Update app.py

app.py

@@ -74,30 +74,21 @@ chunk_sources = []
 def safe_append_to_log(log_entry):
     """Säker metod för att lägga till loggdata utan att förlora historisk information."""
     try:
-        # Öppna filen i append-läge
         with open(log_file_path, "a", encoding="utf-8") as log_file:
             log_json = json.dumps(log_entry)
             log_file.write(log_json + "\n")
-            log_file.flush()  # Säkerställ att data skrivs till disk omedelbart
-            
+            log_file.flush()
         print(f"Loggpost tillagd: {log_entry.get('timestamp', 'okänd tid')}")
         return True
-        
     except Exception as e:
         print(f"Fel vid loggning: {e}")
-        
-        # Försök skapa mappen om den inte finns
         try:
             os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
-            
-            # Försök igen
             with open(log_file_path, "a", encoding="utf-8") as log_file:
                 log_json = json.dumps(log_entry)
                 log_file.write(log_json + "\n")
-                
             print("Loggpost tillagd efter återhämtning")
             return True
-            
         except Exception as retry_error:
             print(f"Kritiskt fel vid loggning: {retry_error}")
             return False
@@ -115,29 +106,25 @@ def load_local_files():
                     with open(file, "r", encoding="utf-8") as f:
                         content = f.read()
                 elif file.endswith(".docx"):
-                    from docx import Document  # Import sker vid behov
+                    from docx import Document
                     content = "\n".join([p.text for p in Document(file).paragraphs])
                 elif file.endswith(".pdf"):
-                    import PyPDF2  # Import sker vid behov
+                    import PyPDF2
                     with open(file, "rb") as f:
                         reader = PyPDF2.PdfReader(f)
                         content = "\n".join([p.extract_text() or "" for p in reader.pages])
                 elif file.endswith(".csv"):
                     content = pd.read_csv(file).to_string()
                 elif file.endswith((".xls", ".xlsx")):
-                    if file == "FAQ stadat.xlsx":
+                    if file == "FAQ stadat.xlsx": # Specific handling for this file
                         df = pd.read_excel(file)
                         rows = []
                         for index, row in df.iterrows():
-                            # Start with the required fields
                             row_text = f"Fråga: {row['Fråga']}\nSvar: {row['Svar']}"
-                            
-                            # Add kategori if it exists in the dataframe
-                            if 'kategori' in df.columns:
+                            if 'kategori' in df.columns and pd.notna(row['kategori']):
                                 row_text += f"\nKategori: {row['kategori']}"
-                            elif 'Kategori' in df.columns:  # Also check for capitalized version
+                            elif 'Kategori' in df.columns and pd.notna(row['Kategori']):
                                 row_text += f"\nKategori: {row['Kategori']}"
-                                
                             rows.append(row_text)
                         content = "\n\n".join(rows)
                     else:
@@ -149,39 +136,41 @@ def load_local_files():
 
 def load_prompt():
     """Läser in system-prompts från prompt.txt med bättre felhantering."""
+    default_prompt = "Du är ChargeNode's AI-assistent. Svara på frågor om ChargeNode's produkter och tjänster baserat på den tillhandahållna informationen."
     try:
         with open("prompt.txt", "r", encoding="utf-8") as f:
             prompt_content = f.read().strip()
             if not prompt_content:
                 print("Varning: prompt.txt är tom, använder standardprompt")
-                return "Du är ChargeNode's AI-assistent. Svara på frågor om ChargeNode's produkter och tjänster baserat på den tillhandahållna informationen."
+                return default_prompt
             return prompt_content
     except FileNotFoundError:
         print("Varning: prompt.txt hittades inte, använder standardprompt")
-        return "Du är ChargeNode's AI-assistent. Svara på frågor om ChargeNode's produkter och tjänster baserat på den tillhandahållna informationen."
+        return default_prompt
     except Exception as e:
         print(f"Fel vid inläsning av prompt.txt: {e}, använder standardprompt")
-        return "Du är ChargeNode's AI-assistent. Svara på frågor om ChargeNode's produkter och tjänster baserat på den tillhandahållna informationen."
+        return default_prompt
 
 # Förbered textsegment
 def prepare_chunks(text_data):
     """Delar upp texten i mindre segment för embedding och sökning."""
-    chunks, sources = [], []
+    chunks_list, sources_list = [], [] # Renamed to avoid conflict with global 'chunks'
     for source, text in text_data.items():
         paragraphs = [p for p in text.split("\n") if p.strip()]
-        chunk = ""
+        current_chunk = ""
         for para in paragraphs:
-            if len(chunk) + len(para) + 1 <= MAX_CHUNK_SIZE:
-                chunk += " " + para
+            if len(current_chunk) + len(para) + 1 <= MAX_CHUNK_SIZE:
+                current_chunk += (" " + para if current_chunk else para)
             else:
-                if chunk.strip():
-                    chunks.append(chunk.strip())
-                    sources.append(source)
-                chunk = para
-        if chunk.strip():
-            chunks.append(chunk.strip())
-            sources.append(source)
-    return chunks, sources
+                if current_chunk.strip():
+                    chunks_list.append(current_chunk.strip())
+                    sources_list.append(source)
+                current_chunk = para
+        if current_chunk.strip(): # Add the last chunk
+            chunks_list.append(current_chunk.strip())
+            sources_list.append(source)
+    return chunks_list, sources_list
+
 
 def initialize_embeddings():
     """Initierar SentenceTransformer och FAISS-index vid första anrop."""
@@ -189,73 +178,123 @@ def initialize_embeddings():
     
     if embedder is None:
         print("Initierar SentenceTransformer och FAISS-index...")
-        # Ladda och förbered lokal data
         print("Laddar textdata...")
         text_data = {"local_files": load_local_files()}
         print("Förbereder textsegment...")
-        chunks, chunk_sources = prepare_chunks(text_data)
+        chunks, chunk_sources = prepare_chunks(text_data) # Assign to global variables
         print(f"{len(chunks)} segment laddade")
 
+        if not chunks:
+            print("Varning: Inga textsegment kunde laddas. RAG kommer inte fungera.")
+            # Initialize with a dummy entry to prevent errors if FAISS needs at least one vector
+            chunks = ["Det finns ingen information tillgänglig just nu."]
+            chunk_sources = ["system_placeholder"]
+            
         print("Skapar embeddings...")
         embedder = SentenceTransformer('all-MiniLM-L6-v2')
-        embeddings = embedder.encode(chunks, convert_to_numpy=True)
-        embeddings /= np.linalg.norm(embeddings, axis=1, keepdims=True)
-        index = faiss.IndexFlatIP(embeddings.shape[1])
-        index.add(embeddings)
-        print("FAISS-index klart")
+        # Ensure chunks is not empty before encoding
+        if chunks:
+            embeddings_np = embedder.encode(chunks, convert_to_numpy=True)
+            if embeddings_np.ndim == 1: # Handle case of single chunk
+                 embeddings_np = embeddings_np.reshape(1, -1)
+            
+            # Normalize embeddings
+            norms = np.linalg.norm(embeddings_np, axis=1, keepdims=True)
+            # Avoid division by zero if a norm is zero
+            norms[norms == 0] = 1e-10 
+            embeddings = embeddings_np / norms
+            
+            index = faiss.IndexFlatIP(embeddings.shape[1])
+            index.add(embeddings)
+            print("FAISS-index klart")
+        else: # Should not happen due to dummy entry, but as a safeguard
+            print("Kritiskt fel: Inga embeddings kunde skapas då inga textsegment fanns.")
+            # Set up dummy index to prevent crashes later, though RAG will be ineffective
+            embedder = SentenceTransformer('all-MiniLM-L6-v2') # ensure embedder is not None
+            dummy_embedding = embedder.encode(["dummy"], convert_to_numpy=True)
+            index = faiss.IndexFlatIP(dummy_embedding.shape[1])
+            index.add(dummy_embedding)
+            embeddings = dummy_embedding # So it's not None
+
 
 def retrieve_context(query, k=RETRIEVAL_K):
     """Hämtar relevant kontext för frågor."""
-    # Säkerställ att modeller är laddade
-    initialize_embeddings()
+    initialize_embeddings() # Ensure models are loaded
     
+    if embedder is None or index is None or not chunks:
+        print("Varning: Embeddings eller index är inte korrekt initierat. Kan inte hämta kontext.")
+        return "", []
+
     query_embedding = embedder.encode([query], convert_to_numpy=True)
-    query_embedding /= np.linalg.norm(query_embedding)
-    D, I = index.search(query_embedding, k)
-    retrieved, sources = [], set()
+    if query_embedding.ndim == 1: # Handle case of single query
+        query_embedding = query_embedding.reshape(1, -1)
+
+    # Normalize query embedding
+    query_norm = np.linalg.norm(query_embedding)
+    if query_norm == 0: query_norm = 1e-10 # Avoid division by zero
+    query_embedding /= query_norm
+    
+    # Ensure k is not greater than the number of items in the index
+    effective_k = min(k, index.ntotal)
+    if effective_k == 0:
+        return "", []
+
+    D, I = index.search(query_embedding, effective_k)
+    retrieved_chunks, sources_set = [], set()
     for idx in I[0]:
-        if idx < len(chunks):
-            retrieved.append(chunks[idx])
-            sources.add(chunk_sources[idx])
-    return " ".join(retrieved), list(sources)
+        if 0 <= idx < len(chunks): # Check index bounds
+            retrieved_chunks.append(chunks[idx])
+            sources_set.add(chunk_sources[idx]) # Ensure chunk_sources has corresponding entries
+    return " ".join(retrieved_chunks), list(sources_set)
 
 # Ladda prompt template
 prompt_template = load_prompt()
 
 def generate_answer(query):
-    """Genererar svar baserat på fråga och retrieval-baserad kontext med Claude Haiku."""
-    # Hämta relevant kontext via RAG istället för hela databasen
+    """Genererar svar baserat på fråga och retrieval-baserad kontext med Claude."""
     context, sources = retrieve_context(query)
     
     if not context.strip():
-        return "Jag hittar ingen relevant information i mina källor.\n\nDetta är ett AI genererat svar."
-    
-    # System-prompts och användarfråga
+        # Default if RAG fails or returns nothing
+        # Try to answer without context or provide a specific message
+        system_prompt_no_context = "Du är ChargeNode's AI-assistent. Försök svara på användarens fråga generellt om ChargeNode även om specifik kontext saknas. Om du inte kan, be användaren kontakta support."
+        user_message_no_context = f"Min fråga är: {query}"
+        try:
+            response = anthropic_client.messages.create(
+                model="claude-3-haiku-20240307", # eller claude-3-opus-20240229 / claude-3-sonnet-20240229
+                max_tokens=500,
+                temperature=0.3,
+                system=system_prompt_no_context,
+                messages=[{"role": "user", "content": user_message_no_context}]
+            )
+            answer = response.content[0].text
+            return answer + "\n\nJag kunde inte hitta specifik information om detta i mina källor, så detta är ett mer generellt AI-genererat svar. Otillräcklig hjälp? Kontakta support@chargenode.eu eller 010-2051055"
+
+        except Exception as e:
+             return f"Jag hittar ingen relevant information i mina källor och ett tekniskt fel uppstod: {str(e)}.\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
+
     system_prompt = prompt_template
-    
-    # Skapa ett renare användarmeddelande med bara den relevanta kontexten
-    user_message = f"""Jag har en fråga om ChargeNode.
+    user_message = f"""Använd endast följande kontext för att svara på frågan. Svara inte på frågor som inte är relaterade till ChargeNode eller elbilsladdning. Om informationen inte finns i kontexten, säg att du inte vet och hänvisa till support.
 
-Relevant kontext för frågan:
+Relevant kontext:
+<kontext>
 {context}
+</kontext>
 
 Min fråga är: {query}"""
     
     try:
-        # Använd Claude Haiku med RAG-baserad kontext
         response = anthropic_client.messages.create(
-            model="claude-3-7-sonnet-20250219",
+            model="claude-3-haiku-20240307", # eller claude-3-opus-20240229 / claude-3-sonnet-20240229
             max_tokens=500,
             temperature=0.3,
             system=system_prompt,
-            messages=[
-                {"role": "user", "content": user_message}
-            ]
+            messages=[{"role": "user", "content": user_message}]
         )
         answer = response.content[0].text
         return answer + "\n\nAI-genererat. Otillräcklig hjälp? Kontakta support@chargenode.eu eller 010-2051055"
     except Exception as e:
-        return f"Tekniskt fel: {str(e)}\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
+        return f"Tekniskt fel vid svarshantering: {str(e)}\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
 
 # --- Slack Integration ---
 def send_to_slack(subject, content, color="#2a9d8f"):
@@ -266,31 +305,13 @@ def send_to_slack(subject, content, color="#2a9d8f"):
         return False
     
     try:
-        # Formatera meddelandet för Slack
         payload = {
             "blocks": [
-                {
-                    "type": "header",
-                    "text": {
-                        "type": "plain_text",
-                        "text": subject
-                    }
-                },
-                {
-                    "type": "section",
-                    "text": {
-                        "type": "mrkdwn",
-                        "text": content
-                    }
-                }
+                {"type": "header", "text": {"type": "plain_text", "text": subject}},
+                {"type": "section", "text": {"type": "mrkdwn", "text": content}}
             ]
         }
-        
-        response = requests.post(
-            webhook_url,
-            json=payload,
-            headers={"Content-Type": "application/json"}
-        )
+        response = requests.post(webhook_url, json=payload, headers={"Content-Type": "application/json"}, timeout=10)
         
         if response.status_code == 200:
             print(f"Slack-meddelande skickat: {subject}")
@@ -304,11 +325,7 @@ def send_to_slack(subject, content, color="#2a9d8f"):
 
 # --- Feedback & Like-funktion ---
 def vote(data: gr.LikeData):
-    """
-    Hanterar feedback från Gradio's inbyggda like-funktion.
-    data.liked är True om uppvote, annars False.
-    data.value innehåller information om meddelandet.
-    """
+    """Hanterar feedback från Gradio's inbyggda like-funktion."""
     feedback_type = "up" if data.liked else "down"
     global last_log
     log_entry = {
@@ -316,39 +333,33 @@ def vote(data: gr.LikeData):
         "feedback": feedback_type,
         "bot_reply": data.value if not isinstance(data.value, dict) else data.value.get("value")
     }
-    # Om global logdata finns, lägg till ytterligare metadata.
-    if last_log:
+    if last_log: # Ensure last_log is not None
         log_entry.update({
             "session_id": last_log.get("session_id"),
             "user_message": last_log.get("user_message"),
         })
     
-    # Använd den förbättrade loggfunktionen
     safe_append_to_log(log_entry)
     
-    # Skicka feedback till Slack
     try:
-        if feedback_type == "down":  # Skicka bara negativ feedback
+        if feedback_type == "down" and last_log: # Only send negative feedback and if context exists
             feedback_message = f"""
 *⚠️ Negativ feedback registrerad*
 
 *Fråga:* {last_log.get('user_message', 'Okänd fråga')}
 
-*Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry.get('bot_reply', '')) > 300 else ''}
+*Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:500]}{'...' if len(log_entry.get('bot_reply', '')) > 500 else ''}
 """
-            # Skicka asynkront
             threading.Thread(
                 target=lambda: send_to_slack("Negativ feedback", feedback_message, "#ff0000"),
                 daemon=True
             ).start()
     except Exception as e:
         print(f"Kunde inte skicka feedback till Slack: {e}")
-    
     return
 
 # --- Rapportering ---
 def read_logs():
-    """Läs alla loggposter från loggfilen."""
     logs = []
     try:
         if os.path.exists(log_file_path):
@@ -360,9 +371,9 @@ def read_logs():
                         log_entry = json.loads(line.strip())
                         logs.append(log_entry)
                     except json.JSONDecodeError as e:
-                        print(f"Varning: Kunde inte tolka rad {line_count}: {e}")
+                        print(f"Varning: Kunde inte tolka rad {line_count} i loggfilen: {e}")
                         continue
-            print(f"Läste {len(logs)} av {line_count} loggposter")
+                print(f"Läste {len(logs)} av {line_count} loggposter från {log_file_path}")
         else:
             print(f"Loggfil saknas: {log_file_path}")
     except Exception as e:
@@ -370,9 +381,8 @@ def read_logs():
     return logs
 
 def get_latest_conversations(logs, limit=50):
-    """Hämta de senaste frågorna och svaren."""
     conversations = []
-    for log in reversed(logs):
+    for log in reversed(logs): # Iterate from newest to oldest
         if 'user_message' in log and 'bot_reply' in log:
             conversations.append({
                 'user_message': log['user_message'],
@@ -383,178 +393,104 @@ def get_latest_conversations(logs, limit=50):
                 break
     return conversations
 
-def get_feedback_stats(logs):
-    """Sammanfatta feedback (tumme upp/ned)."""
-    feedback_count = {"up": 0, "down": 0}
-    negative_feedback_examples = []
-    
-    for log in logs:
-        if 'feedback' in log:
-            feedback = log.get('feedback')
-            if feedback in feedback_count:
-                feedback_count[feedback] += 1
-                
-            # Samla exempel på negativ feedback
-            if feedback == "down" and 'user_message' in log and len(negative_feedback_examples) < 10:
-                negative_feedback_examples.append({
-                    'user_message': log.get('user_message', 'Okänd fråga'),
-                    'bot_reply': log.get('bot_reply', 'Okänt svar')
-                })
-    
-    return feedback_count, negative_feedback_examples
-
 def generate_monthly_stats(days=30):
-    """Genererar omfattande statistik över botanvändning för den senaste månaden."""
     print(f"Genererar statistik för de senaste {days} dagarna...")
-    
-    # Hämta loggar
     logs = read_logs()
-    
-    if not logs:
-        return {"error": "Inga loggar hittades för den angivna perioden"}
-    
-    # Filtrera på datumintervall
+    if not logs: return {"error": "Inga loggar hittades."}
+
     now = datetime.now()
     cutoff_date = now - timedelta(days=days)
-    filtered_logs = []
+    filtered_logs = [
+        log for log in logs if 'timestamp' in log and 
+        datetime.strptime(log['timestamp'], "%Y-%m-%d %H:%M:%S") >= cutoff_date
+        rescue [] # Handle strptime errors gracefully if any
+    ]
+    if not filtered_logs: return {"error": f"Inga loggar hittades för de senaste {days} dagarna."}
     
-    for log in logs:
-        if 'timestamp' in log:
-            try:
-                log_date = datetime.strptime(log['timestamp'], "%Y-%m-%d %H:%M:%S")
-                if log_date >= cutoff_date:
-                    filtered_logs.append(log)
-            except:
-                pass  # Hoppa över poster med ogiltigt datum
-    
-    logs = filtered_logs
-    
-    # Basstatistik
+    logs = filtered_logs # Use filtered logs from now on
+
     total_conversations = sum(1 for log in logs if 'user_message' in log)
-    unique_sessions = len(set(log.get('session_id', 'unknown') for log in logs if 'session_id' in log))
-    unique_users = len(set(log.get('user_id', 'unknown') for log in logs if 'user_id' in log))
+    unique_session_ids = set(log.get('session_id') for log in logs if 'session_id' in log)
+    unique_sessions = len(unique_session_ids)
     
-    # Feedback-statistik
     feedback_logs = [log for log in logs if 'feedback' in log]
     positive_feedback = sum(1 for log in feedback_logs if log.get('feedback') == 'up')
     negative_feedback = sum(1 for log in feedback_logs if log.get('feedback') == 'down')
     feedback_ratio = (positive_feedback / len(feedback_logs) * 100) if feedback_logs else 0
     
-    # Svarstidsstatistik
-    response_times = [log.get('response_time', 0) for log in logs if 'response_time' in log]
+    response_times = [log.get('response_time', 0) for log in logs if 'response_time' in log and isinstance(log.get('response_time'), (int, float))]
     avg_response_time = sum(response_times) / len(response_times) if response_times else 0
-    
-    # Plattformsstatistik
-    platforms = {}
-    browsers = {}
-    operating_systems = {}
-    for log in logs:
-        if 'platform' in log:
-            platforms[log['platform']] = platforms.get(log['platform'], 0) + 1
-        if 'browser' in log:
-            browsers[log['browser']] = browsers.get(log['browser'], 0) + 1
-        if 'os' in log:
-            operating_systems[log['os']] = operating_systems.get(log['os'], 0) + 1
-    
-    # Skapa rapport
+
     report = {
-        "period": f"Senaste {days} dagarna",
-        "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "period": f"Senaste {days} dagarna (till {now.strftime('%Y-%m-%d %H:%M:%S')})",
         "basic_stats": {
             "total_conversations": total_conversations,
             "unique_sessions": unique_sessions,
-            "unique_users": unique_users,
-            "messages_per_user": round(total_conversations / unique_users, 2) if unique_users else 0
         },
         "feedback": {
-            "positive": positive_feedback,
-            "negative": negative_feedback,
+            "positive": positive_feedback, "negative": negative_feedback,
             "ratio_percent": round(feedback_ratio, 1)
         },
-        "performance": {
-            "avg_response_time": round(avg_response_time, 2)
-        },
-        "platform_distribution": platforms,
-        "browser_distribution": browsers,
-        "os_distribution": operating_systems
+        "performance": {"avg_response_time_seconds": round(avg_response_time, 2)}
     }
-    
     return report
 
 def simple_status_report():
-    """Skickar en förenklad statusrapport till Slack."""
     print("Genererar statusrapport för Slack...")
-    
     try:
-        # Generera statistik
-        stats = generate_monthly_stats(days=7)  # Senaste veckan
-        
-        # Skapa innehåll för Slack
-        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        subject = f"ChargeNode AI Bot - Status {now}"
+        stats = generate_monthly_stats(days=1) # Daily stats
+        now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        subject = f"ChargeNode AI Bot - Daglig Status {now_str}"
         
         if 'error' in stats:
             content = f"*Fel vid generering av statistik:* {stats['error']}"
             return send_to_slack(subject, content, "#ff0000")
         
-        # Formatera statistik
         basic = stats["basic_stats"]
         feedback = stats["feedback"]
         perf = stats["performance"]
         
         content = f"""
-*ChargeNode AI Bot - Statusrapport {now}*
+*ChargeNode AI Bot - Daglig Statusrapport ({stats['period']})*
 
-*Basstatistik* (senaste 7 dagarna)
+*Statistik (senaste dygnet)*
 - Totalt antal konversationer: {basic['total_conversations']}
 - Unika sessioner: {basic['unique_sessions']}
-- Unika användare: {basic['unique_users']}
-- Genomsnittlig svarstid: {perf['avg_response_time']} sekunder
+- Genomsnittlig svarstid: {perf['avg_response_time_seconds']} sekunder
 
 *Feedback*
 - 👍 Tumme upp: {feedback['positive']}
 - 👎 Tumme ned: {feedback['negative']}
 - Nöjdhet: {feedback['ratio_percent']}%
 """
-        
-        # Lägg till de senaste konversationerna
-        logs = read_logs()
-        conversations = get_latest_conversations(logs, 3)
-        
+        logs_for_preview = read_logs() # Read all logs for recent conversations
+        conversations = get_latest_conversations(logs_for_preview, 3)
         if conversations:
-            content += "\n*Senaste konversationer*\n"
+            content += "\n*Några av de senaste konversationerna*\n"
             for conv in conversations:
                 content += f"""
 > *Tid:* {conv['timestamp']}
 > *Fråga:* {conv['user_message'][:100]}{'...' if len(conv['user_message']) > 100 else ''}
 > *Svar:* {conv['bot_reply'][:100]}{'...' if len(conv['bot_reply']) > 100 else ''}
 """
-        
-        # Skicka till Slack
         return send_to_slack(subject, content, "#2a9d8f")
-        
     except Exception as e:
-        print(f"Fel vid generering av statusrapport: {e}")
-        
-        # Skicka felmeddelande till Slack
-        error_subject = f"ChargeNode AI Bot - Fel vid statusrapport"
-        error_content = f"*Fel vid generering av statusrapport:* {str(e)}"
+        print(f"Allvarligt fel vid generering av statusrapport: {e}")
+        error_subject = f"ChargeNode AI Bot - KRITISKT FEL vid statusrapport"
+        error_content = f"*Allvarligt fel vid generering av statusrapport:* ```{str(e)}```"
         return send_to_slack(error_subject, error_content, "#ff0000")
 
+
 def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
     """Skickar en supportförfrågan till Slack."""
     try:
-        # Formatera chat-historiken
         chat_content = ""
-        for msg in chat_history:
-            if msg['role'] == 'user':
-                chat_content += f">*Användare:* {msg['content']}\n\n"
-            elif msg['role'] == 'assistant':
-                chat_content += f">*Bot:* {msg['content'][:300]}{'...' if len(msg['content']) > 300 else ''}\n\n"
-        
-        # Skapa innehåll
-        subject = f"Support förfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
-        
+        for msg in chat_history: # chat_history is already in messages format
+            role = msg.get('role', 'unknown').capitalize()
+            content = msg.get('content', '')
+            chat_content += f">{role}: {content[:300]}{'...' if len(content) > 300 else ''}\n\n"
+
+        subject = f"Supportförfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
         content = f"""
 *Användarinformation*
 - *Områdeskod:* {områdeskod or 'Ej angiven'}
@@ -565,9 +501,7 @@ def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
 *Chatthistorik:*
 {chat_content}
 """
-        
-        # Skicka till Slack
-        return send_to_slack(subject, content, "#e76f51")
+        return send_to_slack(subject, content, "#e76f51") # Orange color for support
     except Exception as e:
         print(f"Fel vid sändning av support till Slack: {type(e).__name__}: {e}")
         return False
@@ -575,79 +509,240 @@ def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
 # --- Schemaläggning av rapporter ---
 def run_scheduler():
     """Kör schemaläggaren i en separat tråd med förenklad statusrapportering."""
-    # Använd den förenklade funktionen för rapportering
-    schedule.every().day.at("08:00").do(simple_status_report)
-    schedule.every().day.at("12:00").do(simple_status_report)
-    schedule.every().day.at("17:00").do(simple_status_report)
-    
-    # Veckorapport på måndagar
-    schedule.every().monday.at("09:00").do(lambda: send_to_slack(
-        "Veckostatistik", 
-        f"*ChargeNode AI Bot - Veckostatistik*\n\n{json.dumps(generate_monthly_stats(7), indent=2)}", 
-        "#3498db"
+    schedule.every().day.at("08:00", "Europe/Stockholm").do(simple_status_report)
+    schedule.every().day.at("12:00", "Europe/Stockholm").do(simple_status_report)
+    schedule.every().day.at("17:00", "Europe/Stockholm").do(simple_status_report)
+    
+    schedule.every().monday.at("09:00", "Europe/Stockholm").do(lambda: send_to_slack(
+        "ChargeNode AI - Veckostatistik",  
+        f"*ChargeNode AI Bot - Veckostatistik*\n\n```json\n{json.dumps(generate_monthly_stats(7), indent=2)}\n```",  
+        "#3498db" # Blue color for weekly stats
     ))
     
+    print("Schemaläggare startad. Väntar på schemalagda jobb...")
     while True:
         schedule.run_pending()
-        time.sleep(60)  # Kontrollera varje minut
+        time.sleep(60)
 
-# Starta schemaläggaren i en separat tråd
+# Starta schemaläggaren endast om det inte är en Hugging Face Space med auto-restart
+# eller om en specifik miljövariabel är satt. För nu, starta den alltid.
 scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
 scheduler_thread.start()
 
-# Kör en statusrapport vid uppstart för att verifiera att allt fungerar
-try:
-    print("Skickar en inledande statusrapport för att verifiera Slack-integrationen...")
-    # Anropa inte direkt här - sker i schemaläggaren
-except Exception as e:
-    print(f"Information: Statusrapport kommer att skickas enligt schema: {e}")
-
 # --- Gradio UI ---
 initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
 
 custom_css = """
-body {background-color: #f7f7f7; font-family: Arial, sans-serif; margin: 0; padding: 0;}
-h1 {font-family: Helvetica, sans-serif; color: #2a9d8f; text-align: center; margin-bottom: 0.5em;}
-.gradio-container {max-width: 400px; margin: 0; padding: 10px; position: fixed; bottom: 20px; right: 20px; box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1); border-radius: 10px; background-color: #fff;}
-#chatbot_conversation { max-height: 300px; overflow-y: auto; }
-.gr-button {background-color: #2a9d8f; color: #fff; border: none; border-radius: 4px; padding: 8px 16px; margin: 5px;}
-.gr-button:hover {background-color: #264653;}
-.support-btn {background-color: #000000; color: #ffffff; margin-top: 5px; margin-bottom: 10px;}
-.support-btn:hover {background-color: #333333;}
-.flex-row {display: flex; flex-direction: row; gap: 5px;}
-.gr-form {padding: 10px; border: 1px solid #eee; border-radius: 4px; margin-bottom: 10px;}
-.chat-preview {max-height: 150px; overflow-y: auto; border: 1px solid #eee; padding: 8px; margin-top: 10px; font-size: 12px; background-color: #f9f9f9;}
-.success-message {font-size: 16px; font-weight: normal; margin-bottom: 15px;}
+body, html {
+    background-color: #f7f7f7;
+    font-family: Arial, sans-serif;
+    margin: 0;
+    padding: 0;
+    height: 100%;
+}
+
+/* --- Default styles (Desktop - Floating Widget) --- */
+.gradio-container {
+    max-width: 450px;
+    margin: 0;
+    padding: 0; 
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    box-shadow: 0px 0px 15px rgba(0, 0, 0, 0.15);
+    border-radius: 12px;
+    background-color: #fff;
+    display: flex; 
+    flex-direction: column;
+    height: clamp(70vh, 550px, 85vh);
+    overflow: hidden; 
+}
+
+#chat_interface_main_group, #support_interface_group, #success_interface_group {
+    display: flex;
+    flex-direction: column;
+    flex-grow: 1; 
+    padding: 15px;
+    overflow-y: hidden; 
+}
+#support_interface_group, #success_interface_group {
+     justify-content: center; /* Centrera innehåll i support/success-vyerna */
+}
+
+
+#chatbot_conversation {
+    flex-grow: 1; 
+    overflow-y: auto;
+    min-height: 100px;
+    margin-bottom: 15px; 
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    padding: 10px;
+    background-color: #ffffff; /* Ensure background for chat messages */
+}
+
+.gr-textbox textarea { 
+    border-radius: 6px;
+    padding: 10px;
+    border: 1px solid #ccc;
+    box-sizing: border-box; /* Include padding and border in the element's total width and height */
+    width: 100%; /* Make textarea take full width of its container */
+}
+
+.flex-row {
+    display: flex;
+    flex-direction: row;
+    gap: 10px;
+    align-items: center; 
+    margin-top: 10px; /* Space above button row */
+}
+
+.gr-button {
+    background-color: #2a9d8f;
+    color: #fff;
+    border: none;
+    border-radius: 4px;
+    padding: 10px 16px; 
+    margin: 0; 
+    flex-grow: 1; 
+    text-align: center;
+    cursor: pointer;
+}
+
+.gr-button:hover {
+    background-color: #264653;
+}
+
+.support-btn {
+    background-color: #000000;
+    color: #ffffff;
+}
+.support-btn:hover {
+    background-color: #333333;
+}
+
+#support_interface_group .gr-form { 
+    padding: 10px;
+    border: 1px solid #eee;
+    border-radius: 4px;
+    margin-bottom: 10px;
+    background-color: #f9f9f9;
+}
+#support_interface_group .gr-form label { /* Style labels in support form */
+    margin-bottom: 5px;
+    display: block;
+    font-weight: bold;
+    font-size: 0.9em;
+}
+
+
+.chat-preview {
+    max-height: 150px;
+    overflow-y: auto;
+    border: 1px solid #eee;
+    padding: 8px;
+    margin-top: 10px;
+    font-size: 0.9em; 
+    background-color: #f0f0f0; /* Slightly different background for preview */
+    border-radius: 4px;
+}
+
+.success-message {
+    font-size: 1.1em; 
+    font-weight: normal;
+    text-align: center;
+    padding: 20px;
+}
+.success_interface_group .gr-button { /* Button in success message */
+    flex-grow: 0; /* Don't let it grow unnecessarily */
+    align-self: center; /* Center button */
+}
+
+
 /* Dölj Gradio-footer */
-footer {display: none !important;}
-.footer {display: none !important;}
-.gr-footer {display: none !important;}
-.gradio-footer {display: none !important;}
-.gradio-container .footer {display: none !important;}
-.gradio-container .gr-footer {display: none !important;}
+footer, .footer, .gr-footer, .gradio-footer {
+    display: none !important;
+}
+.gradio-container > .footer { 
+    display: none !important; 
+}
+
+
+/* --- Mobilanpassade stilar --- */
+@media (max-width: 768px) {
+    body, html {
+        overflow: hidden; 
+    }
+
+    .gradio-container {
+        width: 100%;
+        max-width: 100%;
+        height: 100vh; 
+        height: 100dvh; 
+        position: static;
+        border-radius: 0;
+        box-shadow: none;
+        bottom: auto; 
+        right: auto; 
+    }
+
+    #chat_interface_main_group, #support_interface_group, #success_interface_group {
+        padding: 10px; 
+        height: 100%; /* Ensure groups fill the container height */
+        box-sizing: border-box; /* Padding included in height */
+    }
+
+    #chatbot_conversation {
+        margin-bottom: 10px; 
+    }
+
+    .flex-row { /* For buttons */
+        flex-direction: column;
+        gap: 8px;
+        width: 100%; /* Make the column take full width */
+    }
+
+    .flex-row .gr-button {
+        width: 100%; 
+        flex-grow: 0; 
+    }
+    
+    /* For message input row on mobile if it also needs stacking (not typical) */
+    /* Example: if msg textbox was also in a .flex-row */
+    /* #chat_interface_main_group > .gr-row:has(> .gr-textbox) { flex-direction: column; } */
+
+
+    .gradio-app { 
+        height: 100%;
+        min-height: 100%;
+    }
+    
+    /* Adjust main markdown text for mobile if needed */
+    .gradio-container > .gr-markdown { /* Targets the first markdown element if it's a direct child */
+        padding-left: 10px;
+        padding-right: 10px;
+        font-size: 0.95em;
+    }
+}
 """
 
 with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
     gr.Markdown("Ställ din fråga om ChargeNodes produkter och tjänster nedan. Om du inte gillar botten, så ring oss gärna på 010 – 205 10 55")
     
-    # Chat interface
-    with gr.Group(visible=True) as chat_interface:
-        chatbot = gr.Chatbot(value=initial_chat, type="messages", elem_id="chatbot_conversation")
+    with gr.Group(visible=True, elem_id="chat_interface_main_group") as chat_interface:
+        chatbot = gr.Chatbot(value=initial_chat, type="messages", elem_id="chatbot_conversation", bubble_full_width=False)
         chatbot.like(vote, None, None)
         
-        with gr.Row():
-            msg = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...")
+        with gr.Row(): # Row for message input
+            msg = gr.Textbox(label=None, placeholder="Ange din fråga...", scale=1, show_label=False) 
+            # Removed scale to let CSS handle width with .gr-textbox textarea { width: 100%; }
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                clear = gr.Button("Rensa")
-            with gr.Column(scale=1):
-                support_btn = gr.Button("Behöver du mer hjälp?", elem_classes="support-btn")
+        with gr.Row(elem_classes="flex-row"): # Row for buttons
+            clear = gr.Button("Rensa")
+            support_btn = gr.Button("Behöver du mer hjälp?", elem_classes="support-btn")
     
-    # Support form interface (initially hidden)
-    with gr.Group(visible=False) as support_interface:
+    with gr.Group(visible=False, elem_id="support_interface_group") as support_interface:
         gr.Markdown("### Vänligen fyll i din områdeskod, uttagsnummer och din email adress")
-        
         with gr.Group(elem_classes="gr-form"):
             områdeskod = gr.Textbox(label="Områdeskod", placeholder="Områdeskod (valfritt)", info="Numeriskt värde")
             uttagsnummer = gr.Textbox(label="Uttagsnummer", placeholder="Uttagsnummer (valfritt)", info="Numeriskt värde")
@@ -656,107 +751,90 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             gr.Markdown("### Chat som skickas till support:")
             chat_preview = gr.Markdown(elem_classes="chat-preview")
             
-            with gr.Row():
+            with gr.Row(elem_classes="flex-row"): # Buttons in support form
                 back_btn = gr.Button("Tillbaka")
                 send_support_btn = gr.Button("Skicka")
     
-    # Success message (initially hidden)
-    with gr.Group(visible=False) as success_interface:
+    with gr.Group(visible=False, elem_id="success_interface_group") as success_interface:
         gr.Markdown("Tack för att du kontaktar support@chargenode.eu. Vi återkommer inom kort", elem_classes="success-message")
         back_to_chat_btn = gr.Button("Tillbaka till chatten")
     
     def respond(message, chat_history, request: gr.Request):
         global last_log
-        start = time.time()
-        response = generate_answer(message)
-        elapsed = round(time.time() - start, 2)
+        if not message.strip(): # Do not respond to empty messages
+            return "", chat_history
+
+        start_time = time.time() # Renamed for clarity
+        response_text = generate_answer(message) # Renamed for clarity
+        elapsed_time = round(time.time() - start_time, 2) # Renamed for clarity
 
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        session_id = str(uuid.uuid4())
         
-        # Använd session_id från tidigare logg om det finns
-        if last_log and 'session_id' in last_log:
-            session_id = last_log.get('session_id')
-            
-        user_id = request.client.host if request else "okänd"
-
-        ua_str = request.headers.get("user-agent", "")
-        ref = request.headers.get("referer", "")
-        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0]
+        # Session ID logic: try to reuse from last_log if it exists and is recent enough (e.g., within 30 mins)
+        current_session_id = str(uuid.uuid4()) # Default new session_id
+        if last_log and 'session_id' in last_log and 'timestamp' in last_log:
+            try:
+                last_log_time = datetime.strptime(last_log['timestamp'], "%Y-%m-%d %H:%M:%S")
+                if (datetime.now() - last_log_time) < timedelta(minutes=30):
+                    current_session_id = last_log['session_id']
+            except ValueError: # If timestamp format is unexpected
+                pass # Keep new session_id
+
+        user_id = request.client.host if request else "unknown_client"
+        ua_str = request.headers.get("user-agent", "") if request else ""
+        ref = request.headers.get("referer", "") if request else ""
+        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0] if request else user_id.split(",")[0]
+        
         ua = parse_ua(ua_str)
-        browser = f"{ua.browser.family} {ua.browser.version_string}"
-        osys = f"{ua.os.family} {ua.os.version_string}"
+        browser = f"{ua.browser.family} {ua.browser.version_string}" if ua.browser.family else "Unknown Browser"
+        osys = f"{ua.os.family} {ua.os.version_string}" if ua.os.family else "Unknown OS"
 
-        platform = "webb"
-        if "chargenode.eu" in ref:
-            platform = "chargenode.eu"
-        elif "localhost" in ref:
-            platform = "test"
-        elif "app" in ref:
-            platform = "app"
+        platform = "web"
+        if "chargenode.eu" in ref: platform = "chargenode.eu"
+        elif "localhost" in ref: platform = "test"
+        elif "app" in ref: platform = "app" # Assuming 'app' in referer indicates your app environment
 
         log_data = {
-            "timestamp": timestamp,
-            "user_id": user_id,
-            "session_id": session_id,
-            "user_message": message,
-            "bot_reply": response,
-            "response_time": elapsed,
-            "ip": ip,
-            "browser": browser,
-            "os": osys,
-            "platform": platform
+            "timestamp": timestamp, "user_id": user_id, "session_id": current_session_id,
+            "user_message": message, "bot_reply": response_text, "response_time": elapsed_time,
+            "ip": ip, "browser": browser, "os": osys, "platform": platform
         }
-
-        # Använd den förbättrade loggfunktionen
         safe_append_to_log(log_data)
-        last_log = log_data
+        last_log = log_data # Update last_log with the current log
 
-        # Skicka varje konversation direkt till Slack
+        # Slack notification for new conversation (asynchronously)
         try:
-            # Konversationsinnehåll
-            conversation_content = f"""
+            convo_subject = f"Ny konversation ({platform})"
+            convo_content = f"""
 *Ny konversation {timestamp}*
-
 *Användare:* {message}
-
-*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}
-
-*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform}
+*Bot:* {response_text[:300]}{'...' if len(response_text) > 300 else ''}
+*Info:* SessID: ...{current_session_id[-8:]} | {browser} på {osys} | IP: {ip} | Tid: {elapsed_time}s
 """
-            # Skicka asynkront för att inte blockera svarstiden
-            threading.Thread(
-                target=lambda: send_to_slack(f"Ny konversation", conversation_content),
-                daemon=True
-            ).start()
+            threading.Thread(target=lambda: send_to_slack(convo_subject, convo_content), daemon=True).start()
         except Exception as e:
             print(f"Kunde inte skicka konversation till Slack: {e}")
 
         chat_history.append({"role": "user", "content": message})
-        chat_history.append({"role": "assistant", "content": response})
-        return "", chat_history
-    
-    def format_chat_preview(chat_history):
-        if not chat_history:
-            return "Ingen chatthistorik att visa."
+        chat_history.append({"role": "assistant", "content": response_text})
+        return "", chat_history # Clear input field, update chat history
         
+    def format_chat_preview(chat_history_messages): # Parameter renamed for clarity
+        if not chat_history_messages: return "Ingen chatthistorik att visa."
         preview = ""
-        for msg in chat_history:
-            sender = "Användare" if msg["role"] == "user" else "Bot"
-            content = msg["content"]
-            if len(content) > 100:  # Truncate long messages
-                content = content[:100] + "..."
-            preview += f"**{sender}:** {content}\n\n"
-        
+        for msg in chat_history_messages:
+            sender = "Användare" if msg.get("role") == "user" else "Bot"
+            content = msg.get("content", "")
+            preview += f"**{sender}:** {content[:100]}{'...' if len(content) > 100 else ''}\n\n"
         return preview
     
-    def show_support_form(chat_history):
-        preview = format_chat_preview(chat_history)
+    def show_support_form(chat_history_messages):
+        preview_md = format_chat_preview(chat_history_messages)
         return {
             chat_interface: gr.Group(visible=False),
             support_interface: gr.Group(visible=True),
             success_interface: gr.Group(visible=False),
-            chat_preview: preview
+            chat_preview: preview_md # Update the markdown component directly
         }
     
     def back_to_chat():
@@ -766,85 +844,43 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             success_interface: gr.Group(visible=False)
         }
     
-    def submit_support_form(områdeskod, uttagsnummer, email, chat_history):
-        """Hanterar formulärinskickningen med bättre felhantering."""
-        print(f"Support-förfrågan: områdeskod={områdeskod}, uttagsnummer={uttagsnummer}, email={email}")
-        
-        # Validera input med tydligare loggning
+    def submit_support_form(area_code, outlet_number, user_email, chat_history_messages):
         validation_errors = []
-        
-        if områdeskod and not områdeskod.isdigit():
-            print(f"Validerar områdeskod: '{områdeskod}' (felaktig)")
-            validation_errors.append("Områdeskod måste vara numerisk.")
-        else:
-            print(f"Validerar områdeskod: '{områdeskod}' (ok)")
-        
-        if uttagsnummer and not uttagsnummer.isdigit():
-            print(f"Validerar uttagsnummer: '{uttagsnummer}' (felaktig)")
-            validation_errors.append("Uttagsnummer måste vara numerisk.")
-        else:
-            print(f"Validerar uttagsnummer: '{uttagsnummer}' (ok)")
-        
-        if not email:
-            print("Validerar email: (saknas)")
-            validation_errors.append("En giltig e-postadress krävs.")
-        elif '@' not in email or '.' not in email.split('@')[1]:
-            print(f"Validerar email: '{email}' (felaktigt format)")
+        if area_code and not area_code.isdigit(): validation_errors.append("Områdeskod måste vara numerisk.")
+        if outlet_number and not outlet_number.isdigit(): validation_errors.append("Uttagsnummer måste vara numerisk.")
+        if not user_email or '@' not in user_email or '.' not in user_email.split('@')[-1]:
             validation_errors.append("En giltig e-postadress krävs.")
-        else:
-            print(f"Validerar email: '{email}' (ok)")
-        
-        # Om det finns valideringsfel
+
         if validation_errors:
-            print(f"Valideringsfel: {validation_errors}")
-            return {
+            error_md = "**Valideringsfel:**\n" + "\n".join(f"- {err}" for err in validation_errors)
+            return { # Return updates for all relevant components
                 chat_interface: gr.Group(visible=False),
-                support_interface: gr.Group(visible=True),
+                support_interface: gr.Group(visible=True), # Keep support form visible
                 success_interface: gr.Group(visible=False),
-                chat_preview: "\n".join(["**Fel:**"] + validation_errors)
+                chat_preview: error_md # Show errors in the preview area
             }
         
-        # Om formuläret klarade valideringen, försök skicka till Slack
-        try:
-            print("Försöker skicka supportförfrågan till Slack...")
-            
-            # Skapa en förenklad chathistorik för loggning
-            chat_summary = []
-            for msg in chat_history:
-                if 'role' in msg and 'content' in msg:
-                    chat_summary.append(f"{msg['role']}: {msg['content'][:30]}...")
-            print(f"Chatthistorik att skicka: {chat_summary}")
-            
-            # Skicka till Slack
-            success = send_support_to_slack(områdeskod, uttagsnummer, email, chat_history)
-            
-            if success:
-                print("Support-förfrågan skickad till Slack framgångsrikt")
-                return {
-                    chat_interface: gr.Group(visible=False),
-                    support_interface: gr.Group(visible=False),
-                    success_interface: gr.Group(visible=True)
-                }
-            else:
-                print("Support-förfrågan till Slack misslyckades")
-                return {
-                    chat_interface: gr.Group(visible=False),
-                    support_interface: gr.Group(visible=True),
-                    success_interface: gr.Group(visible=False),
-                    chat_preview: "**Ett fel uppstod när meddelandet skulle skickas. Vänligen försök igen senare.**"
-                }
-        except Exception as e:
-            print(f"Oväntat fel vid hantering av support-formulär: {e}")
+        slack_sent = send_support_to_slack(area_code, outlet_number, user_email, chat_history_messages)
+        if slack_sent:
             return {
                 chat_interface: gr.Group(visible=False),
-                support_interface: gr.Group(visible=True),
+                support_interface: gr.Group(visible=False),
+                success_interface: gr.Group(visible=True) # Show success
+            }
+        else:
+            error_md = "**Ett tekniskt fel uppstod när meddelandet skulle skickas. Vänligen försök igen senare eller kontakta support direkt.**"
+            return {
+                chat_interface: gr.Group(visible=False),
+                support_interface: gr.Group(visible=True), # Keep support form visible
                 success_interface: gr.Group(visible=False),
-                chat_preview: f"**Ett fel uppstod: {str(e)}**"
+                chat_preview: error_md # Show submission error
             }
-    
-    msg.submit(respond, [msg, chatbot], [msg, chatbot])
-    clear.click(lambda: None, None, chatbot, queue=False)
-    support_btn.click(show_support_form, chatbot, [chat_interface, support_interface, success_interface, chat_preview])
+
+    # Event handlers
+    msg.submit(respond, [msg, chatbot], [msg, chatbot], api_name="respond") # Added api_name
+    clear.click(lambda: (None, initial_chat[:]), None, [msg, chatbot], queue=False) # Reset chat to initial state
+
+    support_btn.click(show_support_form, [chatbot], [chat_interface, support_interface, success_interface, chat_preview])
     back_btn.click(back_to_chat, None, [chat_interface, support_interface, success_interface])
     back_to_chat_btn.click(back_to_chat, None, [chat_interface, support_interface, success_interface])
     send_support_btn.click(
@@ -859,4 +895,5 @@ initialize_embeddings()
 print("Embedding-modell och index redo!")
 
 if __name__ == "__main__":
-    app.launch(share=True)
+    app.launch(share=IS_HUGGINGFACE) # Share only if IS_HUGGINGFACE is True, otherwise local
+    # For local development, you might want app.launch() or app.launch(share=False)