#!/usr/bin/env python3
"""
Backend-Testskript für die Workflow-Funktionalität mit Prompt und Datei.
Dieses Skript testet die Backend-Komponenten direkt, ohne über die API zu gehen.
"""

import os
import sys
import asyncio
import uuid
from datetime import datetime
import logging
import json

# Pfad zum Projekt-Root hinzufügen, damit Module gefunden werden
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

# Logging konfigurieren
logging.basicConfig(
    level=logging.INFO,
    format='[%(asctime)s] %(levelname)s: %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger("backend_test")

# Imports aus dem Backend
from modules.lucydom_interface import get_lucydom_interface
from modules.chat import get_chat_manager

# Testparameter
TEST_MANDATE_ID = 1
TEST_USER_ID = 1
TEST_FILE_PATH = "d:/temp/prompt_a1.txt"  # Pfad zur Testdatei anpassen
TEST_FILE_PATH1 = "d:/temp/LF-Nutshell.png"  # Pfad zur Testdatei anpassen
TEST_PROMPT = """Bitte analysiere die angehängte Datei und erstelle eine Zusammenfassung der wichtigsten Informationen.
Erstelle außerdem eine Visualisierung, wenn du Zahlenwerte in der Datei findest."""

async def upload_test_file():
    """Lädt eine Testdatei ins Backend hoch und gibt die Datei-ID zurück"""
    logger.info(f"Lade Testdatei hoch: {TEST_FILE_PATH}")
    
    # LucyDOM-Interface initialisieren
    lucy_interface = get_lucydom_interface(TEST_MANDATE_ID, TEST_USER_ID)
    
    try:
        # Prüfen, ob die Datei existiert
        if not os.path.exists(TEST_FILE_PATH):
            logger.error(f"Testdatei nicht gefunden: {TEST_FILE_PATH}")
            return None
        
        # Datei lesen
        with open(TEST_FILE_PATH, 'rb') as f:
            file_content = f.read()
        
        # Dateinamen extrahieren
        file_name = os.path.basename(TEST_FILE_PATH)
        
        # Datei hochladen
        file_meta = lucy_interface.save_uploaded_file(file_content, file_name)
        file_id = file_meta.get('id')
        
        logger.info(f"Datei erfolgreich hochgeladen. ID: {file_id}")
        return file_meta
        
    except Exception as e:
        logger.error(f"Fehler beim Hochladen der Datei: {str(e)}")
        return None

async def create_test_workflow(file_meta):
    """Erstellt einen Testworkflow mit dem angegebenen Prompt und der Datei"""
    logger.info("Erstelle Testworkflow...")
    
    # Chat-Manager initialisieren
    chat_manager = get_chat_manager(TEST_MANDATE_ID, TEST_USER_ID)
    
    # Nachrichtenobjekt vorbereiten
    message = {
        "role": "user",
        "content": TEST_PROMPT,
        "documents": [file_meta] if file_meta else []
    }
    
    try:
        # Workflow erstellen (neue Workflow-ID wird automatisch generiert)
        workflow = await chat_manager.workflow_integrate_userinput(message)
        
        if not workflow:
            logger.error("Workflow konnte nicht erstellt werden")
            return None
            
        workflow_id = workflow.get("id")
        logger.info(f"Workflow erfolgreich erstellt. ID: {workflow_id}")
        return workflow
        
    except Exception as e:
        logger.error(f"Fehler bei der Workflow-Erstellung: {str(e)}")
        import traceback
        logger.error(traceback.format_exc())
        return None

def print_workflow_details(workflow):
    """Gibt Details zum Workflow aus"""
    if not workflow:
        logger.warning("Kein Workflow zum Anzeigen vorhanden")
        return
    
    logger.info("=== WORKFLOW-DETAILS ===")
    logger.info(f"ID: {workflow.get('id')}")
    logger.info(f"Name: {workflow.get('name')}")
    logger.info(f"Status: {workflow.get('status')}")
    logger.info(f"Mandanten-ID: {workflow.get('mandate_id')}")
    logger.info(f"Benutzer-ID: {workflow.get('user_id')}")
    logger.info(f"Gestartet: {workflow.get('started_at')}")
    logger.info(f"Letzte Aktivität: {workflow.get('last_activity')}")
    
    # Nachrichten ausgeben
    messages = workflow.get("messages", [])
    logger.info(f"Anzahl der Nachrichten: {len(messages)}")
    
    for i, msg in enumerate(messages, 1):
        logger.info(f"--- Nachricht {i} ---")
        logger.info(f"ID: {msg.get('id')}")
        logger.info(f"Rolle: {msg.get('role')}")
        logger.info(f"Sequenz: {msg.get('sequence_no')}")
        logger.info(f"Agent: {msg.get('agent_name')}")
        
        # Inhalt gekürzt ausgeben
        content = msg.get('content', '')
        if content:
            preview = content[:200] + ('...' if len(content) > 200 else '')
            logger.info(f"Inhalt: {preview}")
        
        # Dokumente auflisten
        documents = msg.get('documents', [])
        if documents:
            logger.info(f"Dokumente: {len(documents)}")
            for j, doc in enumerate(documents, 1):
                source = doc.get('source', {})
                doc_name = source.get('name', f"Dokument {j}")
                logger.info(f"  - {doc_name}")
    
    # Logs ausgeben
    logs = workflow.get("logs", [])
    logger.info(f"Anzahl der Logs: {len(logs)}")
    if len(logs) > 0:
        logger.info("Letzte 3 Logs:")
        for log in logs[-3:]:
            logger.info(f"  - [{log.get('timestamp')}] {log.get('message')}")

async def main():
    """Hauptfunktion für den Backend-Test"""
    logger.info("=== BACKEND WORKFLOW-TEST GESTARTET ===")
    
    try:
        # Schritt 1: Testdatei hochladen
        file_meta = await upload_test_file()
        if not file_meta:
            logger.error("Test abgebrochen: Datei konnte nicht hochgeladen werden")
            return False
        
        # Schritt 2: Workflow erstellen
        workflow = await create_test_workflow(file_meta)
        if not workflow:
            logger.error("Test abgebrochen: Workflow konnte nicht erstellt werden")
            return False
        
        # Schritt 3: Workflow-Details ausgeben
        print_workflow_details(workflow)
        
        logger.info("=== BACKEND WORKFLOW-TEST ERFOLGREICH BEENDET ===")
        return True
        
    except Exception as e:
        logger.error(f"Unerwarteter Fehler im Test: {str(e)}")
        import traceback
        logger.error(traceback.format_exc())
        return False

if __name__ == "__main__":
    # Event-Loop ausführen
    success = asyncio.run(main())
    sys.exit(0 if success else 1)