Update app.py

app.py

@@ -39,22 +39,29 @@ if not os.path.exists(log_file_path):
     print(f"Skapade tom loggfil: {log_file_path}")
 
 hf_token = os.environ.get("HF_TOKEN")
-if not hf_token:
-    raise ValueError("HF_TOKEN saknas")
+# Validera HF_TOKEN endast om vi är i Hugging Face-miljön
+if IS_HUGGINGFACE and not hf_token:
+    raise ValueError("HF_TOKEN saknas (krävs i Hugging Face-miljön)")
 
-# Minsta möjliga konfiguration som bör fungera
-scheduler = CommitScheduler(
-    repo_id="ChargeNodeEurope/logfiles",
-    repo_type="dataset",
-    folder_path=log_folder,
-    path_in_repo="logs_v2",
-    every=300,  # Vänta 5 minuter
-    token=hf_token
-)
+# Konfigurera CommitScheduler endast om vi är i Hugging Face-miljön
+if IS_HUGGINGFACE and hf_token:
+    scheduler = CommitScheduler(
+        repo_id="ChargeNodeEurope/logfiles",
+        repo_type="dataset",
+        folder_path=log_folder,
+        path_in_repo="logs_v2",
+        every=300,  # Vänta 5 minuter
+        token=hf_token
+    )
+else:
+    scheduler = None # Ingen schemaläggare om inte på Hugging Face
+    print("Kör lokalt eller HF_TOKEN saknas, CommitScheduler är inte aktiv.")
 
 
 # --- Globala variabler ---
 last_log = None  # Sparar loggdata från senaste svar för feedback
+chunks = [] # Definiera globalt så de är tillgängliga
+chunk_sources = [] # Definiera globalt så de är tillgängliga
 
 # --- Förbättrad loggfunktion ---
 def safe_append_to_log(log_entry):
@@ -62,28 +69,28 @@ def safe_append_to_log(log_entry):
     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_json = json.dumps(log_entry, ensure_ascii=False) # ensure_ascii=False för svenska tecken
             log_file.write(log_json + "\n")
             log_file.flush()  # Säkerställ att data skrivs till disk omedelbart
-            
-        print(f"Loggpost tillagd: {log_entry.get('timestamp', 'okänd tid')}")
+
+        # print(f"Loggpost tillagd: {log_entry.get('timestamp', 'okänd tid')}") # Kan bli för mycket output
         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_json = json.dumps(log_entry, ensure_ascii=False)
                 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
@@ -92,67 +99,135 @@ def safe_append_to_log(log_entry):
 def load_local_files():
     uploaded_text = ""
     allowed = [".txt", ".docx", ".pdf", ".csv", ".xls", ".xlsx"]
-    excluded = ["requirements.txt", "app.py", "conversation_log.txt", "conversation_log_v2.txt", "secrets"]
-    for file in os.listdir("."):
-        if file.lower().endswith(tuple(allowed)) and file not in excluded:
+    # Förenklad exkluderingslista för att undvika problem med exakta filnamn
+    excluded_prefixes = ["requirements", "app", "conversation_log", "secrets"]
+    current_dir = os.path.dirname(os.path.abspath(__file__)) if '__file__' in locals() else '.' # Hämta aktuell mapp
+
+    for item in os.listdir(current_dir):
+        # Kontrollera om det är en fil och inte en katalog
+        item_path = os.path.join(current_dir, item)
+        if not os.path.isfile(item_path):
+            continue
+
+        if item.lower().endswith(tuple(allowed)) and not any(item.lower().startswith(prefix) for prefix in excluded_prefixes):
+            print(f"Läser fil: {item}")
             try:
-                if file.endswith(".txt"):
-                    with open(file, "r", encoding="utf-8") as f:
+                if item.endswith(".txt"):
+                    with open(item_path, "r", encoding="utf-8") as f:
                         content = f.read()
-                elif file.endswith(".docx"):
-                    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 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":
-                        df = pd.read_excel(file)
-                        rows = []
-                        for index, row in df.iterrows():
-                            rows.append(f"Fråga: {row['Fråga']}\nSvar: {row['Svar']}")
-                        content = "\n\n".join(rows)
-                    else:
-                        content = pd.read_excel(file).to_string()
-                uploaded_text += f"\n\nFIL: {file}\n{content}"
+                elif item.endswith(".docx"):
+                    try:
+                        from docx import Document  # Import sker vid behov
+                        content = "\n".join([p.text for p in Document(item_path).paragraphs])
+                    except ImportError:
+                        print("Varning: 'python-docx' behövs för att läsa .docx-filer. Installera med 'pip install python-docx'.")
+                        content = ""
+                elif item.endswith(".pdf"):
+                    try:
+                        import PyPDF2  # Import sker vid behov
+                        content = ""
+                        with open(item_path, "rb") as f:
+                             # Korrigerad PdfReader anrop
+                            reader = PyPDF2.PdfReader(f)
+                            for page in reader.pages:
+                                text = page.extract_text()
+                                if text: # Lägg bara till om text extraherades
+                                    content += text + "\n"
+                    except ImportError:
+                        print("Varning: 'PyPDF2' behövs för att läsa .pdf-filer. Installera med 'pip install pypdf2'.")
+                        content = ""
+                    except Exception as pdf_error: # Fånga specifika PDF-läsningsfel
+                         print(f"Fel vid läsning av PDF {item}: {str(pdf_error)}")
+                         content = ""
+                elif item.endswith(".csv"):
+                     try:
+                        content = pd.read_csv(item_path).to_string()
+                     except pd.errors.EmptyDataError:
+                         print(f"Varning: CSV-filen {item} är tom.")
+                         content = ""
+                     except Exception as csv_err:
+                         print(f"Fel vid läsning av CSV {item}: {csv_err}")
+                         content = ""
+                elif item.endswith((".xls", ".xlsx")):
+                    try:
+                        if item == "FAQ stadat.xlsx": # Hårdkodat filnamn - kan vara skört
+                            df = pd.read_excel(item_path)
+                            rows = []
+                            # Säkerställ att kolumnerna finns
+                            if 'Fråga' in df.columns and 'Svar' in df.columns:
+                                for index, row in df.iterrows():
+                                    rows.append(f"Fråga: {row['Fråga']}\nSvar: {row['Svar']}")
+                                content = "\n\n".join(rows)
+                            else:
+                                print(f"Varning: Kolumner 'Fråga' eller 'Svar' saknas i {item}. Läser som vanlig Excel.")
+                                content = pd.read_excel(item_path).to_string()
+                        else:
+                            content = pd.read_excel(item_path).to_string()
+                    except Exception as excel_err:
+                        print(f"Fel vid läsning av Excel {item}: {excel_err}")
+                        content = ""
+
+                if content: # Lägg bara till om innehåll finns
+                    uploaded_text += f"\n\nFIL: {item}\n{content}"
+
             except Exception as e:
-                print(f"Fel vid läsning av {file}: {str(e)}")
+                print(f"Allmänt fel vid läsning av {item}: {str(e)}")
     return uploaded_text.strip()
 
 def load_prompt():
     try:
-        with open("prompt.txt", "r", encoding="utf-8") as f:
+        prompt_path = os.path.join(os.path.dirname(os.path.abspath(__file__)) if '__file__' in locals() else '.', "prompt.txt")
+        with open(prompt_path, "r", encoding="utf-8") as f:
             return f.read().strip()
+    except FileNotFoundError:
+        print(f"Varning: prompt.txt hittades inte. Använder tom prompt.")
+        return ""
     except Exception as e:
-        print(f"Fel vid prompt.txt: {e}")
+        print(f"Fel vid läsning av prompt.txt: {e}")
         return ""
 
 prompt_template = load_prompt()
 
 # Förbered textsegment
 def prepare_chunks(text_data):
+    global chunks, chunk_sources # Uppdatera globala variabler
     chunks, sources = [], []
     for source, text in text_data.items():
-        paragraphs = [p for p in text.split("\n") if p.strip()]
-        chunk = ""
+        if not isinstance(text, str): # Säkerställ att text är en sträng
+            print(f"Varning: Ogiltig textdata för källa '{source}'. Hoppar över.")
+            continue
+        # Dela på dubbla radbrytningar först, sedan enkla
+        paragraphs = [p.strip() for p in text.replace('\n\n', '---PARAGRAPH---').replace('\n', ' ').split('---PARAGRAPH---') if p.strip()]
+        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())
+                # Lägg till föregående chunk om den inte är tom
+                if current_chunk:
+                    chunks.append(current_chunk)
+                    sources.append(source)
+                # Starta en ny chunk (se till att den inte överskrider maxstorleken direkt)
+                if len(para) <= MAX_CHUNK_SIZE:
+                    current_chunk = para
+                else:
+                    # Om en enskild paragraf är för lång, dela upp den
+                    # (Enkel strategi: dela vid MAX_CHUNK_SIZE)
+                    chunks.append(para[:MAX_CHUNK_SIZE])
                     sources.append(source)
-                chunk = para
-        if chunk.strip():
-            chunks.append(chunk.strip())
+                    # Hantera resten av paragrafen i nästa iteration (om det behövs mer logik)
+                    current_chunk = para[MAX_CHUNK_SIZE:] # Eller hantera detta mer robust
+
+        # Lägg till den sista chunken om den inte är tom
+        if current_chunk:
+            chunks.append(current_chunk)
             sources.append(source)
-    return chunks, sources
 
-    # Lazy-laddning av SentenceTransformer
+    # Uppdatera de globala variablerna
+    chunk_sources = sources
+    return chunks, sources # Returnera också för säkerhets skull
+
+# Lazy-laddning av SentenceTransformer
 embedder = None
 embeddings = None
 index = None
@@ -160,108 +235,215 @@ index = None
 def initialize_embeddings():
     """Initierar SentenceTransformer och FAISS-index vid första anrop."""
     global embedder, embeddings, index, chunks, chunk_sources
-    
+
+    # Kör endast om embedder inte redan är initierad
     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()}
+        if not text_data["local_files"]:
+             print("Varning: Ingen lokal textdata hittades att indexera.")
+             # Sätt tomma listor för att undvika fel senare
+             chunks = []
+             chunk_sources = []
+             embeddings = np.array([]) # Tom numpy array
+             # Skapa ett tomt index om inga chunks finns
+             embedder = SentenceTransformer('all-MiniLM-L6-v2') # Ladda modellen ändå
+             # FAISS kräver minst en vektor, eller dimensionen
+             dimension = embedder.get_sentence_embedding_dimension()
+             index = faiss.IndexFlatIP(dimension)
+             print("FAISS-index skapat (tomt).")
+             return # Avsluta tidigt
+
         print("Förbereder textsegment...")
-        chunks, chunk_sources = prepare_chunks(text_data)
-        print(f"{len(chunks)} segment laddade")
+        chunks, chunk_sources = prepare_chunks(text_data) # Detta uppdaterar globala chunks/chunk_sources
+        print(f"{len(chunks)} segment förberedda")
+
+        if not chunks:
+            print("Varning: Inga textsegment skapades från filerna.")
+            embedder = SentenceTransformer('all-MiniLM-L6-v2') # Ladda modellen ändå
+            dimension = embedder.get_sentence_embedding_dimension()
+            index = faiss.IndexFlatIP(dimension)
+            embeddings = np.array([])
+            print("FAISS-index skapat (tomt).")
+            return
 
         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")
+        try:
+            embeddings = embedder.encode(chunks, convert_to_numpy=True, show_progress_bar=True)
+             # Normalisera embeddings
+            norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+            # Undvik division med noll om någon norm är noll
+            norms[norms == 0] = 1e-10
+            embeddings /= norms
+
+            if embeddings.shape[0] > 0:
+                 dimension = embeddings.shape[1]
+                 index = faiss.IndexFlatIP(dimension)
+                 index.add(embeddings.astype(np.float32)) # FAISS föredrar float32
+                 print(f"FAISS-index skapat med {index.ntotal} vektorer.")
+            else:
+                 print("Inga embeddings skapades, skapar tomt FAISS-index.")
+                 dimension = embedder.get_sentence_embedding_dimension()
+                 index = faiss.IndexFlatIP(dimension)
+
+        except Exception as e:
+             print(f"Fel vid skapande av embeddings eller FAISS-index: {e}")
+             # Försök återställa till ett tomt men funktionellt tillstånd
+             embedder = SentenceTransformer('all-MiniLM-L6-v2')
+             dimension = embedder.get_sentence_embedding_dimension()
+             index = faiss.IndexFlatIP(dimension)
+             embeddings = np.array([])
+             chunks = []
+             chunk_sources = []
 
 def retrieve_context(query, k=RETRIEVAL_K):
     """Hämtar relevant kontext för frågor."""
-    # Säkerställ att modeller är laddade
-    initialize_embeddings()
-    
-    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()
-    for idx in I[0]:
-        if idx < len(chunks):
-            retrieved.append(chunks[idx])
-            sources.add(chunk_sources[idx])
-    return " ".join(retrieved), list(sources)
+    initialize_embeddings() # Säkerställ att allt är laddat
+
+    # Kontrollera om indexet är tomt eller om nödvändiga objekt saknas
+    if index is None or index.ntotal == 0 or embedder is None or not chunks:
+        print("Varning: Embeddings eller index är inte redo. Kan inte hämta kontext.")
+        return "", []
+
+    try:
+        query_embedding = embedder.encode([query], convert_to_numpy=True)
+        # Normalisera query_embedding
+        norm = np.linalg.norm(query_embedding)
+        if norm == 0: norm = 1e-10 # Undvik division med noll
+        query_embedding /= norm
+
+        # Säkerställ att k inte är större än antalet vektorer i indexet
+        actual_k = min(k, index.ntotal)
+        if actual_k == 0:
+            return "", []
+
+        # Sök i indexet
+        D, I = index.search(query_embedding.astype(np.float32), actual_k)
+
+        retrieved, sources = [], set()
+        if I.size > 0: # Kontrollera att sökningen gav resultat
+            for idx in I[0]:
+                # Säkerställ att indexet är giltigt
+                if 0 <= idx < len(chunks):
+                    retrieved.append(chunks[idx])
+                    # Säkerställ att chunk_sources har samma längd
+                    if idx < len(chunk_sources):
+                        sources.add(chunk_sources[idx])
+                else:
+                    print(f"Varning: Ogiltigt index {idx} returnerat från FAISS.")
+
+        return " ".join(retrieved), list(sources)
+    except Exception as e:
+        print(f"Fel vid hämtning av kontext: {e}")
+        return "", []
+
 
 def generate_answer(query):
     """Genererar svar baserat på fråga och kontextinformation."""
+    start_time = time.time()
     context, sources = retrieve_context(query)
+    retrieval_time = time.time() - start_time
+
+    # Om ingen kontext hittades, ge ett standardmeddelande
     if not context.strip():
-        return "Jag hittar ingen relevant information i mina källor.\n\nDetta är ett AI genererat svar."
+        print("Ingen relevant kontext hittades.")
+        # Överväg att låta GPT försöka svara ändå, eller returnera direkt
+        # return "Jag kunde inte hitta någon specifik information om det i mina källor. Kan du omformulera frågan?\n\nAI-genererat. Otillräcklig hjälp? Kontakta support@chargenode.eu eller 010-2051055"
+
+    # Bygg prompten även om kontext är tom (GPT kan ha allmän kunskap)
     prompt = f"""{prompt_template}
-    
+
 Relevant kontext:
-{context}
+{context if context.strip() else "Ingen specifik kontext hittades i de lokala dokumenten."}
+
 Fråga: {query}
-Svar (baserat enbart på den indexerade datan):"""
+
+Svar (baserat på tillgänglig information):"""
+
     try:
+        start_time_gpt = time.time()
         response = client.chat.completions.create(
             model="gpt-3.5-turbo",
             messages=[
-                {"role": "system", "content": "Du är en expert på ChargeNodes produkter och tjänster. Svara enbart baserat på den information som finns i den indexerade datan."},
+                {"role": "system", "content": "Du är en hjälpsam assistent för ChargeNode. Basera ditt svar primärt på den 'Relevanta kontexten' om den finns. Om ingen kontext finns, eller om frågan inte täcks av kontexten, använd din allmänna kunskap men ange att svaret är generellt."},
                 {"role": "user", "content": prompt}
             ],
             temperature=0.2,
             max_tokens=500
         )
-        answer = response.choices[0].message.content
-        return answer + "\n\nAI-genererat. Otillräcklig hjälp? Kontakta support@chargenode.eu eller 010-2051055"
+        gpt_time = time.time() - start_time_gpt
+        answer = response.choices[0].message.content.strip()
+
+        # Lägg till standard-disclaimer
+        answer += "\n\nAI-genererat. Otillräcklig hjälp? Kontakta support@chargenode.eu eller 010-2051055"
+
+        print(f"Svar genererat. Retrieval: {retrieval_time:.2f}s, GPT: {gpt_time:.2f}s")
+        return answer
+
     except Exception as e:
-        return f"Tekniskt fel: {str(e)}\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
+        print(f"Fel vid anrop till OpenAI API: {e}")
+        return f"Ett tekniskt fel uppstod när jag försökte generera ett svar ({type(e).__name__}). Försök igen senare.\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
+
 
 # --- Slack Integration ---
 def send_to_slack(subject, content, color="#2a9d8f"):
     """Basfunktion för att skicka meddelanden till Slack."""
     webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
     if not webhook_url:
-        print("Slack webhook URL saknas")
+        print("Slack webhook URL saknas, kan inte skicka meddelande.")
         return False
-    
+
     try:
         # Formatera meddelandet för Slack
         payload = {
-            "blocks": [
-                {
-                    "type": "header",
-                    "text": {
-                        "type": "plain_text",
-                        "text": subject
-                    }
-                },
+            "attachments": [
                 {
-                    "type": "section",
-                    "text": {
-                        "type": "mrkdwn",
-                        "text": content
-                    }
+                    "color": color,
+                    "blocks": [
+                        {
+                            "type": "header",
+                            "text": {
+                                "type": "plain_text",
+                                "text": subject,
+                                "emoji": True
+                            }
+                        },
+                        {
+                            "type": "divider"
+                        },
+                        {
+                            "type": "section",
+                            "text": {
+                                "type": "mrkdwn",
+                                "text": content
+                            }
+                        }
+                    ]
                 }
             ]
         }
-        
+
         response = requests.post(
             webhook_url,
             json=payload,
-            headers={"Content-Type": "application/json"}
+            headers={"Content-Type": "application/json"},
+            timeout=10 # Lägg till timeout
         )
-        
+
         if response.status_code == 200:
-            print(f"Slack-meddelande skickat: {subject}")
+            # print(f"Slack-meddelande skickat: {subject}") # Kan bli för mycket output
             return True
         else:
             print(f"Slack-anrop misslyckades: {response.status_code}, {response.text}")
             return False
+    except requests.exceptions.RequestException as e:
+        print(f"Nätverksfel vid sändning till Slack: {type(e).__name__}: {e}")
+        return False
     except Exception as e:
-        print(f"Fel vid sändning till Slack: {type(e).__name__}: {e}")
+        print(f"Allmänt fel vid sändning till Slack: {type(e).__name__}: {e}")
         return False
 
 # --- Feedback & Like-funktion ---
@@ -273,69 +455,106 @@ def vote(data: gr.LikeData):
     """
     feedback_type = "up" if data.liked else "down"
     global last_log
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    # Försök extrahera bot-svaret från LikeData
+    bot_reply = ""
+    if isinstance(data.value, str):
+        bot_reply = data.value
+    elif isinstance(data.value, dict) and "value" in data.value:
+         bot_reply = data.value["value"]
+    else:
+         print(f"Varning: Kunde inte extrahera bot_reply från LikeData: {data.value}")
+         bot_reply = "[Kunde inte extrahera svar]"
+
+
     log_entry = {
-        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "timestamp": timestamp,
+        "event_type": "feedback", # Tydliggör typ av loggpost
         "feedback": feedback_type,
-        "bot_reply": data.value if not isinstance(data.value, dict) else data.value.get("value")
+        "bot_reply_liked": bot_reply # Namnge tydligare vad det är
     }
-    # Om global logdata finns, lägg till ytterligare metadata.
-    if last_log:
+
+    # Om global logdata finns från senaste *konversationen*, lägg till metadata.
+    # Detta antar att 'like' sker direkt efter ett svar.
+    if last_log and last_log.get("event_type") == "conversation":
         log_entry.update({
             "session_id": last_log.get("session_id"),
             "user_message": last_log.get("user_message"),
+            "associated_bot_reply": last_log.get("bot_reply"), # Spara hela ursprungliga svaret
+            "user_id": last_log.get("user_id"),
+            "ip": last_log.get("ip"),
+            "platform": last_log.get("platform")
         })
-    
+    else:
+        print("Varning: Kunde inte koppla feedback till föregående konversation (last_log saknas eller är av fel typ).")
+        # Lägg till fallback-värden om möjligt
+        log_entry["session_id"] = "unknown"
+        log_entry["user_message"] = "[Okänd fråga]"
+
+
     # 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
-            feedback_message = f"""
-*⚠️ Negativ feedback registrerad*
+        feedback_subject = f"Feedback: {'👍 Positiv' if feedback_type == 'up' else '👎 Negativ'}"
+        feedback_message = f"""
+*Feedback mottagen ({timestamp})*
+
+*Typ:* {"👍 Tumme upp" if feedback_type == 'up' else '👎 Tumme ned'}
 
-*Fråga:* {last_log.get('user_message', 'Okänd fråga')}
+*Associerad fråga:* {log_entry.get('user_message', '[Okänd fråga]')[:500]}...
+*Botens svar (som fick feedback):* {log_entry.get('bot_reply_liked', '[Okänt svar]')[:500]}...
 
-*Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry.get('bot_reply', '')) > 300 else ''}
+*Session:* {log_entry.get('session_id', 'okänd')} | *Plattform:* {log_entry.get('platform', 'okänd')}
 """
-            # Skicka asynkront
-            threading.Thread(
-                target=lambda: send_to_slack("Negativ feedback", feedback_message, "#ff0000"),
-                daemon=True
-            ).start()
+        # Skicka asynkront för att inte blockera
+        threading.Thread(
+            target=send_to_slack,
+            args=(feedback_subject, feedback_message, "#2a9d8f" if feedback_type == 'up' else "#ff0000"),
+            daemon=True
+        ).start()
     except Exception as e:
         print(f"Kunde inte skicka feedback till Slack: {e}")
-    
+
+    # Gradio förväntar sig ingen retur från like-funktionen
     return
 
 # --- Rapportering ---
 def read_logs():
     """Läs alla loggposter från loggfilen."""
     logs = []
+    if not os.path.exists(log_file_path):
+        print(f"Loggfil saknas: {log_file_path}")
+        return logs
+
     try:
-        if os.path.exists(log_file_path):
-            with open(log_file_path, "r", encoding="utf-8") as file:
-                line_count = 0
-                for line in file:
-                    line_count += 1
-                    try:
-                        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}")
-                        continue
-            print(f"Läste {len(logs)} av {line_count} loggposter")
-        else:
-            print(f"Loggfil saknas: {log_file_path}")
+        with open(log_file_path, "r", encoding="utf-8") as file:
+            line_count = 0
+            for line in file:
+                line_count += 1
+                line = line.strip()
+                if not line: # Hoppa över tomma rader
+                    continue
+                try:
+                    log_entry = json.loads(line)
+                    logs.append(log_entry)
+                except json.JSONDecodeError as e:
+                    print(f"Varning: Kunde inte tolka JSON på rad {line_count}: {e}. Radinnehåll: '{line[:100]}...'")
+                    continue
+        print(f"Läste {len(logs)} giltiga loggposter från {line_count} rader.")
     except Exception as e:
-        print(f"Fel vid läsning av loggfil: {e}")
+        print(f"Allvarligt fel vid läsning av loggfil {log_file_path}: {e}")
     return logs
 
 def get_latest_conversations(logs, limit=50):
-    """Hämta de senaste frågorna och svaren."""
+    """Hämta de senaste frågorna och svaren från konversationsloggar."""
     conversations = []
+    # Iterera baklänges för att få de senaste först
     for log in reversed(logs):
-        if 'user_message' in log and 'bot_reply' in log:
+        # Filtrera på loggar av typen 'conversation'
+        if log.get('event_type') == 'conversation' and 'user_message' in log and 'bot_reply' in log:
             conversations.append({
                 'user_message': log['user_message'],
                 'bot_reply': log['bot_reply'],
@@ -346,504 +565,670 @@ def get_latest_conversations(logs, limit=50):
     return conversations
 
 def get_feedback_stats(logs):
-    """Sammanfatta feedback (tumme upp/ned)."""
-    feedback_count = {"up": 0, "down": 0}
-    negative_feedback_examples = []
-    
+    """Sammanfatta feedback (tumme upp/ned) från feedbackloggar."""
+    feedback_count = {"up": 0, "down": 0, "unknown": 0}
+    negative_feedback_examples = [] # Hämta exempel på negativ feedback
+
     for log in logs:
-        if 'feedback' in log:
+        # Filtrera på loggar av typen 'feedback'
+        if log.get('event_type') == 'feedback' and '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')
-                })
-    
+            if feedback == "up":
+                feedback_count["up"] += 1
+            elif feedback == "down":
+                feedback_count["down"] += 1
+                 # Samla exempel på negativ feedback (max 10 st)
+                if len(negative_feedback_examples) < 10:
+                    negative_feedback_examples.append({
+                        'user_message': log.get('user_message', '[Okänd fråga]'),
+                        'bot_reply_liked': log.get('bot_reply_liked', '[Okänt svar]')
+                    })
+            else:
+                feedback_count["unknown"] +=1
+
+
     return feedback_count, negative_feedback_examples
 
-def generate_monthly_stats(days=30):
-    """Genererar omfattande statistik över botanvändning för den senaste månaden."""
+def generate_periodic_stats(days=30):
+    """Genererar statistik över botanvändning för den angivna perioden."""
     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
+
+    all_logs = read_logs()
+    if not all_logs:
+        print("Inga loggar hittades.")
+        return {"error": "Inga loggdata tillgängliga."}
+
+    # Filtrera loggar baserat på tidsstämpel
     now = datetime.now()
     cutoff_date = now - timedelta(days=days)
     filtered_logs = []
-    
-    for log in logs:
+    invalid_date_count = 0
+
+    for log in all_logs:
         if 'timestamp' in log:
             try:
+                # Försök tolka datumet - var flexibel med format om nödvändigt
                 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
-    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))
-    
-    # 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]
+            except ValueError:
+                # Försök med annat vanligt format om det första misslyckas
+                try:
+                    log_date = datetime.fromisoformat(log['timestamp']) # För ISO 8601
+                    if log_date >= cutoff_date:
+                        filtered_logs.append(log)
+                except ValueError:
+                     invalid_date_count += 1
+        else:
+            invalid_date_count += 1 # Räkna även loggar som saknar tidsstämpel
+
+    if invalid_date_count > 0:
+         print(f"Varning: {invalid_date_count} loggposter ignorerades på grund av saknad eller ogiltig tidsstämpel.")
+
+    if not filtered_logs:
+        return {"error": f"Inga loggar hittades för de senaste {days} dagarna."}
+
+    # Separera loggtyper
+    conv_logs = [log for log in filtered_logs if log.get('event_type') == 'conversation']
+    feedback_logs = [log for log in filtered_logs if log.get('event_type') == 'feedback']
+
+    # --- Beräkna statistik ---
+    total_conversations = len(conv_logs)
+    unique_sessions = len(set(log.get('session_id', 'unknown') for log in conv_logs if log.get('session_id')))
+    # User ID kan vara mindre tillförlitligt (baserat på IP), men vi inkluderar det
+    unique_users = len(set(log.get('user_id', 'unknown') for log in conv_logs if log.get('user_id')))
+
+    # Feedback
+    feedback_stats, neg_examples = get_feedback_stats(feedback_logs) # Använd filtrerade feedbackloggar
+    positive_feedback = feedback_stats.get("up", 0)
+    negative_feedback = feedback_stats.get("down", 0)
+    total_feedback = positive_feedback + negative_feedback
+    feedback_ratio = (positive_feedback / total_feedback * 100) if total_feedback > 0 else 0
+
+    # Svarstid (från konversationsloggar)
+    response_times = [log.get('response_time', 0) for log in conv_logs if 'response_time' in log]
     avg_response_time = sum(response_times) / len(response_times) if response_times else 0
-    
-    # Plattformsstatistik
+
+    # Plattform, Browser, OS (från konversationsloggar)
     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
-    
+    for log in conv_logs:
+        p = log.get('platform', 'Okänd')
+        b = log.get('browser', 'Okänd')
+        o = log.get('os', 'Okänd')
+        platforms[p] = platforms.get(p, 0) + 1
+        browsers[b] = browsers.get(b, 0) + 1
+        operating_systems[o] = operating_systems.get(o, 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 ({cutoff_date.strftime('%Y-%m-%d')} - {now.strftime('%Y-%m-%d')})",
+        "generated_at": 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
+            "unique_users (estimated)": unique_users,
+            "messages_per_session": round(total_conversations / unique_sessions, 2) if unique_sessions else 0
         },
         "feedback": {
+            "total_feedback_entries": total_feedback,
             "positive": positive_feedback,
             "negative": negative_feedback,
-            "ratio_percent": round(feedback_ratio, 1)
+            "satisfaction_rate_percent": round(feedback_ratio, 1)
         },
         "performance": {
-            "avg_response_time": round(avg_response_time, 2)
+            "avg_response_time_seconds": round(avg_response_time, 2)
         },
-        "platform_distribution": platforms,
-        "browser_distribution": browsers,
-        "os_distribution": operating_systems
+        "top_platforms": dict(sorted(platforms.items(), key=lambda item: item[1], reverse=True)[:5]),
+        "top_browsers": dict(sorted(browsers.items(), key=lambda item: item[1], reverse=True)[:5]),
+        "top_os": dict(sorted(operating_systems.items(), key=lambda item: item[1], reverse=True)[:5]),
+        "negative_feedback_examples": neg_examples # Lägg till exempel
     }
-    
+
     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}"
-        
-        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}*
 
-*Basstatistik* (senaste 7 dagarna)
-- Totalt antal konversationer: {basic['total_conversations']}
+def format_report_for_slack(stats_dict):
+    """Formaterar statistikrapporten för läsbarhet i Slack."""
+    if 'error' in stats_dict:
+        return f"*Fel vid generering av statistik:* {stats_dict['error']}"
+
+    basic = stats_dict["basic_stats"]
+    feedback = stats_dict["feedback"]
+    perf = stats_dict["performance"]
+    platforms = stats_dict["top_platforms"]
+    browsers = stats_dict["top_browsers"]
+    osys = stats_dict["top_os"]
+    neg_examples = stats_dict["negative_feedback_examples"]
+
+    # Formatera listor snyggt
+    def format_dict(d):
+        return "\n".join([f"- {k}: {v}" for k, v in d.items()]) if d else "Ingen data"
+
+    # Formatera negativa exempel
+    neg_example_str = "\n".join([
+        f"- Fråga: {ex['user_message'][:80]}...\n  Svar: {ex['bot_reply_liked'][:80]}..."
+        for ex in neg_examples
+    ]) if neg_examples else "Inga exempel registrerade."
+
+
+    content = f"""
+*Period:* {stats_dict.get('period', 'Okänd')} (Genererad: {stats_dict.get('generated_at', 'Okänd')})
+
+*📊 Användning*
+- Konversationer: {basic['total_conversations']}
 - Unika sessioner: {basic['unique_sessions']}
-- Unika användare: {basic['unique_users']}
-- Genomsnittlig svarstid: {perf['avg_response_time']} sekunder
+- Uppskattade unika användare: {basic['unique_users (estimated)']}
+- Meddelanden/session: {basic['messages_per_session']}
 
-*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)
-        
-        if conversations:
-            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 ''}
+*👍👎 Feedback*
+- Totalt antal feedback: {feedback['total_feedback_entries']}
+- Positiv: {feedback['positive']} | Negativ: {feedback['negative']}
+- Nöjdhet: {feedback['satisfaction_rate_percent']}%
+
+*⚡ Prestanda*
+- Genomsnittlig svarstid: {perf['avg_response_time_seconds']} sekunder
+
+*💻 Teknik (Topp 5)*
+*Plattformar:*
+{format_dict(platforms)}
+*Webbläsare:*
+{format_dict(browsers)}
+*Operativsystem:*
+{format_dict(osys)}
+
+*📉 Exempel på negativ feedback (senaste):*
+{neg_example_str}
 """
-        
-        # Skicka till Slack
-        return send_to_slack(subject, content, "#2a9d8f")
-        
+    return content.strip()
+
+def send_status_report(days=7, report_type="Daglig"):
+    """Genererar och skickar en statusrapport till Slack."""
+    print(f"Genererar {report_type.lower()} statusrapport för Slack...")
+    report_title = f"ChargeNode AI Bot - {report_type} Statusrapport"
+
+    try:
+        stats = generate_periodic_stats(days=days)
+        slack_content = format_report_for_slack(stats)
+        color = "#3498db" # Blå för vanlig rapport
+        if "error" in stats:
+             color = "#ff0000" # Röd vid fel
+
+        send_to_slack(report_title, slack_content, color)
+
     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)}"
-        return send_to_slack(error_subject, error_content, "#ff0000")
+        print(f"Allvarligt fel vid generering/sändning av {report_type.lower()} statusrapport: {e}")
+        # Försök skicka ett felmeddelande till Slack
+        try:
+            error_subject = f"🚨 Fel: {report_title}"
+            error_content = f"Kunde inte generera eller skicka statusrapporten.\n*Felmeddelande:* `{type(e).__name__}: {e}`"
+            send_to_slack(error_subject, error_content, "#ff0000")
+        except Exception as slack_err:
+             print(f"Kunde inte ens skicka felmeddelande till Slack: {slack_err}")
+
 
+# --- Supportformulär till Slack ---
 def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
     """Skickar en supportförfrågan till Slack."""
+    if not email: # Grundläggande validering
+        print("Fel: Email saknas för supportförfrågan.")
+        return False # Returnera False om email saknas
+
     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"
-        
+        # Ta med de senaste N meddelandena (t.ex. 10 senaste)
+        history_limit = 10
+        start_index = max(0, len(chat_history) - history_limit)
+        for msg in chat_history[start_index:]:
+             # Säkerställ att msg är en dict med 'role' och 'content'
+             if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
+                 role = msg.get('role', 'unknown').capitalize()
+                 content = msg.get('content', '')
+                 # Truncate långa meddelanden för Slack
+                 max_len = 300
+                 display_content = (content[:max_len] + '...') if len(content) > max_len else content
+                 chat_content += f"*{role}:* {display_content}\n"
+             else:
+                 chat_content += f"*Okänt format:* `{str(msg)[:100]}`\n"
+
+
         # Skapa innehåll
-        subject = f"Support förfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
-        
+        subject = f"📩 Supportförfrågan via Chatbot"
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
         content = f"""
-*Användarinformation*
-- *Områdeskod:* {områdeskod or 'Ej angiven'}
-- *Uttagsnummer:* {uttagsnummer or 'Ej angiven'}
+*Ny supportförfrågan* ({timestamp})
+
+*👤 Användarinformation*
 - *Email:* {email}
-- *Tidpunkt:* {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+- *Områdeskod:* {områdeskod or '_Ej angiven_'}
+- *Uttagsnummer:* {uttagsnummer or '_Ej angiven_'}
 
-*Chatthistorik:*
-{chat_content}
+*💬 Chatthistorik (senaste {history_limit} meddelandena):*
+{chat_content or "_Ingen historik tillgänglig_"}
 """
-        
+
         # Skicka till Slack
-        return send_to_slack(subject, content, "#e76f51")
+        success = send_to_slack(subject, content.strip(), "#e76f51") # Orange färg för support
+        if not success:
+             print("Misslyckades med att skicka supportförfrågan till Slack via API.")
+        return success # Returnera True/False baserat på Slack-sändning
+
     except Exception as e:
-        print(f"Fel vid sändning av support till Slack: {type(e).__name__}: {e}")
+        print(f"Allvarligt fel vid sändning av support till Slack: {type(e).__name__}: {e}")
         return False
 
-        # --- Schemaläggning av rapporter ---
+
+# --- 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"
-    ))
-    
+    """Kör schemaläggaren i en separat tråd."""
+    print("Startar schemaläggningstråd för rapporter...")
+
+    # Dagliga rapporter (skicka för föregående dag)
+    schedule.every().day.at("08:00").do(lambda: send_status_report(days=1, report_type="Daglig"))
+
+    # Veckorapport på måndagar (för föregående 7 dagar)
+    schedule.every().monday.at("09:00").do(lambda: send_status_report(days=7, report_type="Veckovis"))
+
+    # Månadsrapport den första dagen i månaden (för föregående ~30 dagar)
+    # schedule.every().month.at("10:00").do(lambda: send_status_report(days=30, report_type="Månadsvis")) # Kan bli mycket data
+    # Kör istället första dagen i månaden
+    schedule.every().day.at("10:00").do(lambda: monthly_report_if_first_day())
+
+    print("Schema konfigurerat:")
+    for job in schedule.get_jobs():
+        print(f"- {job}")
+
     while True:
-        schedule.run_pending()
+        try:
+            schedule.run_pending()
+        except Exception as e:
+            print(f"Fel i schemaläggningsloopen: {e}")
         time.sleep(60)  # Kontrollera varje minut
 
-# Starta schemaläggaren i en separat tråd
-scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
-scheduler_thread.start()
+def monthly_report_if_first_day():
+    """Kör månadsrapport endast om det är den första dagen i månaden."""
+    if datetime.now().day == 1:
+        print("Första dagen i månaden, kör månadsrapport...")
+        send_status_report(days=30, report_type="Månadsvis")
+    else:
+        # print("Inte första dagen i månaden, hoppar över månadsrapport.") # Behövs ej loggas varje dag
+        pass
+
+
+# Starta schemaläggaren endast om Slack Webhook finns
+if os.environ.get("SLACK_WEBHOOK_URL"):
+    scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
+    scheduler_thread.start()
+else:
+    print("Ingen SLACK_WEBHOOK_URL hittades, schemalagda rapporter kommer inte att köras.")
 
 # 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}")
+# Gör detta i en separat tråd för att inte blockera start
+def initial_startup_report():
+    # Vänta några sekunder så att appen hinner starta helt
+    time.sleep(10)
+    print("Skickar en inledande statusrapport (senaste 24h) för att verifiera Slack-integrationen...")
+    send_status_report(days=1, report_type="Uppstart")
+
+if os.environ.get("SLACK_WEBHOOK_URL"):
+     threading.Thread(target=initial_startup_report, daemon=True).start()
+
 
 # --- Gradio UI ---
-initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
+initial_chat = [{"role": "assistant", "content": "Hej! Jag är ChargeNodes AI-assistent. Hur kan jag hjälpa dig idag?"}]
 
+# Mer robust CSS
 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; }
-.message-wrap { scroll-behavior: smooth; }
-.message.bot:last-child { scroll-margin-top: 100px; }
-.support-form-container { margin-top: 40px; }
-.support-form-container .gr-form { margin-top: 15px; }
-.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;}
+body { font-family: sans-serif; margin: 0; padding: 0; background-color: #f0f0f0; }
+.gradio-container { max-width: 450px !important; margin: 0 auto; /* Centrera om inte fixerad */ /* position: fixed; bottom: 20px; right: 20px; */ box-shadow: 0 4px 12px rgba(0,0,0,0.1); border-radius: 12px; background-color: #ffffff; overflow: hidden; border: 1px solid #e0e0e0; }
+h1 { font-family: Helvetica, sans-serif; color: #2a9d8f; text-align: center; margin: 1em 0 0.5em 0; font-size: 1.5em; }
+#chatbot_conversation .message-wrap { padding: 10px; } /* Lägg till padding inuti chatbot */
+#chatbot_conversation { min-height: 300px; max-height: 400px; overflow-y: auto; border-bottom: 1px solid #e0e0e0; }
+.message.user { background-color: #e0f2f7; border-radius: 10px 10px 0 10px; }
+.message.bot { background-color: #f1f1f1; border-radius: 10px 10px 10px 0; }
+.message { padding: 10px 15px; margin-bottom: 8px; max-width: 85%; word-wrap: break-word; }
+.support-form-container, .success-interface { padding: 20px; }
+.support-form-container .gr-form { margin-top: 15px; padding: 15px; border: 1px solid #ddd; border-radius: 8px; background-color: #fafafa; }
+.gr-button { background-color: #2a9d8f; color: white; border: none; border-radius: 5px; padding: 10px 18px; margin: 5px; cursor: pointer; transition: background-color 0.2s ease; font-weight: bold; }
+.gr-button:hover { background-color: #264653; }
+.support-btn { background-color: #f4a261; color: #ffffff; } /* Orange knapp */
+.support-btn:hover { background-color: #e76f51; }
+.flex-row { display: flex; flex-direction: row; gap: 10px; align-items: center; }
+.chat-preview { max-height: 150px; overflow-y: auto; border: 1px solid #eee; padding: 10px; margin-top: 10px; font-size: 0.9em; background-color: #f9f9f9; border-radius: 4px; line-height: 1.4; }
+.success-message { font-size: 1.1em; font-weight: bold; color: #2a9d8f; margin-bottom: 15px; text-align: center; }
+footer { display: none !important; } /* Dölj Gradio-footer mer aggressivt */
+.gradio-container footer, .gradio-container .gr-footer { display: none !important; visibility: hidden !important; }
+/* Specifik targeting för input/textbox */
+.gr-textbox textarea { border-radius: 5px; border: 1px solid #ccc; padding: 10px; }
+.block.padded { padding: 15px !important; } /* Lägg till padding till block om nödvändigt */
+.block.gap { gap: 10px !important; } /* Justera mellanrum mellan element */
 """
 
-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")
-        chatbot.like(vote, None, None)
-        
-        with gr.Row():
-            msg = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...")
-        
-        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")
-    
-    # Lägg till anpassad JavaScript för att styra scrollning
-    js_code = """
-    function scrollToTop() {
-        const chatContainer = document.querySelector('.gradio-container .message-wrap');
-        if (chatContainer) {
-            chatContainer.scrollTop = 0;
-        }
-    }
-
-    // Kör funktionen när nya meddelanden läggs till
-    document.addEventListener('DOMNodeInserted', function(event) {
-        if (event.target.classList && event.target.classList.contains('bot')) {
-            setTimeout(scrollToTop, 100);
-        }
-    });
-    """
-    app.load(js=js_code)
-    
-    # Support form interface (initially hidden)
-    with gr.Group(visible=False, elem_classes="support-form-container") 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")
-            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")
-            
-            with gr.Row():
-                back_btn = gr.Button("Tillbaka")
-                send_support_btn = gr.Button("Skicka")
-    
-    # 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")
-    
-# Detta bör vara slutet av app.py-filen från funktionen "respond" och nedåt
+# --- Funktioner för UI-logik --- (definieras före Blocks)
 
 def respond(message, chat_history, request: gr.Request):
-    global last_log
-    start = time.time()
-    response = generate_answer(message)
-    elapsed = round(time.time() - start, 2)
+    """Hanterar användarens meddelande, genererar svar och loggar."""
+    global last_log # Använd globala variabeln för att spara loggdata
+
+    if not message or message.isspace():
+        # Returnera ingen ändring om meddelandet är tomt
+        return "", chat_history
+
+    start_time = time.time()
+    bot_response = generate_answer(message) # Generera svaret
+    response_time = round(time.time() - start_time, 2)
 
     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]
-    ua = parse_ua(ua_str)
-    browser = f"{ua.browser.family} {ua.browser.version_string}"
-    osys = f"{ua.os.family} {ua.os.version_string}"
 
+    # Försök hämta session_id från tidigare loggar i *samma* session
+    session_id = str(uuid.uuid4()) # Skapa ny som standard
+    if last_log and last_log.get("event_type") == "conversation" and last_log.get("session_id"):
+         # Återanvänd session_id om den senaste loggen var en konversation
+         session_id = last_log.get("session_id")
+
+    # Hämta metadata från request
+    user_id = "unknown"
+    ip_address = "unknown"
+    user_agent_str = ""
+    referer = ""
+    browser_info = "Okänd"
+    os_info = "Okänd"
+
+    if request:
+        user_id = request.client.host if request.client else "unknown_client"
+        # Försök hämta IP från headers (vanligt bakom proxys)
+        headers = request.headers
+        ip_candidates = [
+            headers.get("x-forwarded-for"),
+            headers.get("x-real-ip"),
+            user_id # Fallback till client.host
+        ]
+        for ip in ip_candidates:
+            if ip:
+                # Ta den första IP:n om listan är kommaseparerad
+                ip_address = ip.split(',')[0].strip()
+                break
+
+        user_agent_str = headers.get("user-agent", "")
+        referer = headers.get("referer", "")
+
+        if user_agent_str:
+            try:
+                ua = parse_ua(user_agent_str)
+                browser_info = f"{ua.browser.family} {ua.browser.version_string}" if ua.browser else "Okänd"
+                os_info = f"{ua.os.family} {ua.os.version_string}" if ua.os else "Okänd"
+            except Exception as ua_err:
+                print(f"Fel vid parsning av User Agent: {ua_err}")
+                browser_info = "Parse Error"
+                os_info = "Parse Error"
+
+    # Bestäm plattform baserat på referer
     platform = "webb"
-    if "chargenode.eu" in ref:
-        platform = "chargenode.eu"
-    elif "localhost" in ref:
-        platform = "test"
-    elif "app" in ref:
-        platform = "app"
+    if referer:
+        if "chargenode.eu" in referer:
+            platform = "chargenode.eu"
+        elif any(sub in referer for sub in ["localhost", "127.0.0.1"]): # Utöka localhost-check
+            platform = "test"
+        elif "app" in referer: # Kan vara för generellt
+             platform = "app"
+        # Lägg till fler regler vid behov
+    else:
+        platform = "okänd_referer"
 
+    # Skapa loggposten
     log_data = {
         "timestamp": timestamp,
+        "event_type": "conversation", # Tydliggör typ
         "user_id": user_id,
         "session_id": session_id,
+        "ip": ip_address,
+        "platform": platform,
+        "browser": browser_info,
+        "os": os_info,
         "user_message": message,
-        "bot_reply": response,
-        "response_time": elapsed,
-        "ip": ip,
-        "browser": browser,
-        "os": osys,
-        "platform": platform
+        "bot_reply": bot_response,
+        "response_time": response_time,
+        # Lägg eventuellt till referer och user_agent om det är värdefullt
+        # "referer": referer,
+        # "user_agent": user_agent_str
     }
 
-    # Använd den förbättrade loggfunktionen
     safe_append_to_log(log_data)
-    last_log = log_data
+    last_log = log_data # Spara som den senaste loggen
 
-    # Skicka varje konversation direkt till Slack
+    # Skicka konversationen till Slack (asynkront)
     try:
-        # Konversationsinnehåll
-        conversation_content = f"""
-*Ny konversation {timestamp}*
-
+        slack_conv_subject = f"💬 Ny konversation ({platform})"
+        slack_conv_content = f"""
 *Användare:* {message}
-
-*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}
-
-*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform}
+*Bot:* {bot_response[:300]}{'...' if len(bot_response) > 300 else ''}
+---
+*Tid:* {timestamp} | *Session:* `{session_id[:8]}` | *IP:* `{ip_address}` | *Browser:* {browser_info} | *OS:* {os_info}
 """
-        # Skicka asynkront för att inte blockera svarstiden
         threading.Thread(
-            target=lambda: send_to_slack(f"Ny konversation", conversation_content),
+            target=send_to_slack,
+            args=(slack_conv_subject, slack_conv_content.strip(), "#ADD8E6"), # Ljusblå för konversation
             daemon=True
         ).start()
     except Exception as e:
-        print(f"Kunde inte skicka konversation till Slack: {e}")
+        print(f"Kunde inte starta tråd för att skicka konversation till Slack: {e}")
+
 
+    # Uppdatera Gradio chat history
     chat_history.append({"role": "user", "content": message})
-    chat_history.append({"role": "assistant", "content": response})
-    
-    # Borttaget: gr.javascript("setTimeout(function() { scrollToTop(); }, 100);")
-    # Vi förlitar oss istället på JavaScript-koden som redan laddats via app.load()
-    
+    chat_history.append({"role": "assistant", "content": bot_response})
+
+    # Rensa inputfältet (returnera tom sträng för msg) och uppdatera chatbot
     return "", chat_history
 
 def format_chat_preview(chat_history):
+    """Formaterar chatthistoriken för förhandsgranskning i supportformuläret."""
     if not chat_history:
-        return "Ingen chatthistorik att visa."
-    
+        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"
-    
-    return preview
+    history_limit = 10 # Begränsa förhandsgranskningen
+    start_index = max(0, len(chat_history) - history_limit)
+    for msg in chat_history[start_index:]:
+         if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
+             sender = "Du" if msg["role"] == "user" else "Bot"
+             content = msg["content"]
+             if len(content) > 150:  # Korta ner långa meddelanden i förhandsgranskningen
+                 content = content[:150] + "..."
+             # Använd Markdown för fet stil
+             preview += f"**{sender}:** {content}\n\n"
+         else:
+             # Hantera oväntat format
+             preview += f"**Okänt format:** `{str(msg)[:50]}`\n\n"
+
+    return preview.strip()
 
 def show_support_form(chat_history):
-    preview = format_chat_preview(chat_history)
-    # Borttaget: gr.javascript("setTimeout(function() { window.scrollTo(0, 0); }, 100);")
+    """Visar supportformuläret och döljer chatten."""
+    preview_md = format_chat_preview(chat_history)
+    # Uppdatera synligheten för gränssnitten och innehållet i förhandsgranskningen
     return {
-        chat_interface: gr.Group(visible=False),
-        support_interface: gr.Group(visible=True),
-        success_interface: gr.Group(visible=False),
-        chat_preview: preview
+        chat_interface: gr.update(visible=False),
+        support_interface: gr.update(visible=True),
+        success_interface: gr.update(visible=False),
+        chat_preview: gr.update(value=preview_md) # Uppdatera Markdown-komponenten
     }
 
 def back_to_chat():
+    """Visar chatten och döljer support/success-vyerna."""
     return {
-        chat_interface: gr.Group(visible=True),
-        support_interface: gr.Group(visible=False),
-        success_interface: gr.Group(visible=False)
+        chat_interface: gr.update(visible=True),
+        support_interface: gr.update(visible=False),
+        success_interface: gr.update(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
+    """Validerar och skickar supportformuläret."""
+    print(f"Support-förfrågan mottagen: Områdeskod='{områdeskod}', Uttagsnummer='{uttagsnummer}', Email='{email}'")
+
     validation_errors = []
-    
+    # Validera Områdeskod (om angiven)
     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)")
-    
+        validation_errors.append("Områdeskod måste vara ett nummer (om angivet).")
+    # Validera Uttagsnummer (om angiven)
     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)")
-    
+        validation_errors.append("Uttagsnummer måste vara ett nummer (om angivet).")
+    # Validera Email (obligatorisk)
     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
+        validation_errors.append("E-postadress är obligatorisk.")
+    elif '@' not in email or '.' not in email.split('@')[-1]: # Enkel email-validering
+        validation_errors.append("Ange en giltig e-postadress.")
+
     if validation_errors:
-        print(f"Valideringsfel: {validation_errors}")
+        print(f"Valideringsfel i supportformulär: {validation_errors}")
+        error_message = "**Valideringsfel:**\n" + "\n".join([f"- {err}" for err in validation_errors])
+        # Uppdatera UI för att visa felen, behåll supportformuläret synligt
         return {
-            chat_interface: gr.Group(visible=False),
-            support_interface: gr.Group(visible=True),
-            success_interface: gr.Group(visible=False),
-            chat_preview: "\n".join(["**Fel:**"] + validation_errors)
+            chat_interface: gr.update(visible=False),
+            support_interface: gr.update(visible=True), # Behåll synligt
+            success_interface: gr.update(visible=False),
+            chat_preview: gr.update(value=error_message) # Visa felmeddelande i preview-rutan
         }
-    
-    # Om formuläret klarade valideringen, försök skicka till Slack
+
+    # Om validering OK, 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
+        print("Validering OK. Försöker skicka supportförfrågan 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")
+            print("Support-förfrågan skickad till Slack.")
+            # Visa success-meddelandet
             return {
-                chat_interface: gr.Group(visible=False),
-                support_interface: gr.Group(visible=False),
-                success_interface: gr.Group(visible=True)
+                chat_interface: gr.update(visible=False),
+                support_interface: gr.update(visible=False),
+                success_interface: gr.update(visible=True), # Visa success
+                chat_preview: gr.update(value="") # Rensa preview
             }
         else:
-            print("Support-förfrågan till Slack misslyckades")
+            print("Misslyckades med att skicka supportförfrågan till Slack.")
+            error_message = "**Ett tekniskt fel uppstod.** Meddelandet kunde inte skickas till supporten just nu. Vänligen försök igen senare eller kontakta support@chargenode.eu direkt."
+            # Visa fel i supportformuläret
             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.**"
+                chat_interface: gr.update(visible=False),
+                support_interface: gr.update(visible=True), # Behåll synligt
+                success_interface: gr.update(visible=False),
+                chat_preview: gr.update(value=error_message) # Visa felmeddelande
             }
     except Exception as e:
         print(f"Oväntat fel vid hantering av support-formulär: {e}")
+        error_message = f"**Ett oväntat fel uppstod:** {str(e)}. Försök igen."
         return {
-            chat_interface: gr.Group(visible=False),
-            support_interface: gr.Group(visible=True),
-            success_interface: gr.Group(visible=False),
-            chat_preview: f"**Ett fel uppstod: {str(e)}**"
+            chat_interface: gr.update(visible=False),
+            support_interface: gr.update(visible=True), # Behåll synligt
+            success_interface: gr.update(visible=False),
+            chat_preview: gr.update(value=error_message) # Visa felmeddelande
         }
 
-# Eventkopplingar 
-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], 
-    [chat_interface, support_interface, success_interface, chat_preview]
-)
+# --- Bygg Gradio App ---
+with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
+    gr.Markdown("# ChargeNode AI Assistent") # Tydligare rubrik
+
+    # --- Chat Interface ---
+    with gr.Group(visible=True) as chat_interface:
+        chatbot = gr.Chatbot(
+            value=initial_chat,
+            # type="messages", # 'messages' är inte en giltig typ, använd standard
+            elem_id="chatbot_conversation",
+            label="Chatt",
+            show_label=False,
+            bubble_full_width=False # Gör bubblorna smalare
+            )
+        # Koppla like-funktionen direkt efter definitionen
+        chatbot.like(vote, inputs=None, outputs=None) # inputs/outputs=None är standard vid like
+
+        with gr.Row():
+            msg = gr.Textbox(
+                label="Meddelande",
+                placeholder="Skriv din fråga här...",
+                show_label=False,
+                scale=4 # Ge textrutan mer bredd
+            )
+            # Submit-knapp (kan vara implicit via Enter, men bra att ha synlig)
+            # submit_btn = gr.Button("Skicka", scale=1) # Alternativt
+
+        with gr.Row():
+            clear_btn = gr.Button("Rensa chatt")
+            support_btn = gr.Button("Behöver mer hjälp? Kontakta support", elem_classes="support-btn")
+
+    # --- Support Form Interface ---
+    with gr.Group(visible=False, elem_classes="support-form-container") as support_interface:
+        gr.Markdown("### Kontakta Support")
+        gr.Markdown("Fyll i dina uppgifter så återkommer vi via email. Din chatthistorik inkluderas.")
+
+        with gr.Column(elem_classes="gr-form"): # Använd Column för bättre layout
+            email = gr.Textbox(label="Din E-postadress", placeholder="din.email@example.com", info="Obligatorisk för att vi ska kunna svara dig.")
+            områdeskod = gr.Textbox(label="Områdeskod (frivilligt)", placeholder="t.ex. 12345", info="Numeriskt värde om du vet det.")
+            uttagsnummer = gr.Textbox(label="Uttagsnummer (frivilligt)", placeholder="t.ex. 1", info="Numeriskt värde om relevant.")
+
+            gr.Markdown("#### Chatthistorik (senaste)")
+            chat_preview = gr.Markdown(value="_Laddar förhandsgranskning..._", elem_classes="chat-preview") # Startvärde
+
+            with gr.Row():
+                back_btn = gr.Button("Avbryt (Tillbaka till chatten)")
+                send_support_btn = gr.Button("Skicka till Support")
+
+    # --- Success Message Interface ---
+    with gr.Group(visible=False) as success_interface:
+        gr.Markdown("✅ Tack! Din förfrågan har skickats till support@chargenode.eu.", elem_classes="success-message")
+        back_to_chat_btn = gr.Button("Tillbaka till chatten")
+
+
+    # --- Event Listeners (VIKTIGT: Måste vara INUTI 'with gr.Blocks') ---
+    # När användaren trycker Enter i textrutan eller klickar på (en osynlig) submit-knapp
+    msg.submit(
+        fn=respond,
+        inputs=[msg, chatbot],
+        outputs=[msg, chatbot], # Rensa msg, uppdatera chatbot
+        api_name="send_message" # För API-anrop om det används
+    )
+    # Om du hade en synlig submit-knapp:
+    # submit_btn.click(fn=respond, inputs=[msg, chatbot], outputs=[msg, chatbot])
+
+    # Rensa chatt-historiken
+    clear_btn.click(lambda: (initial_chat, ""), outputs=[chatbot, msg], queue=False) # Återställ till initial + rensa input
+
+    # Visa supportformulär
+    support_btn.click(
+        fn=show_support_form,
+        inputs=[chatbot], # Skicka med aktuell historik
+        outputs=[chat_interface, support_interface, success_interface, chat_preview] # Uppdatera synlighet + preview
+    )
+
+    # Gå tillbaka från supportformulär till chatt
+    back_btn.click(
+        fn=back_to_chat,
+        inputs=None,
+        outputs=[chat_interface, support_interface, success_interface] # Uppdatera bara synlighet
+    )
+
+    # Gå tillbaka från success-meddelande till chatt
+    back_to_chat_btn.click(
+        fn=back_to_chat,
+        inputs=None,
+        outputs=[chat_interface, support_interface, success_interface] # Uppdatera bara synlighet
+    )
+
+    # Skicka in supportformuläret
+    send_support_btn.click(
+        fn=submit_support_form,
+        inputs=[områdeskod, uttagsnummer, email, chatbot], # Skicka med formulärdata + historik
+        outputs=[chat_interface, support_interface, success_interface, chat_preview] # Uppdatera synlighet + ev. fel i preview
+    )
+
 
+# --- Kör appen ---
 if __name__ == "__main__":
-    app.launch(share=True)
+    print("Förbereder att starta Gradio-appen...")
+    initialize_embeddings() # Ladda embeddings innan appen startas
+    print("Embeddings initialiserade.")
+    # Kör med share=True endast om det behövs för extern åtkomst
+    app.launch(share=os.environ.get("GRADIO_SHARE", "true").lower() == "true") # Gör share konfigurerbart via env var
+    # app.launch() # För lokal körning utan delning