Update app.py

app.py

@@ -39,29 +39,22 @@ if not os.path.exists(log_file_path):
     print(f"Skapade tom loggfil: {log_file_path}")
 
 hf_token = os.environ.get("HF_TOKEN")
-# 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)")
+if not hf_token:
+    raise ValueError("HF_TOKEN saknas")
 
-# 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.")
+# 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
+)
 
 
 # --- 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):
@@ -69,28 +62,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, ensure_ascii=False) # ensure_ascii=False för svenska tecken
+            log_json = json.dumps(log_entry)
             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')}") # Kan bli för mycket output
+            
+        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, ensure_ascii=False)
+                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
@@ -99,133 +92,65 @@ def safe_append_to_log(log_entry):
 def load_local_files():
     uploaded_text = ""
     allowed = [".txt", ".docx", ".pdf", ".csv", ".xls", ".xlsx"]
-    # 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}")
+    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:
             try:
-                if item.endswith(".txt"):
-                    with open(item_path, "r", encoding="utf-8") as f:
+                if file.endswith(".txt"):
+                    with open(file, "r", encoding="utf-8") as f:
                         content = f.read()
-                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}"
-
+                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}"
             except Exception as e:
-                print(f"Allmänt fel vid läsning av {item}: {str(e)}")
+                print(f"Fel vid läsning av {file}: {str(e)}")
     return uploaded_text.strip()
 
 def load_prompt():
     try:
-        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:
+        with open("prompt.txt", "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 läsning av prompt.txt: {e}")
+        print(f"Fel vid 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():
-        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 = ""
+        paragraphs = [p for p in text.split("\n") if p.strip()]
+        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:
-                # Lägg till föregående chunk om den inte är tom
-                if current_chunk:
-                    chunks.append(current_chunk)
+                if chunk.strip():
+                    chunks.append(chunk.strip())
                     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)
-                    # 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)
+                chunk = para
+        if chunk.strip():
+            chunks.append(chunk.strip())
             sources.append(source)
-
-    # Uppdatera de globala variablerna
-    chunk_sources = sources
-    return chunks, sources # Returnera också för säkerhets skull
+    return chunks, sources
 
 # Lazy-laddning av SentenceTransformer
 embedder = None
@@ -235,215 +160,107 @@ 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) # 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
+        chunks, chunk_sources = prepare_chunks(text_data)
+        print(f"{len(chunks)} segment laddade")
 
         print("Skapar embeddings...")
         embedder = SentenceTransformer('all-MiniLM-L6-v2')
-        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 = []
-
+        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() # 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 "", []
-
+    # 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)
 
 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():
-        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)
+        return "Jag hittar ingen relevant information i mina källor.\n\nDetta är ett AI genererat svar."
     prompt = f"""{prompt_template}
-
+    
 Relevant kontext:
-{context if context.strip() else "Ingen specifik kontext hittades i de lokala dokumenten."}
-
+{context}
 Fråga: {query}
-
-Svar (baserat på tillgänglig information):"""
-
+Svar (baserat enbart på den indexerade datan):"""
     try:
-        start_time_gpt = time.time()
         response = client.chat.completions.create(
             model="gpt-3.5-turbo",
             messages=[
-                {"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": "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": "user", "content": prompt}
             ],
             temperature=0.2,
             max_tokens=500
         )
-        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
-
+        answer = response.choices[0].message.content
+        return answer + "\n\nAI-genererat. Otillräcklig hjälp? Kontakta support@chargenode.eu eller 010-2051055"
     except Exception as e:
-        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"
-
+        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"):
     """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, kan inte skicka meddelande.")
+        print("Slack webhook URL saknas")
         return False
-
+    
     try:
         # Formatera meddelandet för Slack
         payload = {
-            "attachments": [
+            "blocks": [
+                {
+                    "type": "header",
+                    "text": {
+                        "type": "plain_text",
+                        "text": subject
+                    }
+                },
                 {
-                    "color": color,
-                    "blocks": [
-                        {
-                            "type": "header",
-                            "text": {
-                                "type": "plain_text",
-                                "text": subject,
-                                "emoji": True
-                            }
-                        },
-                        {
-                            "type": "divider"
-                        },
-                        {
-                            "type": "section",
-                            "text": {
-                                "type": "mrkdwn",
-                                "text": content
-                            }
-                        }
-                    ]
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": content
+                    }
                 }
             ]
         }
-
+        
         response = requests.post(
             webhook_url,
             json=payload,
-            headers={"Content-Type": "application/json"},
-            timeout=10 # Lägg till timeout
+            headers={"Content-Type": "application/json"}
         )
-
+        
         if response.status_code == 200:
-            # print(f"Slack-meddelande skickat: {subject}") # Kan bli för mycket output
+            print(f"Slack-meddelande skickat: {subject}")
             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"Allmänt fel vid sändning till Slack: {type(e).__name__}: {e}")
+        print(f"Fel vid sändning till Slack: {type(e).__name__}: {e}")
         return False
 
 # --- Feedback & Like-funktion ---
@@ -455,106 +272,69 @@ 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": timestamp,
-        "event_type": "feedback", # Tydliggör typ av loggpost
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         "feedback": feedback_type,
-        "bot_reply_liked": bot_reply # Namnge tydligare vad det är
+        "bot_reply": data.value if not isinstance(data.value, dict) else data.value.get("value")
     }
-
-    # 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":
+    # 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"),
-            "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:
-        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'}
+        if feedback_type == "down":  # Skicka bara negativ feedback
+            feedback_message = f"""
+*⚠️ Negativ feedback registrerad*
 
-*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]}...
+*Fråga:* {last_log.get('user_message', 'Okänd fråga')}
 
-*Session:* {log_entry.get('session_id', 'okänd')} | *Plattform:* {log_entry.get('platform', 'okänd')}
+*Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry.get('bot_reply', '')) > 300 else ''}
 """
-        # 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()
+            # 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}")
-
-    # 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:
-        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.")
+        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}")
     except Exception as e:
-        print(f"Allvarligt fel vid läsning av loggfil {log_file_path}: {e}")
+        print(f"Fel vid läsning av loggfil: {e}")
     return logs
 
 def get_latest_conversations(logs, limit=50):
-    """Hämta de senaste frågorna och svaren från konversationsloggar."""
+    """Hämta de senaste frågorna och svaren."""
     conversations = []
-    # Iterera baklänges för att få de senaste först
     for log in reversed(logs):
-        # Filtrera på loggar av typen 'conversation'
-        if log.get('event_type') == 'conversation' and 'user_message' in log and 'bot_reply' in log:
+        if 'user_message' in log and 'bot_reply' in log:
             conversations.append({
                 'user_message': log['user_message'],
                 'bot_reply': log['bot_reply'],
@@ -565,670 +345,500 @@ def get_latest_conversations(logs, limit=50):
     return conversations
 
 def get_feedback_stats(logs):
-    """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
-
+    """Sammanfatta feedback (tumme upp/ned)."""
+    feedback_count = {"up": 0, "down": 0}
+    negative_feedback_examples = []
+    
     for log in logs:
-        # Filtrera på loggar av typen 'feedback'
-        if log.get('event_type') == 'feedback' and 'feedback' in log:
+        if 'feedback' in log:
             feedback = log.get('feedback')
-            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
-
-
+            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_periodic_stats(days=30):
-    """Genererar statistik över botanvändning för den angivna perioden."""
+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...")
-
-    all_logs = read_logs()
-    if not all_logs:
-        print("Inga loggar hittades.")
-        return {"error": "Inga loggdata tillgängliga."}
-
-    # Filtrera loggar baserat på tidsstämpel
+    
+    # Hämta loggar
+    logs = read_logs()
+    
+    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 = []
-    invalid_date_count = 0
-
-    for log in all_logs:
+    
+    for log in 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 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]
+            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]
     avg_response_time = sum(response_times) / len(response_times) if response_times else 0
-
-    # Plattform, Browser, OS (från konversationsloggar)
+    
+    # Plattformsstatistik
     platforms = {}
     browsers = {}
     operating_systems = {}
-    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
-
+    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 ({cutoff_date.strftime('%Y-%m-%d')} - {now.strftime('%Y-%m-%d')})",
-        "generated_at": 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 (estimated)": unique_users,
-            "messages_per_session": round(total_conversations / unique_sessions, 2) if unique_sessions else 0
+            "unique_users": unique_users,
+            "messages_per_user": round(total_conversations / unique_users, 2) if unique_users else 0
         },
         "feedback": {
-            "total_feedback_entries": total_feedback,
             "positive": positive_feedback,
             "negative": negative_feedback,
-            "satisfaction_rate_percent": round(feedback_ratio, 1)
+            "ratio_percent": round(feedback_ratio, 1)
         },
         "performance": {
-            "avg_response_time_seconds": round(avg_response_time, 2)
+            "avg_response_time": round(avg_response_time, 2)
         },
-        "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
+        "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:
+        # 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}*
 
-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']}
+*Basstatistik* (senaste 7 dagarna)
+- Totalt antal konversationer: {basic['total_conversations']}
 - Unika sessioner: {basic['unique_sessions']}
-- Uppskattade unika användare: {basic['unique_users (estimated)']}
-- Meddelanden/session: {basic['messages_per_session']}
-
-*👍👎 Feedback*
-- Totalt antal feedback: {feedback['total_feedback_entries']}
-- Positiv: {feedback['positive']} | Negativ: {feedback['negative']}
-- Nöjdhet: {feedback['satisfaction_rate_percent']}%
+- Unika användare: {basic['unique_users']}
+- Genomsnittlig svarstid: {perf['avg_response_time']} sekunder
 
-*⚡ 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}
+*Feedback*
+- 👍 Tumme upp: {feedback['positive']}
+- 👎 Tumme ned: {feedback['negative']}
+- Nöjdhet: {feedback['ratio_percent']}%
 """
-    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)
-
+        
+        # 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 ''}
+"""
+        
+        # Skicka till Slack
+        return send_to_slack(subject, content, "#2a9d8f")
+        
     except Exception as e:
-        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}")
-
+        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")
 
-# --- 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 = ""
-        # 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"
-
-
+        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"📩 Supportförfrågan via Chatbot"
-        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-
+        subject = f"Support förfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+        
         content = f"""
-*Ny supportförfrågan* ({timestamp})
-
-*👤 Användarinformation*
+*Användarinformation*
+- *Områdeskod:* {områdeskod or 'Ej angiven'}
+- *Uttagsnummer:* {uttagsnummer or 'Ej angiven'}
 - *Email:* {email}
-- *Områdeskod:* {områdeskod or '_Ej angiven_'}
-- *Uttagsnummer:* {uttagsnummer or '_Ej angiven_'}
+- *Tidpunkt:* {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
 
-*💬 Chatthistorik (senaste {history_limit} meddelandena):*
-{chat_content or "_Ingen historik tillgänglig_"}
+*Chatthistorik:*
+{chat_content}
 """
-
+        
         # Skicka till Slack
-        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
-
+        return send_to_slack(subject, content, "#e76f51")
     except Exception as e:
-        print(f"Allvarligt fel vid sändning av support till Slack: {type(e).__name__}: {e}")
+        print(f"Fel vid sändning av support till Slack: {type(e).__name__}: {e}")
         return False
 
-
 # --- Schemaläggning av rapporter ---
 def run_scheduler():
-    """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}")
-
+    """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"
+    ))
+    
     while True:
-        try:
-            schedule.run_pending()
-        except Exception as e:
-            print(f"Fel i schemaläggningsloopen: {e}")
+        schedule.run_pending()
         time.sleep(60)  # Kontrollera varje minut
 
-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.")
+# 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
-# 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": "Hej! Jag är ChargeNodes AI-assistent. Hur kan jag hjälpa dig idag?"}]
-
-# Mer robust CSS
-custom_css = """
-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 */
-"""
-
-# --- Funktioner för UI-logik --- (definieras före Blocks)
+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}")
 
+# Definiera respond och chat-relaterade funktioner före Gradio UI
 def respond(message, chat_history, request: gr.Request):
-    """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)
+    global last_log
+    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())
+    
+    # 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 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"
+    if "chargenode.eu" in ref:
+        platform = "chargenode.eu"
+    elif "localhost" in ref:
+        platform = "test"
+    elif "app" in ref:
+        platform = "app"
 
-    # 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": 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
+        "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 # Spara som den senaste loggen
+    last_log = log_data
 
-    # Skicka konversationen till Slack (asynkront)
+    # Skicka varje konversation direkt till Slack
     try:
-        slack_conv_subject = f"💬 Ny konversation ({platform})"
-        slack_conv_content = f"""
+        # Konversationsinnehåll
+        conversation_content = f"""
+*Ny konversation {timestamp}*
+
 *Användare:* {message}
-*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}
+
+*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}
+
+*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform}
 """
+        # Skicka asynkront för att inte blockera svarstiden
         threading.Thread(
-            target=send_to_slack,
-            args=(slack_conv_subject, slack_conv_content.strip(), "#ADD8E6"), # Ljusblå för konversation
+            target=lambda: send_to_slack(f"Ny konversation", conversation_content),
             daemon=True
         ).start()
     except Exception as e:
-        print(f"Kunde inte starta tråd för att skicka konversation till Slack: {e}")
-
+        print(f"Kunde inte skicka konversation till Slack: {e}")
 
-    # Uppdatera Gradio chat history
     chat_history.append({"role": "user", "content": message})
-    chat_history.append({"role": "assistant", "content": bot_response})
-
-    # Rensa inputfältet (returnera tom sträng för msg) och uppdatera chatbot
+    chat_history.append({"role": "assistant", "content": response})
+    
     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 = ""
-    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()
+    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):
-    """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
+    preview = format_chat_preview(chat_history)
     return {
-        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
+        chat_interface: gr.Group(visible=False),
+        support_interface: gr.Group(visible=True),
+        success_interface: gr.Group(visible=False),
+        chat_preview: preview
     }
 
 def back_to_chat():
-    """Visar chatten och döljer support/success-vyerna."""
     return {
-        chat_interface: gr.update(visible=True),
-        support_interface: gr.update(visible=False),
-        success_interface: gr.update(visible=False)
+        chat_interface: gr.Group(visible=True),
+        support_interface: gr.Group(visible=False),
+        success_interface: gr.Group(visible=False)
     }
 
 def submit_support_form(områdeskod, uttagsnummer, email, chat_history):
-    """Validerar och skickar supportformuläret."""
-    print(f"Support-förfrågan mottagen: Områdeskod='{områdeskod}', Uttagsnummer='{uttagsnummer}', Email='{email}'")
-
+    """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 = []
-    # Validera Områdeskod (om angiven)
+    
     if områdeskod and not områdeskod.isdigit():
-        validation_errors.append("Områdeskod måste vara ett nummer (om angivet).")
-    # Validera Uttagsnummer (om angiven)
+        print(f"Validerar områdeskod: '{områdeskod}' (felaktig)")
+        validation_errors.append("Områdeskod måste vara numerisk.")
+    else:
+        print(f"Validerar områdeskod: '{områdeskod}' (ok)")
+    
     if uttagsnummer and not uttagsnummer.isdigit():
-        validation_errors.append("Uttagsnummer måste vara ett nummer (om angivet).")
-    # Validera Email (obligatorisk)
+        print(f"Validerar uttagsnummer: '{uttagsnummer}' (felaktig)")
+        validation_errors.append("Uttagsnummer måste vara numerisk.")
+    else:
+        print(f"Validerar uttagsnummer: '{uttagsnummer}' (ok)")
+    
     if not email:
-        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.")
-
+        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:
-        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
+        print(f"Valideringsfel: {validation_errors}")
         return {
-            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
+            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)
         }
-
-    # Om validering OK, försök skicka till Slack
+    
+    # Om formuläret klarade valideringen, försök skicka till Slack
     try:
-        print("Validering OK. Försöker skicka supportförfrågan till Slack...")
+        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.")
-            # Visa success-meddelandet
+            print("Support-förfrågan skickad till Slack framgångsrikt")
             return {
-                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
+                chat_interface: gr.Group(visible=False),
+                support_interface: gr.Group(visible=False),
+                success_interface: gr.Group(visible=True)
             }
         else:
-            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
+            print("Support-förfrågan till Slack misslyckades")
             return {
-                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
+                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}")
-        error_message = f"**Ett oväntat fel uppstod:** {str(e)}. Försök igen."
         return {
-            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
+            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)}**"
         }
 
-# --- Bygg Gradio App ---
-with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
-    gr.Markdown("# ChargeNode AI Assistent") # Tydligare rubrik
+# --- Gradio UI ---
+initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
 
-    # --- 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
+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;}
+"""
 
+# VIKTIGT: Alla komponenter och eventkopplingar definieras inuti Blocks-kontexten
+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="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
-
+            msg = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...")
+        
         with gr.Row():
-            clear_btn = gr.Button("Rensa chatt")
-            support_btn = gr.Button("Behöver mer hjälp? Kontakta support", elem_classes="support-btn")
+            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;
+        }
+    }
 
-    # --- Support Form Interface ---
+    // 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("### 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
-
+        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("Avbryt (Tillbaka till chatten)")
-                send_support_btn = gr.Button("Skicka till Support")
-
-    # --- Success Message Interface ---
+                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! Din förfrågan har skickats till support@chargenode.eu.", elem_classes="success-message")
+        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")
-
-
-    # --- 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
+    
+    # VIKTIGT: Händelsehanterare definieras INOM gr.Blocks-kontexten, efter att komponenterna definierats
+    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(
-        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
+        submit_support_form, 
+        [områdeskod, uttagsnummer, email, chatbot], 
+        [chat_interface, support_interface, success_interface, chat_preview]
     )
 
-
-# --- Kör appen ---
 if __name__ == "__main__":
-    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
+    app.launch(share=True)