Update app.py

app.py

@@ -74,21 +74,30 @@ 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()
+            log_file.flush()  # Säkerställ att data skrivs till disk omedelbart
+            
         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
@@ -106,25 +115,29 @@ def load_local_files():
                     with open(file, "r", encoding="utf-8") as f:
                         content = f.read()
                 elif file.endswith(".docx"):
-                    from docx import Document
+                    from docx import Document  # Import sker vid behov
                     content = "\n".join([p.text for p in Document(file).paragraphs])
                 elif file.endswith(".pdf"):
-                    import PyPDF2
+                    import PyPDF2  # Import sker vid behov
                     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": # Specific handling for this file
+                    if file == "FAQ stadat.xlsx":
                         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']}"
-                            if 'kategori' in df.columns and pd.notna(row['kategori']):
+                            
+                            # Add kategori if it exists in the dataframe
+                            if 'kategori' in df.columns:
                                 row_text += f"\nKategori: {row['kategori']}"
-                            elif 'Kategori' in df.columns and pd.notna(row['Kategori']):
+                            elif 'Kategori' in df.columns:  # Also check for capitalized version
                                 row_text += f"\nKategori: {row['Kategori']}"
+                                
                             rows.append(row_text)
                         content = "\n\n".join(rows)
                     else:
@@ -136,41 +149,39 @@ 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 default_prompt
+                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 prompt_content
     except FileNotFoundError:
         print("Varning: prompt.txt hittades inte, använder standardprompt")
-        return default_prompt
+        return "Du är ChargeNode's AI-assistent. Svara på frågor om ChargeNode's produkter och tjänster baserat på den tillhandahållna informationen."
     except Exception as e:
         print(f"Fel vid inläsning av prompt.txt: {e}, använder standardprompt")
-        return default_prompt
+        return "Du är ChargeNode's AI-assistent. Svara på frågor om ChargeNode's produkter och tjänster baserat på den tillhandahållna informationen."
 
 # Förbered textsegment
 def prepare_chunks(text_data):
     """Delar upp texten i mindre segment för embedding och sökning."""
-    chunks_list, sources_list = [], [] # Renamed to avoid conflict with global 'chunks'
+    chunks, sources = [], []
     for source, text in text_data.items():
         paragraphs = [p for p in text.split("\n") if p.strip()]
-        current_chunk = ""
+        chunk = ""
         for para in paragraphs:
-            if len(current_chunk) + len(para) + 1 <= MAX_CHUNK_SIZE:
-                current_chunk += (" " + para if current_chunk else para)
+            if len(chunk) + len(para) + 1 <= MAX_CHUNK_SIZE:
+                chunk += " " + para
             else:
-                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
-
+                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
 
 def initialize_embeddings():
     """Initierar SentenceTransformer och FAISS-index vid första anrop."""
@@ -178,123 +189,73 @@ 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) # Assign to global variables
+        chunks, chunk_sources = prepare_chunks(text_data)
         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')
-        # 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
-
+        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")
 
 def retrieve_context(query, k=RETRIEVAL_K):
     """Hämtar relevant kontext för frågor."""
-    initialize_embeddings() # Ensure models are loaded
+    # Säkerställ att modeller är laddade
+    initialize_embeddings()
     
-    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)
-    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()
+    query_embedding /= np.linalg.norm(query_embedding)
+    D, I = index.search(query_embedding, k)
+    retrieved, sources = [], set()
     for idx in I[0]:
-        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)
+        if idx < len(chunks):
+            retrieved.append(chunks[idx])
+            sources.add(chunk_sources[idx])
+    return " ".join(retrieved), list(sources)
 
 # Ladda prompt template
 prompt_template = load_prompt()
 
 def generate_answer(query):
-    """Genererar svar baserat på fråga och retrieval-baserad kontext med Claude."""
+    """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
     context, sources = retrieve_context(query)
     
     if not context.strip():
-        # 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"
-
+        return "Jag hittar ingen relevant information i mina källor.\n\nDetta är ett AI genererat svar."
+    
+    # System-prompts och användarfråga
     system_prompt = prompt_template
-    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.
+    
+    # Skapa ett renare användarmeddelande med bara den relevanta kontexten
+    user_message = f"""Jag har en fråga om ChargeNode.
 
-Relevant kontext:
-<kontext>
+Relevant kontext för frågan:
 {context}
-</kontext>
 
 Min fråga är: {query}"""
     
     try:
+        # Använd Claude Haiku med RAG-baserad kontext
         response = anthropic_client.messages.create(
-            model="claude-3-haiku-20240307", # eller claude-3-opus-20240229 / claude-3-sonnet-20240229
+            model="claude-3-7-sonnet-20250219",
             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 vid svarshantering: {str(e)}\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
+        return f"Tekniskt fel: {str(e)}\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
 
 # --- Slack Integration ---
 def send_to_slack(subject, content, color="#2a9d8f"):
@@ -305,13 +266,31 @@ 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"}, timeout=10)
+        
+        response = requests.post(
+            webhook_url,
+            json=payload,
+            headers={"Content-Type": "application/json"}
+        )
         
         if response.status_code == 200:
             print(f"Slack-meddelande skickat: {subject}")
@@ -325,7 +304,11 @@ 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."""
+    """
+    Hanterar feedback från Gradio's inbyggda like-funktion.
+    data.liked är True om uppvote, annars False.
+    data.value innehåller information om meddelandet.
+    """
     feedback_type = "up" if data.liked else "down"
     global last_log
     log_entry = {
@@ -333,33 +316,39 @@ def vote(data: gr.LikeData):
         "feedback": feedback_type,
         "bot_reply": data.value if not isinstance(data.value, dict) else data.value.get("value")
     }
-    if last_log: # Ensure last_log is not None
+    # Om global logdata finns, lägg till ytterligare metadata.
+    if last_log:
         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" and last_log: # Only send negative feedback and if context exists
+        if feedback_type == "down":  # Skicka bara negativ feedback
             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')[:500]}{'...' if len(log_entry.get('bot_reply', '')) > 500 else ''}
+*Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry.get('bot_reply', '')) > 300 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):
@@ -371,9 +360,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} i loggfilen: {e}")
+                        print(f"Varning: Kunde inte tolka rad {line_count}: {e}")
                         continue
-                print(f"Läste {len(logs)} av {line_count} loggposter från {log_file_path}")
+            print(f"Läste {len(logs)} av {line_count} loggposter")
         else:
             print(f"Loggfil saknas: {log_file_path}")
     except Exception as e:
@@ -381,8 +370,9 @@ 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): # Iterate from newest to oldest
+    for log in reversed(logs):
         if 'user_message' in log and 'bot_reply' in log:
             conversations.append({
                 'user_message': log['user_message'],
@@ -393,117 +383,178 @@ 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."}
-
+    
+    if not logs:
+        return {"error": "Inga loggar hittades för den angivna perioden"}
+    
+    # Filtrera på datumintervall
     now = datetime.now()
     cutoff_date = now - timedelta(days=days)
+    filtered_logs = []
     
-    filtered_logs = [] # Korrekt lista för filtrerade loggar
-    for log_entry in logs: # Byt namn på loopvariabel för tydlighet
-        if 'timestamp' in log_entry and isinstance(log_entry['timestamp'], str):
+    for log in logs:
+        if 'timestamp' in log:
             try:
-                log_date = datetime.strptime(log_entry['timestamp'], "%Y-%m-%d %H:%M:%S")
+                log_date = datetime.strptime(log['timestamp'], "%Y-%m-%d %H:%M:%S")
                 if log_date >= cutoff_date:
-                    filtered_logs.append(log_entry)
-            except ValueError:
-                # Ignorera loggposter med felaktigt formaterad tidsstämpel
-                # print(f"Varning: Felaktigt tidsstämpelformat för logg: {log_entry.get('session_id', 'N/A')}, timestamp: {log_entry['timestamp']}")
-                pass 
-        # Loggposter utan tidsstämpel eller med fel typ ignoreras också implicit
-
-    if not filtered_logs: 
-        return {"error": f"Inga giltiga loggar hittades för de senaste {days} dagarna."}
+                    filtered_logs.append(log)
+            except:
+                pass  # Hoppa över poster med ogiltigt datum
     
-    logs = filtered_logs # Använd de korrekt filtrerade loggarna
-
+    logs = filtered_logs
+    
+    # Basstatistik
     total_conversations = sum(1 for log in logs if 'user_message' in log)
-    # Använd get() med default None för session_id för att undvika KeyError om nyckeln saknas
-    unique_session_ids = set(log.get('session_id') for log in logs) 
-    # Ta bort None från set om det finns med, eftersom det inte representerar en giltig session
-    unique_session_ids.discard(None) 
-    unique_sessions = len(unique_session_ids)
+    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))
     
+    # 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
     
-    response_times = [log.get('response_time', 0) for log in logs if 'response_time' in log and isinstance(log.get('response_time'), (int, float))]
+    # Svarstidsstatistik
+    response_times = [log.get('response_time', 0) for log in logs if 'response_time' in log]
     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 (till {now.strftime('%Y-%m-%d %H:%M:%S')})",
+        "period": f"Senaste {days} dagarna",
+        "generated_at": datetime.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_seconds": round(avg_response_time, 2)}
+        "performance": {
+            "avg_response_time": round(avg_response_time, 2)
+        },
+        "platform_distribution": platforms,
+        "browser_distribution": browsers,
+        "os_distribution": operating_systems
     }
+    
     return report
 
 def simple_status_report():
+    """Skickar en förenklad statusrapport till Slack."""
     print("Genererar statusrapport för Slack...")
+    
     try:
-        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}"
+        # 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}"
         
         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 - Daglig Statusrapport ({stats['period']})*
+*ChargeNode AI Bot - Statusrapport {now}*
 
-*Statistik (senaste dygnet)*
+*Basstatistik* (senaste 7 dagarna)
 - Totalt antal konversationer: {basic['total_conversations']}
 - Unika sessioner: {basic['unique_sessions']}
-- Genomsnittlig svarstid: {perf['avg_response_time_seconds']} sekunder
+- Unika användare: {basic['unique_users']}
+- Genomsnittlig svarstid: {perf['avg_response_time']} sekunder
 
 *Feedback*
 - 👍 Tumme upp: {feedback['positive']}
 - 👎 Tumme ned: {feedback['negative']}
 - Nöjdhet: {feedback['ratio_percent']}%
 """
-        logs_for_preview = read_logs() # Read all logs for recent conversations
-        conversations = get_latest_conversations(logs_for_preview, 3)
+        
+        # Lägg till de senaste konversationerna
+        logs = read_logs()
+        conversations = get_latest_conversations(logs, 3)
+        
         if conversations:
-            content += "\n*Några av de senaste konversationerna*\n"
+            content += "\n*Senaste konversationer*\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"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)}```"
+        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)}"
         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: # 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')}"
+        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')}"
+        
         content = f"""
 *Användarinformation*
 - *Områdeskod:* {områdeskod or 'Ej angiven'}
@@ -514,7 +565,9 @@ def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
 *Chatthistorik:*
 {chat_content}
 """
-        return send_to_slack(subject, content, "#e76f51") # Orange color for support
+        
+        # Skicka till Slack
+        return send_to_slack(subject, content, "#e76f51")
     except Exception as e:
         print(f"Fel vid sändning av support till Slack: {type(e).__name__}: {e}")
         return False
@@ -522,522 +575,282 @@ 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."""
-    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
+    # 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"
     ))
     
-    print("Schemaläggare startad. Väntar på schemalagda jobb...")
     while True:
         schedule.run_pending()
-        time.sleep(60)
+        time.sleep(60)  # Kontrollera varje minut
 
-# 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.
+# Starta schemaläggaren i en separat tråd
 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?"}]
 
-# FÖRBÄTTRAD CSS MED KORREKT VISIBILITY OCH MOBILSUPPORT
 custom_css = """
-/* Reset och grundläggande stilar */
-* {
-    box-sizing: border-box;
-}
-
-body, html {
-    margin: 0;
-    padding: 0;
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-    background-color: #f8f9fa;
-    height: 100%;
-    overflow: hidden;
-}
-
-/* Huvudcontainer - anpassar sig efter iframe */
-.gradio-container {
-    width: 100% !important;
-    height: 100vh !important;
-    max-width: none !important;
-    margin: 0 !important;
-    padding: 0 !important;
-    border-radius: 0 !important;
-    box-shadow: none !important;
-    position: relative;
-    display: flex;
-    flex-direction: column;
-    background-color: #ffffff;
-}
-
-/* Huvud-grupper */
-#chat_interface_main_group,
-#support_interface_group, 
-#success_interface_group {
-    display: flex;
-    flex-direction: column;
-    height: 100%;
-    padding: 16px;
-    overflow: hidden;
-}
-
-/* KORREKT HANTERING AV VISIBILITY */
-#chat_interface_main_group.hidden,
-#support_interface_group.hidden,
-#success_interface_group.hidden {
-    display: none !important;
-    visibility: hidden !important;
-}
-
-/* Chatbot-område */
-#chatbot_conversation {
-    flex: 1;
-    min-height: 300px;
-    margin-bottom: 16px;
-    border: 1px solid #e9ecef;
-    border-radius: 8px;
-    background-color: #ffffff;
-    overflow-y: auto;
-    padding: 12px;
-}
-
-/* Meddelande-input */
-.message-input-container {
-    margin-bottom: 12px;
-}
-
-.message-input-container .gr-textbox {
-    margin: 0;
-}
-
-.message-input-container .gr-textbox textarea {
-    border-radius: 8px;
-    border: 2px solid #e9ecef;
-    padding: 12px;
-    font-size: 14px;
-    resize: none;
-    transition: border-color 0.2s ease;
-}
-
-.message-input-container .gr-textbox textarea:focus {
-    border-color: #2a9d8f;
-    outline: none;
-    box-shadow: 0 0 0 3px rgba(42, 157, 143, 0.1);
-}
-
-/* Knappar */
-.button-row {
-    display: flex;
-    gap: 8px;
-    flex-wrap: wrap;
-}
-
-.gr-button {
-    flex: 1;
-    min-width: 120px;
-    padding: 12px 16px;
-    border: none;
-    border-radius: 6px;
-    font-weight: 500;
-    font-size: 14px;
-    cursor: pointer;
-    transition: all 0.2s ease;
-    background-color: #2a9d8f;
-    color: white;
-}
-
-.gr-button:hover {
-    background-color: #238277;
-    transform: translateY(-1px);
-}
-
-.gr-button.support-btn {
-    background-color: #495057;
-}
-
-.gr-button.support-btn:hover {
-    background-color: #343a40;
-}
-
-/* Support-formulär */
-#support_interface_group {
-    justify-content: flex-start;
-    padding-top: 20px;
-}
-
-.support-form {
-    background-color: #f8f9fa;
-    padding: 20px;
-    border-radius: 8px;
-    border: 1px solid #dee2e6;
-    margin-bottom: 16px;
-}
-
-.support-form .gr-textbox {
-    margin-bottom: 12px;
-}
-
-.support-form .gr-textbox label {
-    font-weight: 600;
-    color: #495057;
-    margin-bottom: 4px;
-    display: block;
-}
-
-.support-form .gr-textbox textarea,
-.support-form .gr-textbox input {
-    border: 1px solid #ced4da;
-    border-radius: 4px;
-    padding: 8px 12px;
-    width: 100%;
-}
-
-/* Chat-förhandsvisning */
-.chat-preview {
-    max-height: 200px;
-    overflow-y: auto;
-    background-color: #f8f9fa;
-    border: 1px solid #dee2e6;
-    border-radius: 4px;
-    padding: 12px;
-    font-size: 13px;
-    line-height: 1.4;
-    margin-top: 12px;
-}
-
-/* Success-meddelande */
-#success_interface_group {
-    justify-content: center;
-    align-items: center;
-    text-align: center;
-}
-
-.success-message {
-    font-size: 18px;
-    color: #198754;
-    margin-bottom: 24px;
-    padding: 20px;
-    background-color: #d1e7dd;
-    border: 1px solid #badbcc;
-    border-radius: 8px;
-}
-
-/* Dölj Gradio footer */
-footer, .footer, .gr-footer, .gradio-footer {
-    display: none !important;
-}
-
-/* --- MOBILANPASSNINGAR --- */
-@media (max-width: 768px) {
-    .gradio-container {
-        height: 100vh !important;
-        height: 100dvh !important;
-    }
-    
-    #chat_interface_main_group,
-    #support_interface_group, 
-    #success_interface_group {
-        padding: 12px;
-    }
-    
-    #chatbot_conversation {
-        min-height: 250px;
-        margin-bottom: 12px;
-        padding: 8px;
-    }
-    
-    .message-input-container .gr-textbox textarea {
-        font-size: 16px; /* Förhindrar zoom på iOS */
-        padding: 12px;
-    }
-    
-    .button-row {
-        flex-direction: column;
-        gap: 8px;
-    }
-    
-    .gr-button {
-        width: 100%;
-        min-width: unset;
-        padding: 14px 16px;
-        font-size: 16px;
-    }
-    
-    .support-form {
-        padding: 16px;
-        margin-bottom: 12px;
-    }
-    
-    .chat-preview {
-        max-height: 150px;
-        font-size: 12px;
-    }
-    
-    .success-message {
-        font-size: 16px;
-        padding: 16px;
-        margin-bottom: 20px;
-    }
-}
-
-/* --- EXTRA SMÅ SKÄRMAR --- */
-@media (max-width: 480px) {
-    #chat_interface_main_group,
-    #support_interface_group, 
-    #success_interface_group {
-        padding: 8px;
-    }
-    
-    #chatbot_conversation {
-        margin-bottom: 8px;
-        padding: 6px;
-    }
-    
-    .support-form {
-        padding: 12px;
-    }
-}
-
-/* IFRAME-SPECIFIKA JUSTERINGAR */
-body.iframe-embedded {
-    overflow: hidden;
-}
-
-body.iframe-embedded .gradio-container {
-    border: none;
-    border-radius: 0;
-}
+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;}
+/* 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;}
 """
 
-with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst", theme=gr.themes.Soft()) as app:
-    # State för att hantera aktuell vy
-    current_view = gr.State("chat")  # "chat", "support", "success"
-    
-    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**", elem_classes=["header-text"])
+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, 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,
-            show_copy_button=True
-        )
+    # Chat interface
+    with gr.Group(visible=True) as chat_interface:
+        chatbot = gr.Chatbot(value=initial_chat, type="messages", elem_id="chatbot_conversation")
         chatbot.like(vote, None, None)
         
-        with gr.Group(elem_classes=["message-input-container"]):
-            msg = gr.Textbox(
-                label=None, 
-                placeholder="Ange din fråga...", 
-                show_label=False,
-                lines=2,
-                max_lines=4
-            )
+        with gr.Row():
+            msg = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...")
         
-        with gr.Group(elem_classes=["button-row"]):
-            clear = gr.Button("Rensa chat", variant="secondary")
-            support_btn = gr.Button("Behöver du mer hjälp?", elem_classes=["support-btn"])
-    
-    # Support Interface  
-    with gr.Group(visible=False, elem_id="support_interface_group") as support_interface:
+        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")
+    
+    # Support form interface (initially hidden)
+    with gr.Group(visible=False) as support_interface:
         gr.Markdown("### Vänligen fyll i din områdeskod, uttagsnummer och din email adress")
         
-        with gr.Group(elem_classes=["support-form"]):
-            områdeskod = gr.Textbox(
-                label="Områdeskod (valfritt)", 
-                placeholder="Områdeskod", 
-                info="Numeriskt värde"
-            )
-            uttagsnummer = gr.Textbox(
-                label="Uttagsnummer (valfritt)", 
-                placeholder="Uttagsnummer", 
-                info="Numeriskt värde"
-            )
-            email = gr.Textbox(
-                label="Din email adress", 
-                placeholder="din@email.se", 
-                info="Email adress krävs"
-            )
+        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")
+            email = gr.Textbox(label="Din email adress", placeholder="din@email.se", info="Email adress krävs")
             
             gr.Markdown("### Chat som skickas till support:")
-            chat_preview = gr.Markdown("", elem_classes=["chat-preview"])
+            chat_preview = gr.Markdown(elem_classes="chat-preview")
             
-            with gr.Group(elem_classes=["button-row"]):
-                back_btn = gr.Button("Tillbaka", variant="secondary")
-                send_support_btn = gr.Button("Skicka till support", variant="primary")
+            with gr.Row():
+                back_btn = gr.Button("Tillbaka")
+                send_support_btn = gr.Button("Skicka")
     
-    # 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", variant="primary")
+    # Success message (initially hidden)
+    with gr.Group(visible=False) 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
-        if not message.strip():
-            return "", chat_history
-
-        start_time = time.time()
-        response_text = generate_answer(message)
-        elapsed_time = round(time.time() - start_time, 2)
+        start = time.time()
+        response = generate_answer(message)
+        elapsed = round(time.time() - start, 2)
 
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        session_id = str(uuid.uuid4())
         
-        current_session_id = str(uuid.uuid4())
-        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:
-                pass
+        # 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"
 
-        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_str = request.headers.get("user-agent", "")
+        ref = request.headers.get("referer", "")
+        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0]
         ua = parse_ua(ua_str)
-        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"
+        browser = f"{ua.browser.family} {ua.browser.version_string}"
+        osys = f"{ua.os.family} {ua.os.version_string}"
 
-        platform = "web"
-        if "chargenode.eu" in ref: platform = "chargenode.eu"
-        elif "localhost" in ref: platform = "test"
-        elif "app" in ref: platform = "app"
+        platform = "webb"
+        if "chargenode.eu" in ref:
+            platform = "chargenode.eu"
+        elif "localhost" in ref:
+            platform = "test"
+        elif "app" in ref:
+            platform = "app"
 
         log_data = {
-            "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
+            "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
         }
+
+        # Använd den förbättrade loggfunktionen
         safe_append_to_log(log_data)
         last_log = log_data
 
+        # Skicka varje konversation direkt till Slack
         try:
-            convo_subject = f"Ny konversation ({platform})"
-            convo_content = f"""
+            # Konversationsinnehåll
+            conversation_content = f"""
 *Ny konversation {timestamp}*
+
 *Användare:* {message}
-*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
+
+*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}
+
+*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform}
 """
-            threading.Thread(target=lambda: send_to_slack(convo_subject, convo_content), daemon=True).start()
+            # Skicka asynkront för att inte blockera svarstiden
+            threading.Thread(
+                target=lambda: send_to_slack(f"Ny konversation", conversation_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_text})
+        chat_history.append({"role": "assistant", "content": response})
         return "", chat_history
-        
-    def format_chat_preview(chat_history_messages):
-        if not chat_history_messages: 
+    
+    def format_chat_preview(chat_history):
+        if not chat_history:
             return "Ingen chatthistorik att visa."
+        
         preview = ""
-        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"
+        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"
+        
         return preview
     
-    def show_support_form(chat_history_messages, current_view_state):
-        preview_md = format_chat_preview(chat_history_messages)
+    def show_support_form(chat_history):
+        preview = format_chat_preview(chat_history)
         return {
             chat_interface: gr.Group(visible=False),
             support_interface: gr.Group(visible=True),
             success_interface: gr.Group(visible=False),
-            chat_preview: preview_md,
-            current_view: "support"
+            chat_preview: preview
         }
     
-    def back_to_chat(current_view_state):
+    def back_to_chat():
         return {
             chat_interface: gr.Group(visible=True),
             support_interface: gr.Group(visible=False),
-            success_interface: gr.Group(visible=False),
-            current_view: "chat"
+            success_interface: gr.Group(visible=False)
         }
     
-    def submit_support_form(area_code, outlet_number, user_email, chat_history_messages, current_view_state):
+    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
         validation_errors = []
-        if area_code and not area_code.isdigit(): 
+        
+        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.")
-        if outlet_number and not outlet_number.isdigit(): 
+        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.")
-        if not user_email or '@' not in user_email or '.' not in user_email.split('@')[-1]:
+        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)")
+            validation_errors.append("En giltig e-postadress krävs.")
+        else:
+            print(f"Validerar email: '{email}' (ok)")
+        
+        # Om det finns valideringsfel
         if validation_errors:
-            error_md = "**Valideringsfel:**\n" + "\n".join(f"- {err}" for err in validation_errors)
+            print(f"Valideringsfel: {validation_errors}")
             return {
                 chat_interface: gr.Group(visible=False),
                 support_interface: gr.Group(visible=True),
                 success_interface: gr.Group(visible=False),
-                chat_preview: error_md,
-                current_view: "support"
+                chat_preview: "\n".join(["**Fel:**"] + validation_errors)
             }
         
-        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=False),
-                success_interface: gr.Group(visible=True),
-                current_view: "success"
-            }
-        else:
-            error_md = "**Ett tekniskt fel uppstod när meddelandet skulle skickas. Vänligen försök igen senare eller kontakta support direkt.**"
+        # 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}")
             return {
                 chat_interface: gr.Group(visible=False),
                 support_interface: gr.Group(visible=True),
                 success_interface: gr.Group(visible=False),
-                chat_preview: error_md,
-                current_view: "support"
+                chat_preview: f"**Ett fel uppstod: {str(e)}**"
             }
-
-    # Event handlers med korrekt state management
-    msg.submit(
-        respond, 
-        [msg, chatbot], 
-        [msg, chatbot], 
-        api_name="respond"
-    )
-    
-    clear.click(
-        lambda: (None, initial_chat[:]), 
-        None, 
-        [msg, chatbot], 
-        queue=False
-    )
-
-    support_btn.click(
-        show_support_form, 
-        [chatbot, current_view], 
-        [chat_interface, support_interface, success_interface, chat_preview, current_view]
-    )
-    
-    back_btn.click(
-        back_to_chat, 
-        [current_view], 
-        [chat_interface, support_interface, success_interface, current_view]
-    )
-    
-    back_to_chat_btn.click(
-        back_to_chat, 
-        [current_view], 
-        [chat_interface, support_interface, success_interface, current_view]
-    )
     
+    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])
+    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(
         submit_support_form, 
-        [områdeskod, uttagsnummer, email, chatbot, current_view], 
-        [chat_interface, support_interface, success_interface, chat_preview, current_view]
+        [områdeskod, uttagsnummer, email, chatbot], 
+        [chat_interface, support_interface, success_interface, chat_preview]
     )
 
 # Initialisera embeddings vid uppstart
@@ -1046,9 +859,4 @@ initialize_embeddings()
 print("Embedding-modell och index redo!")
 
 if __name__ == "__main__":
-    app.launch(
-        share=IS_HUGGINGFACE,
-        server_name="0.0.0.0" if IS_HUGGINGFACE else "127.0.0.1",
-        show_error=True,
-        show_api=False
-    )
+    app.launch(share=True)