"""
app/services/semantic_analyzer.py — Edge Validation & Filtering
Version: Final (Entkoppelt von internen Typ-Simulationen)
"""

import json
import logging
from typing import List, Dict, Any, Optional
from dataclasses import dataclass

# Import der benötigten Services (Annahme: llm_service und discovery sind verfügbar.)
from app.services.llm_service import LLMService
# ANNAHME: DiscoveryService ist für die Matrix-Logik verfügbar.
from app.services.discovery import DiscoveryService 

logger = logging.getLogger(__name__)

@dataclass
class SemanticChunkResult:
    content: str
    suggested_edges: List[str] # Format: "kind:Target"

# Die Klasse muss den TargetTypeResolver als DI-Abhängigkeit erhalten, um flexibel zu sein.
# Da dies aber im Mindnet-System noch nicht etabliert ist, muss der Aufrufer den Resolver bereitstellen.

class SemanticAnalyzer:
    def __init__(self):
        self.llm = LLMService()
        self.discovery = DiscoveryService() 
        self.MAX_CONTEXT_TOKENS = 3000

    async def analyze_and_chunk(
        self, 
        text: str, 
        source_type: str, 
        # NEU: Erfordert die Auflösungsfunktion als Eingabe (DI-Prinzip)
        target_type_resolver: Optional[callable] = None 
    ) -> List[SemanticChunkResult]:
        """
        Zerlegt Text mittels LLM in semantische Abschnitte und extrahiert Kanten.
        """
        
        # Standard-Resolver verwenden, wenn keiner übergeben wird
        if target_type_resolver is None:
            target_type_resolver = self._default_target_type_resolver

        system_prompt = (
            "Du bist ein Knowledge Graph Experte. Deine Aufgabe ist es, Rohtext in "
            "thematisch geschlossene Abschnitte (Chunks) zu zerlegen.\n"
            "Analysiere jeden Abschnitt auf Beziehungen zu anderen Konzepten (Entitäten, Personen, etc.).\n"
            "Antworte AUSSCHLIESSLICH mit validem JSON in diesem Format:\n"
            "[\n"
            "  {\n"
            "    \"content\": \"Der Text des Abschnitts...\",\n"
            "    \"relations\": [{\"target\": \"Entität X\", \"type\": \"related_to\"}]\n"
            "  }\n"
            "]\n"
            "Halte die Chunks mittellang (ca. 100-300 Wörter). Verändere den Inhalt nicht, nur die Struktur."
        )
        
        user_prompt = f"Dokument-Typ: {source_type}\n\nTEXT:\n{text}"

        try:
            response_json = await self.llm.generate_raw_response(
                user_prompt, 
                system=system_prompt,
                force_json=True
            )
            
            clean_json = response_json.replace("```json", "").replace("```", "").strip()
            data = json.loads(clean_json)
            
            if isinstance(data, dict):
                 data = [data]
            elif not isinstance(data, list):
                 logger.error("SemanticAnalyzer: JSON root ist weder Array noch Objekt. Fehlerhafte LLM-Antwort.")
                 raise ValueError("Root element is not a list or dictionary.")

            results = []
            for item in data:
                if not isinstance(item, dict):
                    logger.warning(f"SemanticAnalyzer: Ungültiges Chunk-Element ignoriert: {item}")
                    continue
                
                content = item.get("content", "").strip()
                if not content: continue
                
                raw_rels = item.get("relations", [])
                refined_edges = []
                
                for rel in raw_rels:
                    if not isinstance(rel, dict):
                        logger.warning(f"SemanticAnalyzer: Ignoriere ungültige Relation: {rel}")
                        continue
                        
                    target = rel.get("target")
                    raw_type = rel.get("type", "related_to")
                    
                    if target:
                        # 1. Typ-Auflösung über die injizierte Funktion
                        target_entity_type = target_type_resolver(target) # <--- NUTZT DEN INJIZIERTEN RESOLVER
                        
                        # 2. Matrix-Logik anwenden:
                        final_kind = self.discovery._resolve_edge_type(source_type, target_entity_type)
                        
                        # 3. Priorisierung: Wählt den Matrix-Vorschlag, wenn er spezifischer ist.
                        if final_kind not in ["related_to", "references"] and target_entity_type != "concept":
                             edge_str = f"{final_kind}:{target}"
                        else:
                             edge_str = f"{raw_type}:{target}"
                            
                        refined_edges.append(edge_str)
                
                results.append(SemanticChunkResult(content=content, suggested_edges=refined_edges))
                
            return results

        except json.JSONDecodeError:
            logger.error("SemanticAnalyzer: LLM lieferte KEIN valides JSON. Fallback auf Raw Text.")
            return [SemanticChunkResult(content=text, suggested_edges=[])]
        except Exception as e:
            logger.error(f"SemanticAnalyzer Unbehandelter Fehler: {e}")
            return [SemanticChunkResult(content=text, suggested_edges=[])]

    # NEU: Abstrakter Fallback-Resolver (muss außerhalb des Kernmoduls verbleiben)
    def _default_target_type_resolver(self, title: str) -> str:
        """Standard-Fallback, wenn kein Resolver übergeben wird (immer 'concept')."""
        return "concept" 

    async def close(self):
        if self.llm:
            await self.llm.close()

# Export des Singleton-Helpers
_analyzer_instance = None
def get_semantic_analyzer():
    global _analyzer_instance
    if _analyzer_instance is None:
        _analyzer_instance = SemanticAnalyzer()
    return _analyzer_instance