Update app.py

app.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 import os
 import json
 import time
@@ -37,743 +36,1215 @@ log_file_path = os.path.join(log_folder, "conversation_log_v2.txt")
 
 # Skapa en tom loggfil om den inte finns
 if not os.path.exists(log_file_path):
-    try:
-        with open(log_file_path, "w", encoding="utf-8") as f:
-            f.write("")  # Skapa en tom fil
-        print(f"Skapade tom loggfil: {log_file_path}")
-    except IOError as e:
-        print(f"Kunde inte skapa loggfil {log_file_path}: {e}")
-        # Överväg att avsluta om loggning är kritisk
-        # exit(1)
-
+    with open(log_file_path, "w", encoding="utf-8") as f:
+        f.write("")  # Skapa en tom fil
+    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
-commit_scheduler = None # Initiera till None
-if IS_HUGGINGFACE and hf_token:
-    try:
-        commit_scheduler = CommitScheduler(
-            repo_id="ChargeNodeEurope/logfiles", # Se till att detta repo finns och att token har rättigheter
-            repo_type="dataset",
-            folder_path=log_folder, # Se till att denna mapp existerar och är skrivbar
-            path_in_repo="logs_v2", # Mappsökväg i dataset-repot
-            every=300,  # Committa var 5:e minut (300 sekunder)
-            token=hf_token
-        )
-        print(f"CommitScheduler konfigurerad för att pusha '{log_folder}' till repo 'ChargeNodeEurope/logfiles' var 5:e minut.")
-    except Exception as e:
-        print(f"Kunde inte initiera CommitScheduler: {e}. Loggar kommer inte att sparas automatiskt till Hub.")
-        commit_scheduler = None # Säkerställ att den är None vid fel
-else:
-    print("Info: Kör lokalt eller HF_TOKEN saknas/ogiltig. 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
+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 med rotation och sanering."""
+    """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)
-
-        # Loggrotation (valfritt men rekommenderat)
+        
+        # Kontrollera loggfilens storlek
         try:
-            if os.path.exists(log_file_path):
-                log_size = os.path.getsize(log_file_path)
-                if log_size > 10 * 1024 * 1024: # 10 MB gräns
-                    timestamp_suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
-                    backup_path = f"{log_file_path}.{timestamp_suffix}.bak"
-                    os.rename(log_file_path, backup_path)
-                    print(f"Loggfil roterad: {log_file_path} -> {backup_path}")
-                    with open(log_file_path, "w", encoding="utf-8") as f: f.write("")
-        except FileNotFoundError: pass
-        except Exception as e: print(f"Fel vid loggrotation: {e}")
-
-        # Sanering
-        sanitized_entry = {k: (v.replace('\0', '')[:20000] if isinstance(v, str) else v) for k, v in log_entry.items()}
-
-        # Skriv till fil
+            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, ensure_ascii=False)
+            log_json = json.dumps(sanitized_entry)
             log_file.write(log_json + "\n")
-            log_file.flush()
-
+            log_file.flush()  # Säkerställ att data skrivs till disk omedelbart
+            
+        print(f"Loggpost tillagd: {log_entry.get('timestamp', 'okänd tid')}")
         return True
+        
     except Exception as e:
-        print(f"Allvarligt fel vid loggning: {e}")
+        print(f"Fel vid loggning: {e}")
+        
+        # Försök skapa mappen om den inte finns (detta bör redan ha gjorts ovan)
         try:
-            with open(os.path.join(log_folder, "logging_errors.txt"), "a", encoding="utf-8") as error_file:
-                error_file.write(f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')} - Loggningsfel: {e}\nOriginalpost (delvis): {str(log_entry)[:500]}\n")
-        except Exception as ef: print(f"Kunde inte ens logga loggningsfelet: {ef}")
-        return False
+            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
+            }
+            
+            with open(log_file_path, "a", encoding="utf-8") as log_file:
+                log_json = json.dumps(minimal_entry)
+                log_file.write(log_json + "\n")
+                
+            print("Minimal loggpost tillagd efter återhämtning")
+            return True
+            
+        except Exception as retry_error:
+            print(f"Kritiskt fel vid loggning: {retry_error}")
+            return False
 
 # --- Laddar textkällor ---
 def load_local_files():
     uploaded_text = ""
     allowed = [".txt", ".docx", ".pdf", ".csv", ".xls", ".xlsx"]
-    excluded_prefixes = ["requirements", "app", "conversation_log", "secrets", "logging_errors"]
-    current_dir = os.path.dirname(os.path.abspath(__file__)) if '__file__' in locals() else '.'
-
-    print(f"Söker efter filer i: {current_dir}")
-    items_in_dir = os.listdir(current_dir)
-    print(f"Hittade {len(items_in_dir)} objekt.")
-
-    files_processed = 0
-    for item in items_in_dir:
-        item_path = os.path.join(current_dir, item)
-        if not os.path.isfile(item_path): continue
-
-        is_allowed = item.lower().endswith(tuple(allowed))
-        is_excluded = any(item.lower().startswith(prefix) for prefix in excluded_prefixes)
-
-        if is_allowed and not is_excluded:
-            print(f"Bearbetar fil: {item}")
-            files_processed += 1
+    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:
-                content = ""
-                if item.endswith(".txt"):
-                    with open(item_path, "r", encoding="utf-8", errors='replace') as f: content = f.read()
-                elif item.endswith(".docx"):
-                    try:
-                        from docx import Document
-                        content = "\n".join([p.text for p in Document(item_path).paragraphs])
-                    except ImportError: print(f"Varning: 'python-docx' behövs för {item}.")
-                elif item.endswith(".pdf"):
-                    try:
-                        import PyPDF2
-                        with open(item_path, "rb") as f:
-                            reader = PyPDF2.PdfReader(f, strict=False) # strict=False kan hjälpa med korrupta filer
-                            if reader.is_encrypted:
-                                print(f"Varning: PDF {item} är krypterad.")
-                                try: # Försök dekryptera med tomt lösenord (vanligt)
-                                     if reader.decrypt('') == 0: # 0 = misslyckades
-                                          continue # Hoppa över filen
-                                except NotImplementedError:
-                                     print(f"Varning: Krypteringsmetoden för PDF {item} stöds inte av PyPDF2.")
-                                     continue
-                            temp_content = []
-                            for i, page in enumerate(reader.pages):
-                                try:
-                                    text = page.extract_text()
-                                    if text: temp_content.append(text)
-                                except Exception as page_err:
-                                     print(f"Fel vid extrahering av sida {i+1} från PDF {item}: {page_err}")
-                            content = "\n\n".join(temp_content) # Separera sidor tydligare
-                    except ImportError: print(f"Varning: 'PyPDF2' behövs för {item}.")
-                    except Exception as pdf_error: print(f"Fel vid läsning av PDF {item}: {str(pdf_error)}")
-                elif item.endswith(".csv"):
-                     try: content = pd.read_csv(item_path, encoding='utf-8', low_memory=False).to_string()
-                     except UnicodeDecodeError:
-                         try: content = pd.read_csv(item_path, encoding='latin1', low_memory=False).to_string()
-                         except Exception as csv_err: print(f"Fel vid läsning av CSV {item} (även med latin1): {csv_err}")
-                     except pd.errors.EmptyDataError: print(f"Varning: CSV {item} är tom.")
-                     except Exception as csv_err: print(f"Fel vid läsning av CSV {item}: {csv_err}")
-                elif item.endswith((".xls", ".xlsx")):
-                    try:
-                        df = pd.read_excel(item_path, sheet_name=None) # Läs alla ark
-                        all_sheets_content = []
-                        for sheet_name, sheet_df in df.items():
-                            sheet_content = ""
-                            if item.lower() == "faq stadat.xlsx" and 'Fråga' in sheet_df.columns and 'Svar' in sheet_df.columns:
-                                rows = [f"Fråga: {str(row['Fråga']) if pd.notna(row['Fråga']) else ''}\nSvar: {str(row['Svar']) if pd.notna(row['Svar']) else ''}"
-                                        for index, row in sheet_df.iterrows() if pd.notna(row['Fråga']) or pd.notna(row['Svar'])]
-                                sheet_content = "\n\n".join(rows)
-                            else:
-                                sheet_content = sheet_df.to_string()
-                            all_sheets_content.append(f"--- Ark: {sheet_name} ---\n{sheet_content}")
-                        content = "\n\n".join(all_sheets_content)
-                    except ImportError: print(f"Varning: 'openpyxl'/'xlrd' kan behövas för {item}.")
-                    except Exception as excel_err: print(f"Fel vid läsning av Excel {item}: {excel_err}")
-
-                if content and isinstance(content, str):
-                    uploaded_text += f"\n\n--- FIL: {item} ---\n{content}"
-                elif not content: print(f"Info: Ingen text extraherad från {item}")
-            except Exception as e: print(f"Allmänt fel vid bearbetning av {item}: {str(e)}")
-
-    if files_processed == 0: print("Varning: Inga filer hittades att ladda.")
-    else: print(f"Bearbetade {files_processed} filer.")
+                if file.endswith(".txt"):
+                    with open(file, "r", encoding="utf-8") as f:
+                        content = f.read()
+                elif file.endswith(".docx"):
+                    from docx import Document  # Import sker vid behov
+                    content = "\n".join([p.text for p in Document(file).paragraphs])
+                elif file.endswith(".pdf"):
+                    import PyPDF2  # Import sker vid behov
+                    with open(file, "rb") as f:
+                        reader = PyPDF2.PdfReader(f)
+                        content = "\n".join([p.extract_text() or "" for p in reader.pages])
+                elif file.endswith(".csv"):
+                    content = pd.read_csv(file).to_string()
+                elif file.endswith((".xls", ".xlsx")):
+                    if file == "FAQ stadat.xlsx":
+                        df = pd.read_excel(file)
+                        rows = []
+                        for index, row in df.iterrows():
+                            rows.append(f"Fråga: {row['Fråga']}\nSvar: {row['Svar']}")
+                        content = "\n\n".join(rows)
+                    else:
+                        content = pd.read_excel(file).to_string()
+                uploaded_text += f"\n\nFIL: {file}\n{content}"
+            except Exception as e:
+                print(f"Fel vid läsning av {file}: {str(e)}")
     return uploaded_text.strip()
 
 def load_prompt():
-    prompt_path = os.path.join(os.path.dirname(os.path.abspath(__file__)) if '__file__' in locals() else '.', "prompt.txt")
     try:
-        with open(prompt_path, "r", encoding="utf-8") as f: return f.read().strip()
-    except FileNotFoundError:
-        print(f"Info: prompt.txt ej hittad på {prompt_path}. Använder standardprompt.")
-        return "Du är en hjälpsam AI-assistent för ChargeNode. Svara kortfattat och vänligt baserat på den givna kontexten. Om kontext saknas eller inte är relevant, säg att du inte har informationen i dina dokument och hänvisa till supporten."
+        with open("prompt.txt", "r", encoding="utf-8") as f:
+            return f.read().strip()
     except Exception as e:
-        print(f"Fel vid läsning av prompt.txt: {e}")
-        return "Du är en hjälpsam AI-assistent." # Nöd-fallback
+        print(f"Fel vid prompt.txt: {e}")
+        return ""
 
 prompt_template = load_prompt()
 
 # Förbered textsegment
 def prepare_chunks(text_data):
-    global chunks, chunk_sources
-    local_chunks, local_sources = [], []
+    chunks, sources = [], []
     for source, text in text_data.items():
-        if not isinstance(text, str) or not text.strip(): continue
-        # Smartare splittning
-        paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
-        if len(paragraphs) < 5: # Om få dubbla radbrytningar, prova enkel
-             paragraphs = [p.strip() for p in text.split('\n') if p.strip()]
-        if not paragraphs: paragraphs = [text.strip()] # Om inga radbrytningar alls
-
-        current_chunk = ""
+        paragraphs = [p for p in text.split("\n") if p.strip()]
+        chunk = ""
         for para in paragraphs:
-            if not para: continue
-            if len(para) > MAX_CHUNK_SIZE:
-                if current_chunk:
-                    local_chunks.append(current_chunk); local_sources.append(source)
-                    current_chunk = ""
-                # Dela lång paragraf
-                for i in range(0, len(para), MAX_CHUNK_SIZE):
-                    local_chunks.append(para[i : i + MAX_CHUNK_SIZE]); local_sources.append(source)
-            elif len(current_chunk) + len(para) + 1 <= MAX_CHUNK_SIZE:
-                current_chunk += (" " + para if current_chunk else para)
+            if len(chunk) + len(para) + 1 <= MAX_CHUNK_SIZE:
+                chunk += " " + para
             else:
-                if current_chunk: local_chunks.append(current_chunk); local_sources.append(source)
-                current_chunk = para
-        if current_chunk: local_chunks.append(current_chunk); local_sources.append(source)
-
-    chunks = local_chunks; chunk_sources = local_sources
-    return chunks, chunk_sources
-
-# --- Embeddings ---
-embedder = None; embeddings = None; index = None
-chunks = []; chunk_sources = []
+                if chunk.strip():
+                    chunks.append(chunk.strip())
+                    sources.append(source)
+                chunk = para
+        if chunk.strip():
+            chunks.append(chunk.strip())
+            sources.append(source)
+    return chunks, sources
+
+# 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."""
+    """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 not None: return # Redan klar
-        print("Initierar Embeddings...")
-        try:
-            text_data = {"local_files": load_local_files()}
-            if not text_data["local_files"]:
-                 print("Varning: Ingen textdata för indexering.")
-                 embedder = SentenceTransformer('all-MiniLM-L6-v2')
-                 dim = embedder.get_sentence_embedding_dimension()
-                 index = faiss.IndexFlatIP(dim)
-                 chunks, chunk_sources = [], []
-                 embeddings = np.array([], dtype=np.float32).reshape(0, dim)
-                 print("Tomt index skapat.")
-                 return
-
-            chunks, chunk_sources = prepare_chunks(text_data)
-            print(f"{len(chunks)} segment förberedda.")
-            if not chunks:
-                 print("Varning: Inga segment skapades.")
-                 embedder = SentenceTransformer('all-MiniLM-L6-v2')
-                 dim = embedder.get_sentence_embedding_dimension()
-                 index = faiss.IndexFlatIP(dim)
-                 embeddings = np.array([], dtype=np.float32).reshape(0, dim)
-                 print("Tomt index skapat.")
-                 return
-
-            print("Skapar embeddings (kan ta tid)...")
-            embedder = SentenceTransformer('all-MiniLM-L6-v2')
-            embeddings_np = embedder.encode(chunks, convert_to_numpy=True, show_progress_bar=True)
-            if embeddings_np.size == 0: raise ValueError("Encoding resulterade i tomma embeddings.")
-
-            norms = np.linalg.norm(embeddings_np, axis=1, keepdims=True)
-            norms[norms == 0] = 1e-10
-            embeddings_np /= norms
-            embeddings = embeddings_np.astype(np.float32) # Spara som global variabel
-
-            dim = embeddings.shape[1]
-            index = faiss.IndexFlatIP(dim)
-            index.add(embeddings)
-            print(f"FAISS-index klart ({index.ntotal} vektorer, dim {dim}).")
-
-        except Exception as e:
-            print(f"FATALT FEL vid initiering av embeddings: {e}")
-            embedder, embeddings, index, chunks, chunk_sources = None, None, None, [], []
-            raise RuntimeError(f"Kunde inte initiera embeddings: {e}") from e
-
+        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"]
+
+                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."""
-    # initialize_embeddings() # Bör redan vara anropad vid start
-    if index is None or embedder is None or index.ntotal == 0:
-        print("Varning: Försöker hämta kontext när index inte är redo.")
-        return "Ingen kontext tillgänglig (index ej redo).", ["error"]
+    """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)
-        if query_embedding.size == 0: return "Kunde inte bearbeta frågan.", ["error"]
-        norm = np.linalg.norm(query_embedding); query_embedding /= (norm if norm != 0 else 1e-10)
-        query_embedding = query_embedding.astype(np.float32)
-
+        
+        # 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 == 0: return "", ["no_context"]
-
+        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 = [f"[Dokument {r+1}] {chunks[idx]}" for r, idx in enumerate(I[0]) if 0 <= idx < len(chunks)]
-        sources = list({chunk_sources[idx] for idx in I[0] if 0 <= idx < len(chunk_sources)})
-
-        if not retrieved: return "", (["no_context"] + sources) if sources else ["no_context"]
-        return "\n---\n".join(retrieved), sources
+        
+        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)[:100]}", ["error"]
+        return f"Fel vid kontexthämtning: {str(e)[:200]}", ["error"]
 
 def generate_answer(query):
-    """Genererar svar baserat på fråga och kontext."""
+    """Genererar svar baserat på fråga och kontextinformation."""
     context, sources = retrieve_context(query)
-    system_content = prompt_template
-    user_prompt = f"Kontext:\n{context if context else 'Ingen specifik kontext hittades.'}\n\nFråga: {query}"
-
-    if "error" in sources:
-        system_content += "\n(Varning: Fel vid kontexthämtning.)"
-    elif "no_context" in sources:
-         system_content += "\n(Info: Ingen specifik lokal kontext hittades.)"
-
+    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:
+{context}
+Fråga: {query}
+Svar (baserat enbart på den indexerade datan):"""
     try:
         response = client.chat.completions.create(
             model="gpt-3.5-turbo",
-            messages=[{"role": "system", "content": system_content}, {"role": "user", "content": user_prompt}],
-            temperature=0.2, max_tokens=500
+            messages=[
+                {"role": "system", "content": "Du är en expert på ChargeNodes produkter och tjänster. Svara enbart baserat på den information som finns i den indexerade datan."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.2,
+            max_tokens=500
         )
-        answer = response.choices[0].message.content.strip()
-        answer += "\n\n*AI-genererat svar.* För personlig hjälp, kontakta support@chargenode.eu / 010-205 10 55."
-        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 OpenAI API-anrop: {e}")
-        return f"Tekniskt fel vid svar ({type(e).__name__}). Försök igen eller kontakta support.\n\n*AI-genererat svar.* support@chargenode.eu / 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."); return False
+    if not webhook_url:
+        print("Slack webhook URL saknas")
+        return False
+    
     try:
-        safe_subject = subject[:150]; safe_content = content[:2900]
-        if len(content) > 2900: safe_content += "\n... (meddelandet trunkerat)"
-        payload = {"attachments": [{"color": color,"blocks": [{"type": "header","text": {"type": "plain_text","text": safe_subject,"emoji": True}},{"type": "divider"},{"type": "section","text": {"type": "mrkdwn","text": safe_content}}]}]}
-        response = requests.post(webhook_url, json=payload, headers={"Content-Type": "application/json"}, timeout=15)
-        if response.status_code == 200: return True
-        else: print(f"Slack-anrop misslyckades: {response.status_code}, {response.text}"); return False
-    except Exception as e: print(f"Fel vid sändning till Slack: {e}"); return False
+        # Formatera meddelandet för Slack
+        payload = {
+            "blocks": [
+                {
+                    "type": "header",
+                    "text": {
+                        "type": "plain_text",
+                        "text": subject
+                    }
+                },
+                {
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": content
+                    }
+                }
+            ]
+        }
+        
+        response = requests.post(
+            webhook_url,
+            json=payload,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        if response.status_code == 200:
+            print(f"Slack-meddelande skickat: {subject}")
+            return True
+        else:
+            print(f"Slack-anrop misslyckades: {response.status_code}, {response.text}")
+            return False
+    except Exception as e:
+        print(f"Fel vid sändning till Slack: {type(e).__name__}: {e}")
+        return False
 
 # --- Feedback & Like-funktion ---
 def vote(data: gr.LikeData):
+    """
+    Hanterar feedback från Gradio's inbyggda like-funktion.
+    data.liked är True om uppvote, annars False.
+    data.value innehåller information om meddelandet.
+    """
     feedback_type = "up" if data.liked else "down"
     global last_log, last_log_lock
-    bot_reply_liked = data.value if isinstance(data.value, str) else (data.value.get("value") if isinstance(data.value, dict) else "[Kunde inte extrahera svar]")
-
-    log_entry = {"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "event_type": "feedback", "feedback": feedback_type, "bot_reply_liked": bot_reply_liked}
-    user_message, session_id, associated_bot_reply, user_id, ip_address, platform = "[Okänd fråga]", "unknown", "[Okänt svar]", "unknown", "unknown", "unknown"
-
+    
+    # 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 = ""
+    
+    log_entry = {
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "feedback": feedback_type,
+        "bot_reply": bot_reply
+    }
+    
+    # Använd lock för att säkert komma åt last_log
     with last_log_lock:
-        if last_log and last_log.get("event_type") == "conversation":
-            user_message = last_log.get("user_message", user_message)
-            session_id = last_log.get("session_id", session_id)
-            associated_bot_reply = last_log.get("bot_reply", associated_bot_reply)
-            user_id, ip_address, platform = last_log.get("user_id", user_id), last_log.get("ip", ip_address), last_log.get("platform", platform)
-
-    log_entry.update({"session_id": session_id, "user_message": user_message, "associated_bot_reply": associated_bot_reply, "user_id": user_id, "ip": ip_address, "platform": platform})
+        # 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"),
+            })
+    
+    # Använd den förbättrade loggfunktionen
     safe_append_to_log(log_entry)
-
-    if feedback_type == "down":
-        try:
-            feedback_subject = f"👎 Negativ Feedback ({platform})"
-            feedback_message = f"*Fråga:* {user_message[:500]}\n*Svar (som fick 👎):* {bot_reply_liked[:500]}\n---\n*Session:* `{session_id[:8]}` | *IP:* `{ip_address}` | *Tid:* {log_entry['timestamp']}"
-            threading.Thread(target=send_to_slack, args=(feedback_subject, feedback_message.strip(), "#ff0000"), daemon=True).start()
-        except Exception as e: print(f"Kunde inte starta tråd för neg. feedback: {e}")
+    
+    # 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}
+
+*Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry.get('bot_reply', '')) > 300 else ''}
+"""
+            # Skicka asynkront
+            threading.Thread(
+                target=lambda: send_to_slack("Negativ feedback", feedback_message, "#ff0000"),
+                daemon=True
+            ).start()
+    except Exception as e:
+        print(f"Kunde inte skicka feedback till Slack: {e}")
+    
     return
 
 # --- Rapportering ---
 def read_logs():
+    """Läs alla loggposter från loggfilen."""
     logs = []
-    if not os.path.exists(log_file_path): return logs
     try:
-        with open(log_file_path, "r", encoding="utf-8", errors='replace') as file:
-            malformed_lines = 0
-            for line_count, line in enumerate(file, 1):
-                line = line.strip()
-                if not line: continue
-                try: logs.append(json.loads(line))
-                except json.JSONDecodeError: malformed_lines += 1
-            if malformed_lines > 0: print(f"Varning: {malformed_lines} felaktigt formaterade rader i loggfilen.")
-    except Exception as e: print(f"Fel vid läsning av loggfil: {e}")
+        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"Fel vid läsning av loggfil: {e}")
     return logs
 
 def get_latest_conversations(logs, limit=50):
-    # Implementering oförändrad...
+    """Hämta de senaste frågorna och svaren."""
     conversations = []
-    count = 0
     for log in reversed(logs):
-        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'],
                 'timestamp': log.get('timestamp', '')
             })
-            count += 1
-            if count >= limit: break
+            if len(conversations) >= limit:
+                break
     return conversations
 
 def get_feedback_stats(logs):
-    # Implementering oförändrad...
+    """Sammanfatta feedback (tumme upp/ned)."""
     feedback_count = {"up": 0, "down": 0}
     negative_feedback_examples = []
+    
     for log in logs:
-        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
-                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]')
-                    })
+            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):
-    # Implementering oförändrad...
+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(); now = datetime.now(); cutoff_date = now - timedelta(days=days)
-    if not all_logs: return {"error": "Inga loggdata."}
-    filtered_logs = [log for log in all_logs if (ts := log.get('timestamp')) and (log_date := _parse_datetime(ts)) and log_date >= cutoff_date]
-    if not filtered_logs: return {"error": f"Inga loggar senaste {days} dagarna."}
-
-    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']
-    total_conv = len(conv_logs)
-    unique_sess = len(set(log.get('session_id') for log in conv_logs if log.get('session_id')))
-    unique_users = len(set(log.get('user_id') for log in conv_logs if log.get('user_id')))
-    fb_stats, neg_ex = get_feedback_stats(feedback_logs); pos_fb, neg_fb = fb_stats.get("up",0), fb_stats.get("down",0); total_fb = pos_fb + neg_fb
-    fb_ratio = (pos_fb / total_fb * 100) if total_fb > 0 else 0
-    resp_times = [t for log in conv_logs if isinstance(t := log.get('response_time'), (int, float))]
-    avg_resp = sum(resp_times) / len(resp_times) if resp_times else 0
-    plats, brows, osys = {}, {}, {}
-    for log in conv_logs:
-        p, b, o = log.get('platform','?'), log.get('browser','?'), log.get('os','?')
-        plats[p], brows[b], osys[o] = plats.get(p,0)+1, brows.get(b,0)+1, osys.get(o,0)+1
-
+    
+    # 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 = []
+    
+    for log in logs:
+        if 'timestamp' in log:
+            try:
+                log_date = datetime.strptime(log['timestamp'], "%Y-%m-%d %H:%M:%S")
+                if log_date >= cutoff_date:
+                    filtered_logs.append(log)
+            except:
+                pass  # Hoppa över poster med ogiltigt datum
+    
+    logs = filtered_logs
+    
+    # Basstatistik
+    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
+    
+    # Plattformsstatistik
+    platforms = {}
+    browsers = {}
+    operating_systems = {}
+    for log in logs:
+        if 'platform' in log:
+            platforms[log['platform']] = platforms.get(log['platform'], 0) + 1
+        if 'browser' in log:
+            browsers[log['browser']] = browsers.get(log['browser'], 0) + 1
+        if 'os' in log:
+            operating_systems[log['os']] = operating_systems.get(log['os'], 0) + 1
+    
+    # Skapa rapport
     report = {
-        "period": f"{days} dagar ({cutoff_date.strftime('%Y-%m-%d')} - {now.strftime('%Y-%m-%d')})", "generated_at": now.strftime("%Y-%m-%d %H:%M:%S"),
-        "basic_stats": {"conv": total_conv, "sess": unique_sess, "users": unique_users, "msg_p_sess": round(total_conv/unique_sess,2) if unique_sess else 0},
-        "feedback": {"total": total_fb, "pos": pos_fb, "neg": neg_fb, "satisfaction": round(fb_ratio,1)},
-        "performance": {"avg_resp_sec": round(avg_resp,2)},
-        "top_platforms": dict(sorted(plats.items(), key=lambda i: i[1], reverse=True)[:5]),
-        "top_browsers": dict(sorted(brows.items(), key=lambda i: i[1], reverse=True)[:5]),
-        "top_os": dict(sorted(osys.items(), key=lambda i: i[1], reverse=True)[:5]),
-        "neg_feedback_examples": neg_ex
+        "period": f"Senaste {days} dagarna",
+        "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "basic_stats": {
+            "total_conversations": total_conversations,
+            "unique_sessions": unique_sessions,
+            "unique_users": unique_users,
+            "messages_per_user": round(total_conversations / unique_users, 2) if unique_users else 0
+        },
+        "feedback": {
+            "positive": positive_feedback,
+            "negative": negative_feedback,
+            "ratio_percent": round(feedback_ratio, 1)
+        },
+        "performance": {
+            "avg_response_time": round(avg_response_time, 2)
+        },
+        "platform_distribution": platforms,
+        "browser_distribution": browsers,
+        "os_distribution": operating_systems
     }
+    
     return report
 
-def _parse_datetime(ts_str):
-    try: return datetime.strptime(ts_str, "%Y-%m-%d %H:%M:%S")
-    except (ValueError, TypeError): return None
-
-def format_report_for_slack(stats_dict):
-    # Implementering oförändrad...
-    if 'error' in stats_dict: return f"*Fel:* {stats_dict['error']}"
-    b, f, p = stats_dict["basic_stats"], stats_dict["feedback"], stats_dict["performance"]
-    plats, brows, osys, neg_ex = stats_dict["top_platforms"], stats_dict["top_browsers"], stats_dict["top_os"], stats_dict["neg_feedback_examples"]
-    fmt_d = lambda d: "\n".join([f"- {k}: {v}" for k, v in d.items()]) if d else "_Ingen data_"
-    fmt_neg = lambda exs: "\n".join([f"- `{ex['user_message'][:60]}`->`{ex['bot_reply_liked'][:60]}`" for ex in exs]) if exs else "_Inga_"
-    return f"""*Period:* {stats_dict['period']} ({stats_dict['generated_at']})
-*📊 Anv:* Konv: {b['conv']}, Sess: {b['sess']}, Anv(est): {b['users']}, Med/Sess: {b['msg_p_sess']}
-*👍👎 Feedback:* Tot: {f['total']} ({f['pos']}👍/{f['neg']}👎), Nöjdhet: {f['satisfaction']}%
-*⚡ Prestanda:* Svarstid: {p['avg_resp_sec']}s
-*💻 Teknik:* Platf:\n{fmt_d(plats)}\nWebbläs:\n{fmt_d(brows)}\nOS:\n{fmt_d(osys)}
-*📉 Neg. Feedback Exempel:*\n{fmt_neg(neg_ex)}""".strip()
-
-def send_status_report(days=7, report_type="Daglig"):
-    print(f"Genererar {report_type.lower()} rapport...")
-    title = f"ChargeNode AI - {report_type} Status"
+def simple_status_report():
+    """Skickar en förenklad statusrapport till Slack."""
+    print("Genererar statusrapport för Slack...")
+    
     try:
-        stats = generate_periodic_stats(days=days)
-        content = format_report_for_slack(stats)
-        color = "#3498db" if "error" not in stats else "#ff0000"
-        send_to_slack(title, content, color)
+        # Generera statistik
+        stats = generate_monthly_stats(days=7)  # Senaste veckan
+        
+        # Skapa innehåll för Slack
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        subject = f"ChargeNode AI Bot - Status {now}"
+        
+        if 'error' in stats:
+            content = f"*Fel vid generering av statistik:* {stats['error']}"
+            return send_to_slack(subject, content, "#ff0000")
+        
+        # Formatera statistik
+        basic = stats["basic_stats"]
+        feedback = stats["feedback"]
+        perf = stats["performance"]
+        
+        content = f"""
+*ChargeNode AI Bot - Statusrapport {now}*
+
+*Basstatistik* (senaste 7 dagarna)
+- Totalt antal konversationer: {basic['total_conversations']}
+- Unika sessioner: {basic['unique_sessions']}
+- Unika användare: {basic['unique_users']}
+- Genomsnittlig svarstid: {perf['avg_response_time']} sekunder
+
+*Feedback*
+- 👍 Tumme upp: {feedback['positive']}
+- 👎 Tumme ned: {feedback['negative']}
+- Nöjdhet: {feedback['ratio_percent']}%
+"""
+        
+        # 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"Fel vid {report_type.lower()} rapport: {e}")
-        try: send_to_slack(f"🚨 Fel: {title}", f"*Fel:* `{type(e).__name__}: {e}`", "#ff0000")
-        except: pass # Ignorera fel vid sändning av felmeddelande
+        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):
-    # Implementering oförändrad...
-    if not email: print("Fel: Email saknas."); return False
+    """Skickar en supportförfrågan till Slack."""
     try:
-        hist_limit = 15; start_idx = max(0, len(chat_history) - hist_limit)
-        chat_content = "\n\n".join([f"*{('👤 Anv' if m['role']=='user' else '🤖 Bot')} ({i+1}):* {m['content'][:400]}{'...' if len(m['content'])>400 else ''}"
-                                  for i, m in enumerate(chat_history[start_idx:]) if isinstance(m, dict) and 'role' in m and 'content' in m])
-        subject = f"📩 Support via Chatbot ({email})"
-        ts = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-        content = f"*Ny supportförfrågan* ({ts})\n*Kontakt:* {email}\n*Områdeskod:* `{områdeskod or '?'}`\n*Uttag:* `{uttagsnummer or '?'}`\n---\n*Chatthistorik (senaste {min(hist_limit, len(chat_history))}):*\n{chat_content or '_Ingen historik_'}"
-        return send_to_slack(subject, content.strip(), "#f4a261")
-    except Exception as e: print(f"Fel vid sändning av support: {e}"); return False
-
-# --- Schemaläggning ---
-scheduler_running = True
+        # Formatera chat-historiken
+        chat_content = ""
+        for msg in chat_history:
+            if msg['role'] == 'user':
+                chat_content += f">*Användare:* {msg['content']}\n\n"
+            elif msg['role'] == 'assistant':
+                chat_content += f">*Bot:* {msg['content'][:300]}{'...' if len(msg['content']) > 300 else ''}\n\n"
+        
+        # Skapa innehåll
+        subject = f"Support förfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+        
+        content = f"""
+*Användarinformation*
+- *Områdeskod:* {områdeskod or 'Ej angiven'}
+- *Uttagsnummer:* {uttagsnummer or 'Ej angiven'}
+- *Email:* {email}
+- *Tidpunkt:* {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+*Chatthistorik:*
+{chat_content}
+"""
+        
+        # Skicka till Slack
+        return send_to_slack(subject, content, "#e76f51")
+    except Exception as e:
+        print(f"Fel vid sändning av support till Slack: {type(e).__name__}: {e}")
+        return False
+
+# --- Schemaläggning av rapporter ---
 def run_scheduler():
-    global scheduler_running
-    print("Startar schemaläggare...")
-    schedule.every().day.at("08:00").do(lambda: send_status_report(days=1, report_type="Daglig"))
-    schedule.every().monday.at("09:00").do(lambda: send_status_report(days=7, report_type="Veckovis"))
-    schedule.every().day.at("10:00").do(monthly_report_if_first_day)
-    print("Schema konfigurerat.")
-    while scheduler_running:
-        try:
-            schedule.run_pending()
-            for _ in range(60): # Check flag more often
-                 if not scheduler_running: break
-                 time.sleep(1)
-        except Exception as e: print(f"Fel i schemaläggare: {e}"); time.sleep(300)
-    print("Schemaläggare avslutas.")
-
-def monthly_report_if_first_day():
-    if datetime.now().day == 1:
-        print("Kör månadsrapport..."); send_status_report(days=30, report_type="Månadsvis")
-
-scheduler_thread = None
-if os.environ.get("SLACK_WEBHOOK_URL"):
-    scheduler_thread = threading.Thread(target=run_scheduler, daemon=True); scheduler_thread.start()
-else: print("Info: Slack Webhook saknas, rapporter ej aktiva.")
-
-# --- Städning vid avslut ---
+    """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")
+
+# 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():
-    global scheduler_running, scheduler_thread, commit_scheduler
+    """Städa upp resurser vid avslut."""
     print("Städar upp resurser...")
-    if scheduler_thread and scheduler_thread.is_alive():
-        print("Stoppar schemaläggare..."); scheduler_running = False
-        scheduler_thread.join(timeout=5)
-        print("Schemaläggare stoppad." if not scheduler_thread.is_alive() else "Varning: Schemaläggare timeout.")
-    if commit_scheduler:
-        print("Försöker pusha sista loggarna till Hub...")
+    # Stäng scheduler om möjligt
+    schedule.clear()
+    
+    # Stäng CommitScheduler om den är aktiv
+    if 'scheduler' in globals() and scheduler:
         try:
-            # Kör i tråd för att undvika blockering vid exit
-            threading.Thread(target=commit_scheduler.push_to_hub, daemon=False).start()
-            time.sleep(5) # Ge lite tid att starta
-            print("Sista push initierad (bakgrunden).")
-        except Exception as e: print(f"Fel vid sista push: {e}")
-    # Försök stänga filer (best effort)
+            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 hasattr(obj, 'closed') and not obj.closed:
-                try: obj.close()
-                except: pass
-        print("Försökt stänga filer.")
-    except Exception as e: print(f"Fel vid filstängning: {e}")
+            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)
 
-# --- Inledande rapport ---
-def initial_startup_report():
-    time.sleep(15); print("Skickar uppstartsrapport..."); send_status_report(days=1, report_type="Uppstart")
-if os.environ.get("SLACK_WEBHOOK_URL"): threading.Thread(target=initial_startup_report, daemon=True).start()
+# Kör en statusrapport vid uppstart för att verifiera att allt fungerar
+try:
+    print("Skickar en inledande statusrapport för att verifiera Slack-integrationen...")
+    # Anropa inte direkt här - sker i schemaläggaren
+except Exception as e:
+    print(f"Information: Statusrapport kommer att skickas enligt schema: {e}")
 
-# --- UI Funktioner ---
+# Definiera respond och chat-relaterade funktioner före Gradio UI
 def respond(message, chat_history, request: gr.Request):
     global last_log, last_log_lock
-    if not message or not isinstance(message, str) or message.isspace(): return "", chat_history
-    message = message.strip()[:1500]
-    start_time = time.time()
-    try: bot_response = generate_answer(message)
-    except Exception as e: print(f"Fel vid generate_answer: {e}"); bot_response = f"Internt fel ({type(e).__name__}). Kontakta support."
-    response_time = round(time.time() - start_time, 2)
+    
+    # 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:
+        response = generate_answer(message)
+    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: {str(e)[:50]}"
+    
+    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 last_log.get("event_type") == "conversation": session_id = last_log.get("session_id", session_id)
-    user_id, ip_address, browser_info, os_info, platform, referer = "okänd", "okänd", "Okänd", "Okänd", "webb", ""
+        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 request.client else "?"
-            hdrs = request.headers; ip_cand = [hdrs.get("x-forwarded-for"), hdrs.get("x-real-ip"), user_id]
-            ip_address = next((ip.split(',')[0].strip() for ip in ip_cand if ip), user_id)
-            ua_str = hdrs.get("user-agent",""); referer = hdrs.get("referer","")
-            if ua_str: ua = parse_ua(ua_str); browser_info=f"{ua.browser.family} {ua.browser.version_string}" if ua.browser else "?"; os_info=f"{ua.os.family} {ua.os.version_string}" if ua.os else "?"
-            if referer:
-                if "chargenode.eu" in referer: platform = "chargenode.eu"
-                elif any(s in referer for s in ["localhost", "127.0."]): platform = "test"
-                elif "app" in referer: platform = "app"
-            else: platform = "direkt/?"
-        except Exception as req_err: print(f"Fel vid req metadata: {req_err}")
-
-    log_data = {"timestamp": timestamp, "event_type": "conversation", "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}
+            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)
-    with last_log_lock: last_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:
-        slack_subj = f"💬 Ny konv ({platform})"
-        slack_cont = f"*Anv:* {message}\n*Bot:* {bot_response[:350]}{'...' if len(bot_response)>350 else ''}\n---\n*Info:* `{timestamp}` | `{session_id[:8]}` | `{ip_address}` | `{browser_info}` | `{os_info}`"
-        threading.Thread(target=send_to_slack, args=(slack_subj, slack_cont.strip(), "#ADD8E6"), daemon=True).start()
-    except Exception as e: print(f"Kunde inte starta Slack-tråd: {e}")
+        # Konversationsinnehåll
+        conversation_content = f"""
+*Ny konversation {timestamp}*
+
+*Användare:* {message}
+
+*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}
 
-    chat_history.append({"role": "user", "content": message})
-    chat_history.append({"role": "assistant", "content": bot_response})
-    return "", chat_history
+*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
+    """
+    
+    return "", chat_history, gr.update(javascript=scroll_js)
 
 def format_chat_preview(chat_history):
-    # Implementering oförändrad...
-    if not chat_history: return "_Ingen historik_"
-    hist_limit = 15; start_idx = max(0, len(chat_history) - hist_limit)
-    return "\n\n".join([f"**{'Du' if m['role']=='user' else 'Bot'}:** {m['content'][:150]}{'...' if len(m['content'])>150 else ''}"
-                       for m in chat_history[start_idx:] if isinstance(m, dict) and 'role' in m and 'content' in m]).strip()
+    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_md = 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)}
+    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.update(visible=True), support_interface: gr.update(visible=False), success_interface: gr.update(visible=False)}
+    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):
-    # Implementering oförändrad...
-    errors = []
-    if områdeskod and not områdeskod.isdigit(): errors.append("Områdeskod?")
-    if uttagsnummer and not uttagsnummer.isdigit(): errors.append("Uttagsnummer?")
-    if not email or '@' not in email or '.' not in email.split('@')[-1]: errors.append("E-post?")
-    if errors:
-        msg = "**Valideringsfel:**\n- " + "\n- ".join(errors)
-        return {chat_interface: gr.update(visible=False), support_interface: gr.update(visible=True), success_interface: gr.update(visible=False), chat_preview: gr.update(value=msg)}
+    """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: return {chat_interface: gr.update(visible=False), support_interface: gr.update(visible=False), success_interface: gr.update(visible=True), chat_preview: gr.update(value="")}
-        else: msg = "**Fel:** Meddelandet kunde inte skickas. Försök igen eller maila support@chargenode.eu."
-    except Exception as e: msg = f"**Oväntat fel:** {e}"
-    return {chat_interface: gr.update(visible=False), support_interface: gr.update(visible=True), success_interface: gr.update(visible=False), chat_preview: gr.update(value=msg)}
+        
+        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 Definition ---
-initial_chat = [{"role": "assistant", "content": "Hej! Jag är ChargeNodes AI-assistent. Ställ din fråga nedan."}]
+# --- Gradio UI ---
+initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
 
 custom_css = """
-body { font-family: sans-serif; margin: 0; padding: 0; background-color: #f8f9fa; }
-.gradio-container { max-width: 420px !important; margin: 10px auto; box-shadow: 0 2px 10px rgba(0,0,0,0.1); border-radius: 10px; background-color: #ffffff; overflow: hidden; border: 1px solid #dee2e6; position: fixed; bottom: 15px; right: 15px; }
-h1 { font-family: 'Segoe UI', sans-serif; color: #1e88e5; text-align: center; margin: 0.8em 0 0.6em 0; font-size: 1.4em; font-weight: 600; }
-#chatbot_conversation .message-wrap { padding: 12px; }
-#chatbot_conversation { min-height: 280px; max-height: 350px; overflow-y: auto; border-bottom: 1px solid #e9ecef; background-color: #f8f9fa;}
-.message { padding: 8px 12px; margin-bottom: 6px; border-radius: 15px; max-width: 88%; word-wrap: break-word; line-height: 1.4; font-size: 0.95em;}
-.message.user { background-color: #e3f2fd; border-radius: 15px 15px 5px 15px; margin-left: auto; }
-.message.bot { background-color: #e9ecef; border-radius: 15px 15px 15px 5px; margin-right: auto; }
-.support-form-container, .success-interface { padding: 15px 20px; }
-.support-form-container .gr-form { margin-top: 10px; padding: 15px; border: 1px solid #ced4da; border-radius: 8px; background-color: #f1f3f5; }
-.gr-button { background-color: #1e88e5; color: white; border: none; border-radius: 5px; padding: 9px 16px; margin: 4px; cursor: pointer; transition: background-color 0.2s ease; font-weight: 500; font-size: 0.9em; }
-.gr-button:hover { background-color: #1565c0; }
-.support-btn { background-color: #6c757d; } .support-btn:hover { background-color: #5a6268; }
-.clear-btn { background-color: #dc3545; } .clear-btn:hover { background-color: #c82333; }
-.flex-row { display: flex; flex-direction: row; gap: 8px; align-items: center; }
-.chat-preview { max-height: 140px; overflow-y: auto; border: 1px solid #ced4da; padding: 10px; margin-top: 12px; font-size: 0.85em; background-color: #ffffff; border-radius: 4px; line-height: 1.3; }
-.success-message { font-size: 1.05em; font-weight: 500; color: #28a745; margin-bottom: 15px; text-align: center; }
-footer { display: none !important; }
-.gradio-container footer, .gradio-container .gr-footer { display: none !important; visibility: hidden !important; }
-.gr-textbox textarea { border-radius: 5px; border: 1px solid #ced4da; padding: 10px; font-size: 0.95em;}
-.block.padded { padding: 10px 15px !important; }
-.block.gap { gap: 8px !important; }
+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("# ChargeNode AI Assistent")
-
+    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',  # <<< KORRIGERAD HÄR
-            elem_id="chatbot_conversation",
-            label="Chatt", show_label=False
-            # bubble_full_width är borttagen
-        )
-        chatbot.like(vote, inputs=None, outputs=None)
-
-        with gr.Row(equal_height=False):
-            msg = gr.Textbox(label="Meddelande", placeholder="Skriv din fråga här...", show_label=False, scale=4, lines=1, max_lines=3)
-            # submit_btn = gr.Button("Skicka", scale=1, min_width=80) # Ta bort om Enter räcker
-
+        chatbot = gr.Chatbot(value=initial_chat, type="messages", elem_id="chatbot_conversation")
+        chatbot.like(vote, None, None)
+        
         with gr.Row():
-            clear_btn = gr.Button("Rensa chatt", elem_classes="clear-btn")
-            support_btn = gr.Button("Kontakta support", elem_classes="support-btn")
-
-    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"):
-            email = gr.Textbox(label="Din E-postadress", placeholder="din.email@example.com", info="Obligatorisk.")
-            områdeskod = gr.Textbox(label="Områdeskod (frivilligt)", placeholder="t.ex. 12345")
-            uttagsnummer = gr.Textbox(label="Uttagsnummer (frivilligt)", placeholder="t.ex. 1")
-            gr.Markdown("#### Chatthistorik (senaste)")
-            chat_preview = gr.Markdown(value="_Laddar..._", elem_classes="chat-preview")
-            with gr.Row():
-                back_btn = gr.Button("Avbryt")
-                send_support_btn = gr.Button("Skicka till Support")
-
-    with gr.Group(visible=False) as success_interface:
-        gr.Markdown("✅ Tack! Din förfrågan har skickats.", elem_classes="success-message")
-        back_to_chat_btn = gr.Button("Tillbaka till chatten")
-
-    # --- JavaScript för Scrollning ---
+            msg = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                clear = gr.Button("Rensa")
+            with gr.Column(scale=1):
+                support_btn = gr.Button("Behöver du mer hjälp?", elem_classes="support-btn")
+    
+    # Lägg till anpassad JavaScript för att styra scrollning och förhindra auto-scroll
     js_code = """
-    function scrollToTopOfLatestBotMessage() {
-        const selectorOptions = [
-            '.gradio-container .message-wrap .message.bot:last-child',
-            '.gradio-container [data-testid="bot"]:last-child',
-            '.gradio-container #chatbot_conversation .message:is(.bot, [data-testid="bot"]):last-of-type'
-        ];
-        let latestBotMessage = null;
-        for (const selector of selectorOptions) {
-            latestBotMessage = document.querySelector(selector);
-            if (latestBotMessage) break;
-        }
-        if (latestBotMessage) {
-            try { latestBotMessage.scrollIntoView({ block: 'start', behavior: 'smooth' }); }
-            catch (e) {
-                console.error("Scroll Error:", e);
-                const chatContainer = latestBotMessage.closest('#chatbot_conversation .message-wrap');
-                if (chatContainer) { try { chatContainer.scrollTop = latestBotMessage.offsetTop - chatContainer.offsetTop; } catch (e2) {} }
+    // Förhindra Gradio's automatiska scrollning till botten
+    (function() {
+        // Spara originella scrollTo och scrollIntoView funktioner
+        const originalScrollTo = window.scrollTo;
+        const originalElementScrollIntoView = Element.prototype.scrollIntoView;
+        const originalScrollIntoView = HTMLElement.prototype.scrollIntoView;
+        
+        // Övervaka och förhindra automatisk scrollning till botten
+        window.scrollTo = function(x, y) {
+            console.log('scrollTo intercepted:', x, y);
+            // Tillåt bara scrollning som inte är till botten av sidan
+            if (typeof y !== 'number' || y < document.body.scrollHeight - window.innerHeight - 100) {
+                originalScrollTo.apply(this, arguments);
+            } else {
+                console.log('Prevented automatic scroll to bottom');
+            }
+        };
+        
+        // Övervaka scrollIntoView anrop
+        Element.prototype.scrollIntoView = function(options) {
+            console.log('Element scrollIntoView intercepted', this, options);
+            // Kontrollera om elementet är ett botmeddelande eller en del av chattcontainern
+            if (this.classList && (
+                this.classList.contains('message') || 
+                this.classList.contains('bot') || 
+                this.closest('.message-wrap')
+            )) {
+                console.log('Handling chat element scrollIntoView');
+                // Anropa vår egen scrollningsfunktion istället
+                handleChatScroll();
+                return;
             }
+            // Annars, låt originella funktionen köra
+            originalElementScrollIntoView.apply(this, arguments);
+        };
+        
+        HTMLElement.prototype.scrollIntoView = Element.prototype.scrollIntoView;
+        
+        console.log('Scroll interception set up');
+    })();
+
+    // Huvudfunktion för att hantera chattscrollning
+    function handleChatScroll() {
+        console.log('handleChatScroll called');
+        
+        // Hitta chattcontainern
+        const chatContainers = [
+            document.querySelector('#chatbot_conversation .message-wrap'),
+            document.querySelector('.gradio-container .chat'),
+            document.querySelector('.gradio-container [id^="component-"] .chat'),
+            document.querySelector('.gradio-container .message-wrap')
+        ].filter(Boolean);
+        
+        if (chatContainers.length === 0) {
+            console.log('No chat container found');
+            return;
+        }
+        
+        const chatContainer = chatContainers[0];
+        console.log('Found chat container:', chatContainer);
+        
+        // Hitta alla botmeddelanden
+        const botMessages = [
+            ...Array.from(document.querySelectorAll('.message.bot')),
+            ...Array.from(document.querySelectorAll('[data-testid="bot"]')),
+            ...Array.from(document.querySelectorAll('.message:not(.user)'))
+        ].filter(Boolean);
+        
+        if (botMessages.length === 0) {
+            console.log('No bot messages found');
+            return;
+        }
+        
+        // Hitta det senaste botmeddelandet
+        const latestBotMessage = botMessages[botMessages.length - 1];
+        console.log('Latest bot message:', latestBotMessage);
+        
+        // Beräkna position för att visa botmeddelandet i toppen
+        try {
+            const containerRect = chatContainer.getBoundingClientRect();
+            const messageRect = latestBotMessage.getBoundingClientRect();
+            const relativeTop = messageRect.top - containerRect.top;
+            
+            // Scrolla så att botmeddelandet är i toppen
+            chatContainer.scrollTop = chatContainer.scrollTop + relativeTop - 10; // 10px marginal
+            console.log('Scrolled chat container to show bot message at top');
+            
+            // Förhindra ytterligare scrollning under en kort period
+            chatContainer.style.overflowY = 'hidden';
+            setTimeout(() => {
+                chatContainer.style.overflowY = '';
+            }, 500);
+        } catch (e) {
+            console.error('Error during manual scrolling:', e);
         }
     }
-    function setupObserver() {
-        const chatRoot = document.querySelector('#chatbot_conversation');
-        if (!chatRoot) { setTimeout(setupObserver, 300); return; }
-        const observer = new MutationObserver((mutationsList) => {
-            let botMessageAdded = false;
-            for (const mutation of mutationsList) {
-                if (mutation.type === 'childList' && mutation.addedNodes.length > 0) {
-                    mutation.addedNodes.forEach(node => {
-                        if (node.nodeType === Node.ELEMENT_NODE && (node.matches('.message.bot') || node.matches('[data-testid="bot"]'))) { botMessageAdded = true; }
-                        else if (node.nodeType === Node.ELEMENT_NODE && node.querySelector && (node.querySelector('.message.bot') || node.querySelector('[data-testid="bot"]'))) { botMessageAdded = true; }
+
+    // Lyssna på DOM-ändringar för att upptäcka nya meddelanden
+    document.addEventListener('DOMContentLoaded', function() {
+        console.log('DOM loaded, setting up observers');
+        
+        // Använd MutationObserver för att upptäcka nya meddelanden
+        const observer = new MutationObserver(function(mutations) {
+            let newBotMessage = false;
+            
+            mutations.forEach(function(mutation) {
+                if (mutation.type === 'childList' && mutation.addedNodes.length) {
+                    mutation.addedNodes.forEach(function(node) {
+                        if (node.nodeType === 1) { // Element node
+                            // Kontrollera om det är ett botmeddelande
+                            if (node.classList && (
+                                node.classList.contains('bot') || 
+                                node.classList.contains('message')
+                            )) {
+                                newBotMessage = true;
+                            }
+                            // Eller om det innehåller ett botmeddelande
+                            else if (node.querySelector && (
+                                node.querySelector('.bot') || 
+                                node.querySelector('.message:not(.user)')
+                            )) {
+                                newBotMessage = true;
+                            }
+                        }
                     });
                 }
-                if (botMessageAdded) break;
+            });
+            
+            if (newBotMessage) {
+                console.log('New bot message detected');
+                // Använd flera timeouts för att säkerställa att scrollningen fungerar
+                // efter att alla DOM-uppdateringar är klara
+                setTimeout(handleChatScroll, 100);
+                setTimeout(handleChatScroll, 300);
+                setTimeout(handleChatScroll, 500);
+                setTimeout(handleChatScroll, 1000);
             }
-            if (botMessageAdded) { setTimeout(scrollToTopOfLatestBotMessage, 200); }
         });
-        observer.observe(chatRoot, { childList: true, subtree: true });
-    }
-    if (document.readyState === 'loading') { document.addEventListener('DOMContentLoaded', setupObserver); } else { setupObserver(); }
+        
+        // Starta övervakning av hela dokumentet
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true
+        });
+        
+        console.log('MutationObserver started');
+        
+        // Lyssna även på klickhändelser för att hantera scrollning efter användarinteraktion
+        document.addEventListener('click', function(event) {
+            // Fördröj för att låta eventuella UI-uppdateringar slutföras
+            setTimeout(handleChatScroll, 300);
+        });
+    });
+    
+    // Lägg till CSS för att förbättra scrollningsbeteendet
+    const style = document.createElement('style');
+    style.textContent = `
+        #chatbot_conversation .message-wrap {
+            scroll-behavior: smooth !important;
+            overflow-anchor: none !important; /* Förhindra automatisk ankring */
+        }
+        .message.bot {
+            scroll-margin-top: 10px !important;
+        }
+    `;
+    document.head.appendChild(style);
     """
     app.load(js=js_code)
+    
+    # Support form interface (initially hidden)
+    with gr.Group(visible=False, elem_classes="support-form-container") as support_interface:
+        gr.Markdown("### Vänligen fyll i din områdeskod, uttagsnummer och din email adress")
+        
+        with gr.Group(elem_classes="gr-form"):
+            områdeskod = gr.Textbox(label="Områdeskod", placeholder="Områdeskod (valfritt)", info="Numeriskt värde")
+            uttagsnummer = gr.Textbox(label="Uttagsnummer", placeholder="Uttagsnummer (valfritt)", info="Numeriskt värde")
+            email = gr.Textbox(label="Din email adress", placeholder="din@email.se", info="Email adress krävs")
+            
+            gr.Markdown("### Chat som skickas till support:")
+            chat_preview = gr.Markdown(elem_classes="chat-preview")
+            
+            with gr.Row():
+                back_btn = gr.Button("Tillbaka")
+                send_support_btn = gr.Button("Skicka")
+    
+    # Success message (initially hidden)
+    with gr.Group(visible=False) as success_interface:
+        gr.Markdown("Tack för att du kontaktar support@chargenode.eu. Vi återkommer inom kort", elem_classes="success-message")
+        back_to_chat_btn = gr.Button("Tillbaka till chatten")
+    
+    # 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(
+        submit_support_form, 
+        [områdeskod, uttagsnummer, email, chatbot], 
+        [chat_interface, support_interface, success_interface, chat_preview]
+    )
 
-    # --- Event Listeners ---
-    msg.submit(fn=respond, inputs=[msg, chatbot], outputs=[msg, chatbot], api_name="send_message")
-    # submit_btn.click(fn=respond, inputs=[msg, chatbot], outputs=[msg, chatbot], api_name="send_message") # Om knappen används
-    clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg], queue=False)
-    support_btn.click(fn=show_support_form, inputs=[chatbot], outputs=[chat_interface, support_interface, success_interface, chat_preview])
-    back_btn.click(fn=back_to_chat, inputs=None, outputs=[chat_interface, support_interface, success_interface])
-    back_to_chat_btn.click(fn=back_to_chat, inputs=None, outputs=[chat_interface, support_interface, success_interface])
-    send_support_btn.click(fn=submit_support_form, inputs=[områdeskod, uttagsnummer, email, chatbot], outputs=[chat_interface, support_interface, success_interface, chat_preview])
-
-# --- Kör appen ---
 if __name__ == "__main__":
-    print("Förbereder start...")
-    try:
-        initialize_embeddings() # Ladda embeddings FÖRE launch
-        print("Embeddings klara.")
-        should_share = os.environ.get("GRADIO_SHARE", "false").lower() == "true"
-        print(f"Startar Gradio app {'MED' if should_share else 'UTAN'} delning...")
-        app.launch(share=should_share)
-    except RuntimeError as e: print(f"Kunde inte starta appen p.g.a. tidigare fel: {e}")
-    except Exception as e: print(f"Oväntat fel vid Gradio start: {e}")
+    app.launch(share=True)