Update app.py

app.py

@@ -14,9 +14,6 @@ import uuid
 from user_agents import parse as parse_ua
 import schedule
 import threading
-import io
-import atexit
-import re
 
 # --- Konfiguration ---
 CHARGENODE_URL = "https://www.chargenode.eu"
@@ -58,42 +55,14 @@ scheduler = CommitScheduler(
 
 # --- Globala variabler ---
 last_log = None  # Sparar loggdata från senaste svar för feedback
-# Lägg till en lock för att skydda åtkomst till last_log
-last_log_lock = threading.Lock()
 
 # --- Förbättrad loggfunktion ---
 def safe_append_to_log(log_entry):
     """Säker metod för att lägga till loggdata utan att förlora historisk information."""
     try:
-        # Kontrollera att loggmappen finns
-        os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
-        
-        # Kontrollera loggfilens storlek
-        try:
-            log_size = os.path.getsize(log_file_path)
-            # Om loggfilen är större än 10MB, rotera den
-            if log_size > 10 * 1024 * 1024:  # 10MB
-                backup_path = f"{log_file_path}.bak"
-                if os.path.exists(backup_path):
-                    os.remove(backup_path)
-                os.rename(log_file_path, backup_path)
-                print(f"Loggfil roterad: {log_file_path} -> {backup_path}")
-        except FileNotFoundError:
-            # Filen finns inte än, inget att rotera
-            pass
-            
-        # Sanitera loggdata för att undvika potentiella injektioner
-        sanitized_entry = {}
-        for k, v in log_entry.items():
-            if isinstance(v, str):
-                # Ta bort null-bytes och begränsa längden
-                sanitized_entry[k] = v.replace('\0', '')[:10000]  # Begränsa till 10000 tecken
-            else:
-                sanitized_entry[k] = v
-        
         # Öppna filen i append-läge
         with open(log_file_path, "a", encoding="utf-8") as log_file:
-            log_json = json.dumps(sanitized_entry)
+            log_json = json.dumps(log_entry)
             log_file.write(log_json + "\n")
             log_file.flush()  # Säkerställ att data skrivs till disk omedelbart
             
@@ -103,22 +72,16 @@ def safe_append_to_log(log_entry):
     except Exception as e:
         print(f"Fel vid loggning: {e}")
         
-        # Försök skapa mappen om den inte finns (detta bör redan ha gjorts ovan)
+        # 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 med minimal loggdata för att undvika fel
-            minimal_entry = {
-                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "error": f"Fel vid loggning: {str(e)[:200]}",
-                "recovery": True
-            }
-            
+            # Försök igen
             with open(log_file_path, "a", encoding="utf-8") as log_file:
-                log_json = json.dumps(minimal_entry)
+                log_json = json.dumps(log_entry)
                 log_file.write(log_json + "\n")
                 
-            print("Minimal loggpost tillagd efter återhämtning")
+            print("Loggpost tillagd efter återhämtning")
             return True
             
         except Exception as retry_error:
@@ -189,281 +152,52 @@ def prepare_chunks(text_data):
             sources.append(source)
     return chunks, sources
 
-# Lazy-laddning av SentenceTransformer
+    # Lazy-laddning av SentenceTransformer
 embedder = None
 embeddings = None
 index = None
-chunks = []
-chunk_sources = []
-embedding_lock = threading.Lock()
 
 def initialize_embeddings():
     """Initierar SentenceTransformer och FAISS-index vid första anrop."""
     global embedder, embeddings, index, chunks, chunk_sources
     
-    # Använd en lock för att förhindra att flera trådar initierar samtidigt
-    with embedding_lock:
-        if embedder is None:
-            try:
-                print("Initierar SentenceTransformer och FAISS-index...")
-                # Ladda och förbered lokal data
-                print("Laddar textdata...")
-                text_data = {"local_files": load_local_files()}
-                print("Förbereder textsegment...")
-                chunks, chunk_sources = prepare_chunks(text_data)
-                print(f"{len(chunks)} segment laddade")
-
-                if not chunks:
-                    print("Varning: Inga textsegment hittades. Kontrollera textdata.")
-                    # Skapa tomma listor för att undvika fel
-                    chunks = [""]
-                    chunk_sources = ["empty"]
+    if embedder is None:
+        print("Initierar SentenceTransformer och FAISS-index...")
+        # Ladda och förbered lokal data
+        print("Laddar textdata...")
+        text_data = {"local_files": load_local_files()}
+        print("Förbereder textsegment...")
+        chunks, chunk_sources = prepare_chunks(text_data)
+        print(f"{len(chunks)} segment laddade")
+
+        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")
 
-                print("Skapar embeddings...")
-                embedder = SentenceTransformer('all-MiniLM-L6-v2')
-                embeddings = embedder.encode(chunks, convert_to_numpy=True)
-                
-                # Kontrollera att embeddings inte är tomma
-                if embeddings.size > 0:
-                    embeddings /= np.linalg.norm(embeddings, axis=1, keepdims=True)
-                    index = faiss.IndexFlatIP(embeddings.shape[1])
-                    index.add(embeddings)
-                    print("FAISS-index klart")
-                else:
-                    print("Varning: Tomma embeddings. Skapar ett tomt index.")
-                    # Skapa ett tomt index med rätt dimensioner
-                    index = faiss.IndexFlatIP(384)  # Standard dimension för all-MiniLM-L6-v2
-            except Exception as e:
-                print(f"Fel vid initiering av embeddings: {e}")
-                # Sätt upp grundläggande värden för att undvika fel
-                if embedder is None:
-                    print("Försöker återhämta från fel...")
-                    try:
-                        embedder = SentenceTransformer('all-MiniLM-L6-v2')
-                        if not chunks:
-                            chunks = ["Fel vid laddning av data"]
-                            chunk_sources = ["error"]
-                        embeddings = embedder.encode(chunks, convert_to_numpy=True)
-                        index = faiss.IndexFlatIP(embeddings.shape[1])
-                        index.add(embeddings)
-                        print("Återhämtning lyckades")
-                    except Exception as recovery_error:
-                        print(f"Kunde inte återhämta: {recovery_error}")
-                        # Sätt upp dummy-värden som sista utväg
-                        embedder = None
-                        embeddings = np.zeros((1, 384))
-                        index = faiss.IndexFlatIP(384)
 def retrieve_context(query, k=RETRIEVAL_K):
     """Hämtar relevant kontext för frågor."""
     # Säkerställ att modeller är laddade
     initialize_embeddings()
     
-    try:
-        if embedder is None:
-            print("Varning: Embedder är fortfarande None efter initiering")
-            return "Kunde inte ladda kontext", ["error"]
-            
-        query_embedding = embedder.encode([query], convert_to_numpy=True)
-        
-        # Kontrollera att embedding inte är tom
-        if query_embedding.size == 0:
-            print("Varning: Tom query embedding")
-            return "Kunde inte bearbeta frågan", ["error"]
-            
-        query_embedding /= np.linalg.norm(query_embedding)
-        
-        # Kontrollera att index finns
-        if index is None:
-            print("Varning: FAISS-index är None")
-            return "Kunde inte söka i kontext", ["error"]
-            
-        # Säkerställ att k inte är större än antalet element i index
-        actual_k = min(k, index.ntotal)
-        if actual_k < k:
-            print(f"Varning: Justerade k från {k} till {actual_k} baserat på index.ntotal")
-            
-        D, I = index.search(query_embedding, actual_k)
-        
-        retrieved, sources = [], set()
-        for idx in I[0]:
-            if 0 <= idx < len(chunks):
-                retrieved.append(chunks[idx])
-                sources.add(chunk_sources[idx])
-        
-        if not retrieved:
-            print("Varning: Ingen relevant kontext hittades")
-            return "Ingen relevant kontext hittades", ["no_context"]
-            
-        return " ".join(retrieved), list(sources)
-    except Exception as e:
-        print(f"Fel vid hämtning av kontext: {e}")
-        return f"Fel vid kontexthämtning: {str(e)[:200]}", ["error"]
-
-# --- Förbättringsfunktioner ---
-
-def identify_user_role(message, chat_history):
-    """Identifierar användarens roll baserat på meddelande och chatthistorik."""
-    # Nyckelord för olika roller
-    anlaggningsagare_keywords = ["självfaktura", "portal", "anläggning", "äger", "lastbalansering", 
-                                "prissättning", "statistik", "effekt", "laddtjänst", "anläggningsägare"]
-    laddkund_keywords = ["ladda", "app", "starta laddning", "debitering", "registrering", 
-                        "betalning", "kabel", "laddkund", "elbilist", "problem med laddning", "rfid"]
-    foretagskonto_keywords = ["företagskonto", "faktura", "företag", "portaladmin", "företagets"]
-    
-    # Analysera meddelande och chatthistorik (senaste 4 meddelanden)
-    all_text = message.lower()
-    history_limit = 4
-    start_index = max(0, len(chat_history) - history_limit)
-    for msg in chat_history[start_index:]:
-        if msg["role"] == "user":
-             all_text += " " + msg["content"].lower()
-
-    # Räkna förekomster av nyckelord
-    anlaggningsagare_score = sum(1 for word in anlaggningsagare_keywords if word in all_text)
-    laddkund_score = sum(1 for word in laddkund_keywords if word in all_text)
-    foretagskonto_score = sum(1 for word in foretagskonto_keywords if word in all_text)
-    
-    # Bestäm roll baserat på högsta poäng (med Laddkund som default)
-    if anlaggningsagare_score > laddkund_score and anlaggningsagare_score > foretagskonto_score:
-        return "Anläggningsägare"
-    elif foretagskonto_score > laddkund_score and foretagskonto_score > anlaggningsagare_score:
-        return "Företagskonto kund"
-    else:
-        # Om laddkund har högst poäng eller om det är oavgjort/inga träffar
-        return "Laddkund"
-
-def format_response(response, user_role):
-    """Formaterar svaret för bättre läsbarhet baserat på användarroll."""
-    
-    # Hantera specialfall för "kabeln har fastnat"
-    if "kabeln har fastnat i bilen:" in response.lower() or "kabeln har fastnat i uttaget:" in response.lower():
-        formatted = ""
-        if "kabeln har fastnat i bilen:" in response:
-             # Extrahera och formatera "fastnat i bilen" delen
-             start_bil = response.lower().find("kabeln har fastnat i bilen:")
-             end_bil = response.lower().find("kabeln har fastnat i uttaget:") if "kabeln har fastnat i uttaget:" in response.lower() else len(response)
-             bil_part = response[start_bil:end_bil].strip()
-             
-             formatted += "**" + bil_part.splitlines()[0] + "**\n" # Rubrik
-             steps = "\n".join(line.strip() for line in bil_part.splitlines()[1:] if line.strip())
-             # Ersätt nummer med punktlista
-             steps = re.sub(r"^\s*\d+\.\s*", "- ", steps, flags=re.MULTILINE)
-             formatted += steps + "\n\n"
-
-        if "kabeln har fastnat i uttaget:" in response:
-             # Extrahera och formatera "fastnat i uttaget" delen
-             start_uttag = response.lower().find("kabeln har fastnat i uttaget:")
-             uttag_part = response[start_uttag:].strip()
-
-             formatted += "**" + uttag_part.splitlines()[0] + "**\n" # Rubrik
-             steps = "\n".join(line.strip() for line in uttag_part.splitlines()[1:] if line.strip())
-             # Ersätt nummer med punktlista
-             steps = re.sub(r"^\s*\d+\.\s*", "- ", steps, flags=re.MULTILINE)
-             formatted += steps + "\n\n"
-             
-        # Lägg till generell kontaktinfo om den inte redan finns
-        if "010-205 10 55" not in formatted:
-             formatted += "Om detta inte fungerar är ni välkomna att kontakta oss på 010-205 10 55."
-             
-        return formatted.strip()
-
-    # Hantera specialfall för "starta laddning"
-    if "kontrollera betalning:" in response.lower() and "felsökningssteg:" in response.lower():
-         formatted = ""
-         parts = response.split("🔁 Felsökningssteg:")
-         
-         # Betalningsdel
-         payment_part = parts[0].replace("✅ Kontrollera betalning:", "**Kontrollera betalning:**").strip()
-         payment_part = re.sub(r"^\s*-\s*", "\n- ", payment_part, flags=re.MULTILINE)
-         formatted += payment_part + "\n\n"
-         
-         # Felsökningsdel
-         troubleshooting_part = parts[1].split("📞 Vid fortsatta problem:")[0]
-         formatted += "**Felsökningssteg:**" + troubleshooting_part.strip() + "\n\n"
-         formatted = re.sub(r"^\s*-\s*", "\n- ", formatted, flags=re.MULTILINE)
-
-         # Kontaktinfo-del
-         contact_part = parts[1].split("📞 Vid fortsatta problem:")[1]
-         formatted += "**Vid fortsatta problem:**" + contact_part.strip()
-         
-         return formatted.strip()
-
-    # Dela upp långa stycken för bättre läsbarhet (om det inte redan är punktlistor)
-    if "\n-" not in response and "\n*" not in response and len(response) > 250:
-        # Försök dela vid punkter följt av stor bokstav för att behålla meningar
-        sentences = re.split(r'(?<=\.)\s+(?=[A-ZÅÄÖ])', response)
-        formatted_response = ""
-        current_paragraph = ""
-        for sentence in sentences:
-            if len(current_paragraph) + len(sentence) < 200:
-                current_paragraph += sentence + " "
-            else:
-                formatted_response += current_paragraph.strip() + "\n\n"
-                current_paragraph = sentence + " "
-        formatted_response += current_paragraph.strip()
-        response = formatted_response
-
-    # Ta bort eventuell inledande "Svar:" om det finns kvar
-    if response.lower().startswith("svar:"):
-        response = response[len("svar:"):].strip()
-
-    return response
-
-def handle_error_cases(query):
-    """Identifierar och hanterar vanliga felfall baserat på regex."""
-    # Notera: Prompten hanterar redan dessa specialfall, 
-    # så denna funktion är mest för framtida bruk eller om prompten misslyckas.
-    # Den används inte aktivt i generate_answer just nu.
-    error_patterns = {
-        "kabeln sitter fast|fastnat|kommer inte loss": "specialfall_kabel",
-        "kan inte starta|startar inte|problem.*starta": "specialfall_starta",
-        "system.*problem|nedtid|fungerar inte|appen.*nere": "specialfall_system",
-        "tillåtelse|får jag ladda|tillåtet": "specialfall_tillatelse",
-        "logga in|inloggning|lösenord": "specialfall_login"
-    }
-    
-    query_lower = query.lower()
-    
-    for pattern, case in error_patterns.items():
-        if re.search(pattern, query_lower):
-            print(f"Identifierade specialfall: {case}")
-            return case # Returnerar typen av specialfall
-    
-    return None # Inget specialfall identifierat
-
-# --- Huvudfunktion för svar ---
-
-def generate_answer(query, chat_history):
-    """Genererar svar baserat på fråga och kontextinformation, med rollidentifiering och formatering."""
-    
-    # Identifiera användarroll
-    user_role = identify_user_role(query, chat_history)
-    print(f"Identifierad användarroll: {user_role}") # För felsökning
-
-    # Hämta relevant kontext
+    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."""
     context, sources = retrieve_context(query)
-    
-    # Hantera fall där ingen kontext hittas
-    if not context.strip() or context == "Ingen relevant kontext hittades":
-        # Använd standard "vet inte"-svaret från prompten
-        fallback_response = """Hej! Tyvärr har jag inte tillgång till uppgiften just nu och kan därför inte ge dig ett direkt svar.  
-Om du vill ha hjälp inom kort, mejla support@chargenode.eu – vi svarar vanligtvis inom 24 timmar.  
-Vid akuta problem, ring 010-205 10 55 (24/7). Om vi har system fel, så rapporteras detta via https://chargenode.statuspage.io/  
-Jag beklagar att jag inte kunde lösa detta omedelbart, men vårt supportteam står redo att hjälpa dig!"""
-        return fallback_response # Returnera direkt, ingen formatering behövs
-        
-    # Skapa prompten med användarroll inkluderad
-    role_prompt_addition = f"Tänk på att användaren troligen är en {user_role}."
-    
-    prompt = f"""{prompt_template}
-
-{role_prompt_addition}
-
-Relevant kontext:
-{context}
-
-Fråga: {query}
-Svar (baserat enbart på den indexerade datan):"""
+    if not context.strip():
+        return "Jag hittar ingen relevant information i mina källor.\n\nDetta är ett AI genererat svar."
     prompt = f"""{prompt_template}
     
 Relevant kontext:
@@ -474,30 +208,16 @@ Svar (baserat enbart på den indexerade datan):"""
         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. Anpassa ditt svar till användarens troliga roll."},
+                {"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
         )
         answer = response.choices[0].message.content
-        
-        # Formatera svaret
-        formatted_answer = format_response(answer, user_role)
-        
-        # Lägg till standardavslutning om den inte redan finns
-        standard_ending = "AI-genererat. Otillräcklig hjälp? Kontakta support@chargenode.eu eller 010-2051055"
-        if standard_ending not in formatted_answer:
-             # Undvik att lägga till om det är ett "vet inte"-svar som redan har kontaktinfo
-             if "support@chargenode.eu" not in formatted_answer and "010-205 10 55" not in formatted_answer:
-                 formatted_answer += "\n\n" + standard_ending
-        
-        return formatted_answer
-        
+        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: {e}")
-        # Returnera ett mer informativt felmeddelande till användaren
-        return f"Ett tekniskt fel uppstod när jag försökte generera ett svar. Vänligen försök igen om en liten stund.\n\nOm problemet kvarstår, kontakta support@chargenode.eu eller ring 010-2051055.\nFelkod: API_ERROR"
+        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"):
@@ -552,27 +272,18 @@ def vote(data: gr.LikeData):
     data.value innehåller information om meddelandet.
     """
     feedback_type = "up" if data.liked else "down"
-    global last_log, last_log_lock
-    
-    # Skapa en kopia av data.value för att undvika potentiella race conditions
-    bot_reply = data.value if not isinstance(data.value, dict) else data.value.get("value", "")
-    if bot_reply is None:
-        bot_reply = ""
-    
+    global last_log
     log_entry = {
         "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         "feedback": feedback_type,
-        "bot_reply": bot_reply
+        "bot_reply": data.value if not isinstance(data.value, dict) else data.value.get("value")
     }
-    
-    # Använd lock för att säkert komma åt last_log
-    with last_log_lock:
-        # Om global logdata finns, lägg till ytterligare metadata.
-        if last_log:
-            log_entry.update({
-                "session_id": last_log.get("session_id", "unknown"),
-                "user_message": last_log.get("user_message", "Okänd fråga"),
-            })
+    # Om global logdata finns, lägg till ytterligare metadata.
+    if last_log:
+        log_entry.update({
+            "session_id": last_log.get("session_id"),
+            "user_message": last_log.get("user_message"),
+        })
     
     # Använd den förbättrade loggfunktionen
     safe_append_to_log(log_entry)
@@ -580,16 +291,10 @@ def vote(data: gr.LikeData):
     # Skicka feedback till Slack
     try:
         if feedback_type == "down":  # Skicka bara negativ feedback
-            # Hämta user_message säkert
-            user_message = "Okänd fråga"
-            with last_log_lock:
-                if last_log:
-                    user_message = last_log.get("user_message", "Okänd fråga")
-            
             feedback_message = f"""
 *⚠️ Negativ feedback registrerad*
 
-*Fråga:* {user_message}
+*Fråga:* {last_log.get('user_message', 'Okänd fråga')}
 
 *Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry.get('bot_reply', '')) > 300 else ''}
 """
@@ -829,72 +534,29 @@ def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
         print(f"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."""
-    # Flagga för att kontrollera om tråden ska fortsätta köra
-    running = True
-    
-    try:
-        # 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 running:
-            try:
-                schedule.run_pending()
-                time.sleep(60)  # Kontrollera varje minut
-            except Exception as e:
-                print(f"Fel i schemaläggaren: {e}")
-                time.sleep(300)  # Vänta 5 minuter vid fel
-    except Exception as e:
-        print(f"Kritiskt fel i schemaläggaren: {e}")
-    finally:
-        print("Schemaläggaren avslutad")
+    # 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:
+        schedule.run_pending()
+        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()
 
-# Registrera en atexit-funktion för att städa upp vid avslut
-
-def cleanup():
-    """Städa upp resurser vid avslut."""
-    print("Städar upp resurser...")
-    # Stäng scheduler om möjligt
-    schedule.clear()
-    
-    # Stäng CommitScheduler om den är aktiv
-    if 'scheduler' in globals() and scheduler:
-        try:
-            scheduler.stop()
-            print("CommitScheduler stoppad")
-        except Exception as e:
-            print(f"Kunde inte stoppa CommitScheduler: {e}")
-    
-    # Stäng eventuella öppna filer
-    try:
-        # Försök att stänga alla öppna filer
-        import gc
-        for obj in gc.get_objects():
-            if isinstance(obj, io.IOBase) and not obj.closed:
-                try:
-                    obj.close()
-                except:
-                    pass
-    except Exception as e:
-        print(f"Fel vid stängning av filer: {e}")
-
-atexit.register(cleanup)
-
 # 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...")
@@ -902,314 +564,6 @@ try:
 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):
-    global last_log, last_log_lock
-    
-    # Validera indata
-    if not message or not isinstance(message, str):
-        print(f"Varning: Ogiltigt meddelande: {type(message)}")
-        message = str(message) if message is not None else ""
-    
-    # Begränsa meddelandets längd för att förhindra överbelastning
-    if len(message) > 1000:
-        message = message[:1000] + "..."
-        print("Meddelande trunkerat på grund av längd")
-    
-    start = time.time()
-    try:
-        # Anropa den uppdaterade generate_answer som nu inkluderar chat_history
-        response = generate_answer(message, chat_history) 
-    except Exception as e:
-        print(f"Fel vid generering av svar: {e}")
-        response = f"Tyvärr uppstod ett tekniskt fel. Vänligen försök igen eller kontakta support@chargenode.eu. Felkod: RESPOND_ERROR"
-    
-    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
-    with last_log_lock:
-        if last_log and 'session_id' in last_log:
-            session_id = last_log.get('session_id')
-    
-    # Säker hantering av request-objektet
-    user_id = "okänd"
-    ua_str = ""
-    ref = ""
-    ip = ""
-    
-    if request:
-        try:
-            user_id = request.client.host if hasattr(request.client, 'host') else "okänd"
-            ua_str = request.headers.get("user-agent", "") if hasattr(request, 'headers') else ""
-            ref = request.headers.get("referer", "") if hasattr(request, 'headers') else ""
-            ip = request.headers.get("x-forwarded-for", user_id).split(",")[0] if hasattr(request, 'headers') else user_id
-        except Exception as e:
-            print(f"Fel vid läsning av request-data: {e}")
-    
-    # Säker parsing av user agent
-    try:
-        ua = parse_ua(ua_str)
-        browser = f"{ua.browser.family} {ua.browser.version_string}"
-        osys = f"{ua.os.family} {ua.os.version_string}"
-    except Exception as e:
-        print(f"Fel vid parsing av user agent: {e}")
-        browser = "okänd"
-        osys = "okänd"
-
-    # Bestäm plattform
-    platform = "webb"
-    try:
-        if ref:
-            if "chargenode.eu" in ref:
-                platform = "chargenode.eu"
-            elif "localhost" in ref:
-                platform = "test"
-            elif "app" in ref:
-                platform = "app"
-    except Exception as e:
-        print(f"Fel vid bestämning av plattform: {e}")
-
-    # Skapa loggdata
-    log_data = {
-        "timestamp": timestamp,
-        "user_id": user_id,
-        "session_id": session_id,
-        "user_message": message,
-        "bot_reply": response,
-        "response_time": elapsed,
-        "ip": ip,
-        "browser": browser,
-        "os": osys,
-        "platform": platform
-    }
-
-    # Använd den förbättrade loggfunktionen
-    safe_append_to_log(log_data)
-    
-    # Uppdatera last_log säkert
-    with last_log_lock:
-        last_log = log_data.copy()  # Använd en kopia för att undvika race conditions
-
-    # Skicka varje konversation direkt till Slack
-    try:
-        # Konversationsinnehåll
-        conversation_content = f"""
-*Ny konversation {timestamp}*
-
-*Användare:* {message}
-
-*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=lambda: send_to_slack(f"Ny konversation", conversation_content),
-            daemon=True
-        ).start()
-    except Exception as e:
-        print(f"Kunde inte skicka konversation till Slack: {e}")
-
-    # Uppdatera chatthistorik
-    try:
-        chat_history.append({"role": "user", "content": message})
-        chat_history.append({"role": "assistant", "content": response})
-    except Exception as e:
-        print(f"Fel vid uppdatering av chatthistorik: {e}")
-        # Försök återställa chatthistoriken om något går fel
-        if not chat_history:
-            chat_history = []
-        chat_history.append({"role": "user", "content": message})
-        chat_history.append({"role": "assistant", "content": response})
-    
-    # Skapa JavaScript för att scrolla till senaste botmeddelandet
-    scroll_js = """
-    setTimeout(function() {
-        console.log("Executing scroll script");
-        const messages = document.querySelectorAll('.message');
-        if (messages.length > 0) {
-            console.log("Found messages:", messages.length);
-            const lastMessage = messages[messages.length - 1];
-            console.log("Scrolling to last message");
-            lastMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-        } else {
-            console.log("No messages found, trying alternative selectors");
-            // Alternativa selektorer för Hugging Face
-            const altMessages = document.querySelectorAll('.bot, [data-testid="bot"], .message-wrap > div:last-child');
-            if (altMessages.length > 0) {
-                console.log("Found messages with alt selector:", altMessages.length);
-                const lastAltMessage = altMessages[altMessages.length - 1];
-                console.log("Scrolling to last alt message");
-                lastAltMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-            } else {
-                console.log("No messages found with any selector");
-            }
-        }
-    }, 100);  // Vänta 100 millisekunder innan scroll
-    
-    // Försök igen efter lite längre tid om första försöket misslyckas
-    setTimeout(function() {
-        console.log("Executing delayed scroll script");
-        const messages = document.querySelectorAll('.message, .bot, [data-testid="bot"], .message-wrap > div:last-child');
-        if (messages.length > 0) {
-            console.log("Found messages in delayed script:", messages.length);
-            const lastMessage = messages[messages.length - 1];
-            console.log("Scrolling to last message in delayed script");
-            lastMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-        }
-    }, 500);  // Vänta 500 millisekunder innan andra försöket
-    """
-    
-    # Skapa JavaScript för att scrolla till senaste botmeddelandet (behåller den tidigare fungerande logiken)
-    scroll_js = """
-    setTimeout(function() {
-        console.log("Executing scroll script");
-        const messages = document.querySelectorAll('.message');
-        if (messages.length > 0) {
-            console.log("Found messages:", messages.length);
-            const lastMessage = messages[messages.length - 1];
-            console.log("Scrolling to last message");
-            lastMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-        } else {
-            console.log("No messages found, trying alternative selectors");
-            // Alternativa selektorer för Hugging Face
-            const altMessages = document.querySelectorAll('.bot, [data-testid="bot"], .message-wrap > div:last-child');
-            if (altMessages.length > 0) {
-                console.log("Found messages with alt selector:", altMessages.length);
-                const lastAltMessage = altMessages[altMessages.length - 1];
-                console.log("Scrolling to last alt message");
-                lastAltMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-            } else {
-                console.log("No messages found with any selector");
-            }
-        }
-    }, 100);  // Vänta 100 millisekunder innan scroll
-    
-    // Försök igen efter lite längre tid om första försöket misslyckas
-    setTimeout(function() {
-        console.log("Executing delayed scroll script");
-        const messages = document.querySelectorAll('.message, .bot, [data-testid="bot"], .message-wrap > div:last-child');
-        if (messages.length > 0) {
-            console.log("Found messages in delayed script:", messages.length);
-            const lastMessage = messages[messages.length - 1];
-            console.log("Scrolling to last message in delayed script");
-            lastMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-        }
-    }, 500);  // Vänta 500 millisekunder innan andra försöket
-    """
-    
-    # Returnera tomt meddelande och den uppdaterade chatthistoriken
-    return "", chat_history
-
-def format_chat_preview(chat_history):
-    if not chat_history:
-        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
-
-def show_support_form(chat_history):
-    preview = format_chat_preview(chat_history)
-    return {
-        chat_interface: gr.Group(visible=False),
-        support_interface: gr.Group(visible=True),
-        success_interface: gr.Group(visible=False),
-        chat_preview: preview
-    }
-
-def back_to_chat():
-    return {
-        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):
-    """Hanterar formulärinskickningen med bättre felhantering."""
-    print(f"Support-förfrågan: områdeskod={områdeskod}, uttagsnummer={uttagsnummer}, email={email}")
-    
-    # Validera input med tydligare loggning
-    validation_errors = []
-    
-    if områdeskod and not områdeskod.isdigit():
-        print(f"Validerar områdeskod: '{områdeskod}' (felaktig)")
-        validation_errors.append("Områdeskod måste vara numerisk.")
-    else:
-        print(f"Validerar områdeskod: '{områdeskod}' (ok)")
-    
-    if uttagsnummer and not uttagsnummer.isdigit():
-        print(f"Validerar uttagsnummer: '{uttagsnummer}' (felaktig)")
-        validation_errors.append("Uttagsnummer måste vara numerisk.")
-    else:
-        print(f"Validerar uttagsnummer: '{uttagsnummer}' (ok)")
-    
-    if not email:
-        print("Validerar email: (saknas)")
-        validation_errors.append("En giltig e-postadress krävs.")
-    elif '@' not in email or '.' not in email.split('@')[1]:
-        print(f"Validerar email: '{email}' (felaktigt format)")
-        validation_errors.append("En giltig e-postadress krävs.")
-    else:
-        print(f"Validerar email: '{email}' (ok)")
-    
-    # Om det finns valideringsfel
-    if validation_errors:
-        print(f"Valideringsfel: {validation_errors}")
-        return {
-            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 formuläret klarade valideringen, försök skicka till Slack
-    try:
-        print("Försöker skicka supportförfrågan till Slack...")
-        
-        # Skapa en förenklad chathistorik för loggning
-        chat_summary = []
-        for msg in chat_history:
-            if 'role' in msg and 'content' in msg:
-                chat_summary.append(f"{msg['role']}: {msg['content'][:30]}...")
-        print(f"Chatthistorik att skicka: {chat_summary}")
-        
-        # Skicka till Slack
-        success = send_support_to_slack(områdeskod, uttagsnummer, email, chat_history)
-        
-        if success:
-            print("Support-förfrågan skickad till Slack framgångsrikt")
-            return {
-                chat_interface: gr.Group(visible=False),
-                support_interface: gr.Group(visible=False),
-                success_interface: gr.Group(visible=True)
-            }
-        else:
-            print("Support-förfrågan till Slack misslyckades")
-            return {
-                chat_interface: gr.Group(visible=False),
-                support_interface: gr.Group(visible=True),
-                success_interface: gr.Group(visible=False),
-                chat_preview: "**Ett fel uppstod när meddelandet skulle skickas. Vänligen försök igen senare.**"
-            }
-    except Exception as e:
-        print(f"Oväntat fel vid hantering av support-formulär: {e}")
-        return {
-            chat_interface: gr.Group(visible=False),
-            support_interface: gr.Group(visible=True),
-            success_interface: gr.Group(visible=False),
-            chat_preview: f"**Ett fel uppstod: {str(e)}**"
-        }
-
 # --- Gradio UI ---
 initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
 
@@ -1218,10 +572,6 @@ body {background-color: #f7f7f7; font-family: Arial, sans-serif; margin: 0; padd
 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;}
@@ -1239,46 +589,6 @@ footer {display: none !important;}
 .gradio-container .gr-footer {display: none !important;}
 """
 
-# --- JavaScript för scrollning ---
-# Definiera JS-koden som en sträng här för att kunna använda den i _js parametern
-scroll_js = """
-    setTimeout(function() {
-        console.log("Executing scroll script");
-        const messages = document.querySelectorAll('.message');
-        if (messages.length > 0) {
-            console.log("Found messages:", messages.length);
-            const lastMessage = messages[messages.length - 1];
-            console.log("Scrolling to last message");
-            lastMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-        } else {
-            console.log("No messages found, trying alternative selectors");
-            // Alternativa selektorer för Hugging Face
-            const altMessages = document.querySelectorAll('.bot, [data-testid="bot"], .message-wrap > div:last-child');
-            if (altMessages.length > 0) {
-                console.log("Found messages with alt selector:", altMessages.length);
-                const lastAltMessage = altMessages[altMessages.length - 1];
-                console.log("Scrolling to last alt message");
-                lastAltMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-            } else {
-                console.log("No messages found with any selector");
-            }
-        }
-    }, 100);  // Vänta 100 millisekunder innan scroll
-    
-    // Försök igen efter lite längre tid om första försöket misslyckas
-    setTimeout(function() {
-        console.log("Executing delayed scroll script");
-        const messages = document.querySelectorAll('.message, .bot, [data-testid="bot"], .message-wrap > div:last-child');
-        if (messages.length > 0) {
-            console.log("Found messages in delayed script:", messages.length);
-            const lastMessage = messages[messages.length - 1];
-            console.log("Scrolling to last message in delayed script");
-            lastMessage.scrollIntoView({ behavior: 'smooth', block: 'start' });
-        }
-    }, 500);  // Vänta 500 millisekunder innan andra försöket
-"""
-
-# 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")
     
@@ -1296,11 +606,8 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             with gr.Column(scale=1):
                 support_btn = gr.Button("Behöver du mer hjälp?", elem_classes="support-btn")
     
-    # Ta bort den gamla app.load(js=...) eftersom scrollningen nu hanteras via gr.update
-    # app.load(js=js_code) 
-    
     # Support form interface (initially hidden)
-    with gr.Group(visible=False, elem_classes="support-form-container") as support_interface:
+    with gr.Group(visible=False) as support_interface:
         gr.Markdown("### Vänligen fyll i din områdeskod, uttagsnummer och din email adress")
         
         with gr.Group(elem_classes="gr-form"):
@@ -1320,15 +627,185 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         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")
     
-    # VIKTIGT: Händelsehanterare definieras INOM gr.Blocks-kontexten, efter att komponenterna definierats
-    # Uppdatera msg.submit för att hantera de två returvärdena från respond
-    # Använd _js parametern för att köra scroll-skriptet efter uppdateringen
-    msg.submit(respond, 
-               inputs=[msg, chatbot], 
-               outputs=[msg, chatbot], # msg, chatbot history
-               _js=scroll_js) 
+    def respond(message, chat_history, request: gr.Request):
+        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}"
+
+        platform = "webb"
+        if "chargenode.eu" in ref:
+            platform = "chargenode.eu"
+        elif "localhost" in ref:
+            platform = "test"
+        elif "app" in ref:
+            platform = "app"
+
+        log_data = {
+            "timestamp": timestamp,
+            "user_id": user_id,
+            "session_id": session_id,
+            "user_message": message,
+            "bot_reply": response,
+            "response_time": elapsed,
+            "ip": ip,
+            "browser": browser,
+            "os": osys,
+            "platform": platform
+        }
+
+        # Använd den förbättrade loggfunktionen
+        safe_append_to_log(log_data)
+        last_log = log_data
+
+        # Skicka varje konversation direkt till Slack
+        try:
+            # Konversationsinnehåll
+            conversation_content = f"""
+*Ny konversation {timestamp}*
+
+*Användare:* {message}
+
+*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=lambda: send_to_slack(f"Ny konversation", conversation_content),
+                daemon=True
+            ).start()
+        except Exception as e:
+            print(f"Kunde inte skicka konversation till Slack: {e}")
+
+        chat_history.append({"role": "user", "content": message})
+        chat_history.append({"role": "assistant", "content": response})
+        return "", chat_history
+    
+    def format_chat_preview(chat_history):
+        if not chat_history:
+            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
+    
+    def show_support_form(chat_history):
+        preview = format_chat_preview(chat_history)
+        return {
+            chat_interface: gr.Group(visible=False),
+            support_interface: gr.Group(visible=True),
+            success_interface: gr.Group(visible=False),
+            chat_preview: preview
+        }
+    
+    def back_to_chat():
+        return {
+            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):
+        """Hanterar formulärinskickningen med bättre felhantering."""
+        print(f"Support-förfrågan: områdeskod={områdeskod}, uttagsnummer={uttagsnummer}, email={email}")
+        
+        # Validera input med tydligare loggning
+        validation_errors = []
+        
+        if områdeskod and not områdeskod.isdigit():
+            print(f"Validerar områdeskod: '{områdeskod}' (felaktig)")
+            validation_errors.append("Områdeskod måste vara numerisk.")
+        else:
+            print(f"Validerar områdeskod: '{områdeskod}' (ok)")
+        
+        if uttagsnummer and not uttagsnummer.isdigit():
+            print(f"Validerar uttagsnummer: '{uttagsnummer}' (felaktig)")
+            validation_errors.append("Uttagsnummer måste vara numerisk.")
+        else:
+            print(f"Validerar uttagsnummer: '{uttagsnummer}' (ok)")
+        
+        if not email:
+            print("Validerar email: (saknas)")
+            validation_errors.append("En giltig e-postadress krävs.")
+        elif '@' not in email or '.' not in email.split('@')[1]:
+            print(f"Validerar email: '{email}' (felaktigt format)")
+            validation_errors.append("En giltig e-postadress krävs.")
+        else:
+            print(f"Validerar email: '{email}' (ok)")
+        
+        # Om det finns valideringsfel
+        if validation_errors:
+            print(f"Valideringsfel: {validation_errors}")
+            return {
+                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 formuläret klarade valideringen, försök skicka till Slack
+        try:
+            print("Försöker skicka supportförfrågan till Slack...")
+            
+            # Skapa en förenklad chathistorik för loggning
+            chat_summary = []
+            for msg in chat_history:
+                if 'role' in msg and 'content' in msg:
+                    chat_summary.append(f"{msg['role']}: {msg['content'][:30]}...")
+            print(f"Chatthistorik att skicka: {chat_summary}")
+            
+            # Skicka till Slack
+            success = send_support_to_slack(områdeskod, uttagsnummer, email, chat_history)
+            
+            if success:
+                print("Support-förfrågan skickad till Slack framgångsrikt")
+                return {
+                    chat_interface: gr.Group(visible=False),
+                    support_interface: gr.Group(visible=False),
+                    success_interface: gr.Group(visible=True)
+                }
+            else:
+                print("Support-förfrågan till Slack misslyckades")
+                return {
+                    chat_interface: gr.Group(visible=False),
+                    support_interface: gr.Group(visible=True),
+                    success_interface: gr.Group(visible=False),
+                    chat_preview: "**Ett fel uppstod när meddelandet skulle skickas. Vänligen försök igen senare.**"
+                }
+        except Exception as e:
+            print(f"Oväntat fel vid hantering av support-formulär: {e}")
+            return {
+                chat_interface: gr.Group(visible=False),
+                support_interface: gr.Group(visible=True),
+                success_interface: gr.Group(visible=False),
+                chat_preview: f"**Ett fel uppstod: {str(e)}**"
+            }
     
-    clear.click(lambda: (None, []), None, [msg, chatbot], queue=False) # Rensa både textbox och historik
+    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])
@@ -1339,4 +816,4 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
     )
 
 if __name__ == "__main__":
-    app.launch(share=True)
+    app.launch(share=True)