"""Factchecker-Agent: Prüft Fakten gegen mehrere unabhängige Quellen."""
import json
import logging
import re
from difflib import SequenceMatcher
from agents.claude_client import call_claude, ClaudeUsage

logger = logging.getLogger("osint.factchecker")

FACTCHECK_PROMPT_TEMPLATE = """Du bist ein Faktencheck-Agent für ein OSINT-Lagemonitoring-System.
AUSGABESPRACHE: {output_language}
WICHTIG: Verwende IMMER echte UTF-8-Umlaute (ä, ö, ü, ß) — NIEMALS Umschreibungen (ae, oe, ue, ss).

VORFALL: {title}

VORLIEGENDE MELDUNGEN:
{articles_text}

STRENGE REGELN - KEINE HALLUZINATIONEN:
- Du darfst NUR Fakten bewerten, die direkt aus den oben übergebenen Meldungen stammen
- KEINE Fakten aus deinem Trainingskorpus - NUR aus den übergebenen Meldungen + WebSearch
- Nutze WebSearch um jeden Claim gegen mindestens 1 weitere unabhängige Quelle zu prüfen
- Rufe die gefundenen URLs per WebFetch ab um den Inhalt zu verifizieren
- Nur wenn du den Claim in der tatsächlich abgerufenen Quelle findest, darfst du ihn als bestätigt markieren
- Jeder Claim MUSS eine konkrete Quellen-URL als Beleg enthalten
- "confirmed" erst bei 2+ unabhängigen Quellen mit überprüfbarer URL
- Lieber "unconfirmed" als falsch bestätigt

AUFTRAG:
1. Identifiziere die 5-10 wichtigsten Faktenaussagen aus den Meldungen
2. Prüfe jeden Claim aktiv per WebSearch gegen mindestens eine weitere unabhängige Quelle
3. Kategorisiere jede Aussage:
   - "confirmed": Durch 2+ unabhängige seriöse Quellen mit überprüfbarer URL bestätigt
   - "unconfirmed": Nur 1 Quelle oder nicht unabhängig verifizierbar
   - "contradicted": Widersprüchliche Informationen aus verschiedenen Quellen
   - "developing": Situation noch unklar, entwickelt sich
4. Markiere WICHTIGE NEUE Entwicklungen mit is_notification: true

Antworte AUSSCHLIESSLICH als JSON-Array. Jedes Element hat:
- "claim": Die Faktenaussage auf {output_language}
- "status": "confirmed" | "unconfirmed" | "contradicted" | "developing"
- "sources_count": Anzahl unabhängiger Quellen mit überprüfbarer URL
- "evidence": Begründung MIT konkreten Quellen-URLs als Beleg (z.B. "Bestätigt durch: tagesschau.de (URL), Reuters (URL)")
- "is_notification": true/false (nur bei wichtigen Entwicklungen true)

Antworte NUR mit dem JSON-Array. Keine Einleitung, keine Erklärung."""

RESEARCH_FACTCHECK_PROMPT_TEMPLATE = """Du bist ein Faktencheck-Agent für eine Hintergrundrecherche in einem OSINT-Lagemonitoring-System.
AUSGABESPRACHE: {output_language}
WICHTIG: Verwende IMMER echte UTF-8-Umlaute (ä, ö, ü, ß) — NIEMALS Umschreibungen (ae, oe, ue, ss).

THEMA: {title}

VORLIEGENDE QUELLEN:
{articles_text}

STRENGE REGELN - KEINE HALLUZINATIONEN:
- Du darfst NUR Fakten bewerten, die direkt aus den oben übergebenen Quellen stammen
- KEINE Fakten aus deinem Trainingskorpus - NUR aus den übergebenen Quellen + WebSearch
- Nutze WebSearch um jeden Claim gegen mindestens 1 weitere unabhängige Quelle zu prüfen
- Rufe die gefundenen URLs per WebFetch ab um den Inhalt zu verifizieren
- Nur wenn du den Claim in der tatsächlich abgerufenen Quelle findest, darfst du ihn als gesichert markieren
- Jeder Claim MUSS eine konkrete Quellen-URL als Beleg enthalten
- Lieber "unverified" als falsch bestätigt

AUFTRAG:
Fokus: "Was sind die gesicherten Fakten zu diesem Thema?"

1. Identifiziere die 5-10 wichtigsten Faktenaussagen aus den Quellen
2. Prüfe jeden Claim aktiv per WebSearch gegen weitere unabhängige Quellen
3. Kategorisiere jede Aussage:
   - "established": Breit dokumentierter, gesicherter Fakt (3+ unabhängige Quellen mit URL)
   - "disputed": Umstrittener Sachverhalt, verschiedene Positionen dokumentiert
   - "unverified": Einzelbehauptung, nicht unabhängig verifizierbar
   - "developing": Aktuelle Entwicklung, Faktenlage noch im Fluss
4. Markiere WICHTIGE Erkenntnisse mit is_notification: true

Antworte AUSSCHLIESSLICH als JSON-Array. Jedes Element hat:
- "claim": Die Faktenaussage auf {output_language}
- "status": "established" | "disputed" | "unverified" | "developing"
- "sources_count": Anzahl unabhängiger Quellen mit überprüfbarer URL
- "evidence": Begründung MIT konkreten Quellen-URLs als Beleg
- "is_notification": true/false

Antworte NUR mit dem JSON-Array. Keine Einleitung, keine Erklärung."""

# --- Inkrementelle Faktencheck-Prompts (für Folge-Refreshes) ---

INCREMENTAL_FACTCHECK_PROMPT_TEMPLATE = """Du bist ein Faktencheck-Agent für ein OSINT-Lagemonitoring-System.
AUSGABESPRACHE: {output_language}
WICHTIG: Verwende IMMER echte UTF-8-Umlaute (ä, ö, ü, ß) — NIEMALS Umschreibungen (ae, oe, ue, ss).

VORFALL: {title}

BEREITS GEPRÜFTE FAKTEN:
{existing_facts_text}

NEUE MELDUNGEN:
{articles_text}

STRENGE REGELN - KEINE HALLUZINATIONEN:
- Du darfst NUR Fakten bewerten, die aus den Meldungen oder bereits geprüften Fakten stammen
- KEINE Fakten aus deinem Trainingskorpus
- Nutze WebSearch zur Verifikation
- Rufe gefundene URLs per WebFetch ab

AUFTRAG:
1. Prüfe ob die neuen Meldungen bereits geprüfte Fakten BESTÄTIGEN, WIDERLEGEN oder ERGÄNZEN
2. Aktualisiere den Status bestehender Fakten wenn nötig (z.B. "unconfirmed" → "confirmed")
3. Identifiziere 3-5 NEUE Faktenaussagen aus den neuen Meldungen
4. Prüfe neue Claims per WebSearch gegen unabhängige Quellen
5. Markiere wichtige Statusänderungen und neue Entwicklungen mit is_notification: true

Status-Kategorien:
- "confirmed": 2+ unabhängige seriöse Quellen mit URL
- "unconfirmed": Nur 1 Quelle
- "contradicted": Widersprüchliche Informationen
- "developing": Situation unklar

Antworte AUSSCHLIESSLICH als JSON-Array mit ALLEN Fakten (bestehende aktualisiert + neue).
Jedes Element hat:
- "claim": Die Faktenaussage auf {output_language}
- "status": "confirmed" | "unconfirmed" | "contradicted" | "developing"
- "sources_count": Anzahl unabhängiger Quellen
- "evidence": Begründung MIT konkreten Quellen-URLs
- "is_notification": true/false

Antworte NUR mit dem JSON-Array."""

INCREMENTAL_RESEARCH_FACTCHECK_PROMPT_TEMPLATE = """Du bist ein Faktencheck-Agent für eine Hintergrundrecherche in einem OSINT-Lagemonitoring-System.
AUSGABESPRACHE: {output_language}
WICHTIG: Verwende IMMER echte UTF-8-Umlaute (ä, ö, ü, ß) — NIEMALS Umschreibungen (ae, oe, ue, ss).

THEMA: {title}

BEREITS GEPRÜFTE FAKTEN:
{existing_facts_text}

NEUE QUELLEN:
{articles_text}

STRENGE REGELN - KEINE HALLUZINATIONEN:
- Du darfst NUR Fakten bewerten, die aus den Quellen oder bereits geprüften Fakten stammen
- KEINE Fakten aus deinem Trainingskorpus
- Nutze WebSearch zur Verifikation
- Rufe gefundene URLs per WebFetch ab

AUFTRAG:
1. Prüfe ob die neuen Quellen bereits geprüfte Fakten bestätigen, widerlegen oder ergänzen
2. Aktualisiere den Status bestehender Fakten wenn nötig
3. Identifiziere 3-5 NEUE Faktenaussagen aus den neuen Quellen
4. Prüfe neue Claims per WebSearch

Status-Kategorien:
- "established": 3+ unabhängige Quellen mit URL
- "disputed": Verschiedene Positionen dokumentiert
- "unverified": Nicht unabhängig verifizierbar
- "developing": Faktenlage im Fluss

Antworte AUSSCHLIESSLICH als JSON-Array mit ALLEN Fakten (bestehende aktualisiert + neue).
Jedes Element hat:
- "claim": Die Faktenaussage auf {output_language}
- "status": "established" | "disputed" | "unverified" | "developing"
- "sources_count": Anzahl unabhängiger Quellen
- "evidence": Begründung MIT konkreten Quellen-URLs
- "is_notification": true/false

Antworte NUR mit dem JSON-Array."""


# --- Stopwords fuer Keyword-Extraktion ---
_STOPWORDS = frozenset({
    "der", "die", "das", "ein", "eine", "und", "oder", "von", "nach", "bei", "mit",
    "wurde", "wird", "haben", "sein", "dass", "ist", "sind", "hat", "vor", "fuer",
    "den", "dem", "des", "sich", "auf", "als", "auch", "noch", "nicht", "aber",
    "ueber", "durch", "einer", "einem", "eines", "werden", "wurde", "waren",
    "the", "and", "was", "has", "been", "have", "that", "with", "from", "for",
    "are", "were", "this", "which", "into", "their", "than", "about",
})

STATUS_PRIORITY = {
    "confirmed": 5, "established": 5,
    "contradicted": 4, "disputed": 4,
    "unconfirmed": 3, "unverified": 3,
    "developing": 1,
}


def normalize_claim(claim: str) -> str:
    """Normalisiert einen Claim fuer Aehnlichkeitsvergleich."""
    c = claim.lower().strip()
    c = c.replace("\u00e4", "ae").replace("\u00f6", "oe").replace("\u00fc", "ue").replace("\u00df", "ss")
    c = re.sub(r'[^\w\s]', '', c)
    c = re.sub(r'\s+', ' ', c).strip()
    return c


def _keyword_set(text: str) -> set[str]:
    """Extrahiert signifikante Woerter fuer Overlap-Vergleich."""
    words = set(normalize_claim(text).split())
    return {w for w in words if len(w) >= 4 and w not in _STOPWORDS}


def find_matching_claim(new_claim: str, existing_claims: list[dict], threshold: float = 0.75) -> dict | None:
    """Findet den besten passenden bestehenden Claim per kombiniertem Scoring.

    Verwendet SequenceMatcher (70%) + Jaccard-Keyword-Overlap (30%) fuer robusteres Matching.
    """
    norm_new = normalize_claim(new_claim)
    if not norm_new:
        return None

    kw_new = _keyword_set(new_claim)
    best_match = None
    best_score = 0.0

    for existing in existing_claims:
        norm_existing = normalize_claim(existing.get("claim", ""))
        if not norm_existing:
            continue

        # Fruehzeitiger Abbruch bei grossem Laengenunterschied
        len_ratio = len(norm_new) / len(norm_existing) if norm_existing else 0
        if len_ratio > 2.5 or len_ratio < 0.4:
            continue

        seq_ratio = SequenceMatcher(None, norm_new, norm_existing).ratio()

        kw_existing = _keyword_set(existing.get("claim", ""))
        kw_union = kw_new | kw_existing
        jaccard = len(kw_new & kw_existing) / len(kw_union) if kw_union else 0.0

        combined = 0.7 * seq_ratio + 0.3 * jaccard

        if combined > best_score:
            best_score = combined
            best_match = existing

    if best_score >= threshold:
        logger.debug(
            f"Claim-Match ({best_score:.2f}): "
            f"'{new_claim[:50]}...' -> '{best_match['claim'][:50]}...'"
        )
        return best_match
    return None


def deduplicate_new_facts(facts: list[dict], threshold: float = 0.70) -> list[dict]:
    """Dedupliziert Fakten aus einer einzelnen LLM-Antwort vor dem DB-Insert.

    Clustert aehnliche Claims und behaelt pro Cluster den mit dem
    hoechsten Status und den meisten Quellen.
    """
    if not facts:
        return []

    clusters: list[list[dict]] = []
    for fact in facts:
        matched_cluster = None
        for cluster in clusters:
            if find_matching_claim(fact.get("claim", ""), cluster, threshold=threshold):
                matched_cluster = cluster
                break
        if matched_cluster is not None:
            matched_cluster.append(fact)
        else:
            clusters.append([fact])

    result = []
    for cluster in clusters:
        best = max(cluster, key=lambda f: (
            STATUS_PRIORITY.get(f.get("status", "developing"), 0),
            f.get("sources_count", 0),
        ))
        result.append(best)

    if len(result) < len(facts):
        logger.info(
            f"Fakten-Dedup: {len(facts)} -> {len(result)} "
            f"(-{len(facts) - len(result)} Duplikate)"
        )
    return result


class FactCheckerAgent:
    """Prüft Fakten über Claude CLI gegen unabhängige Quellen."""

    def _format_articles_text(self, articles: list[dict], max_articles: int = 20) -> str:
        """Formatiert Artikel als Text für den Prompt."""
        articles_text = ""
        for i, article in enumerate(articles[:max_articles]):
            articles_text += f"\n--- Meldung {i+1} ---\n"
            articles_text += f"Quelle: {article.get('source', 'Unbekannt')}\n"
            source_url = article.get('source_url', '')
            if source_url:
                articles_text += f"URL: {source_url}\n"
            headline = article.get('headline_de') or article.get('headline', '')
            articles_text += f"Überschrift: {headline}\n"
            content = article.get('content_de') or article.get('content_original', '')
            if content:
                articles_text += f"Inhalt: {content[:500]}\n"
        return articles_text

    def _format_existing_facts(self, facts: list[dict]) -> str:
        """Formatiert bestehende Fakten als Text für den inkrementellen Prompt."""
        if not facts:
            return "Keine bisherigen Fakten"
        lines = []
        for fc in facts:
            status = fc.get("status", "developing")
            claim = fc.get("claim", "")
            sources = fc.get("sources_count", 0)
            lines.append(f"- [{status}] ({sources} Quellen) {claim}")
        return "\n".join(lines)

    async def check(self, title: str, articles: list[dict], incident_type: str = "adhoc") -> tuple[list[dict], ClaudeUsage | None]:
        """Führt vollständigen Faktencheck durch (erster Refresh)."""
        if not articles:
            return [], None

        articles_text = self._format_articles_text(articles)

        from config import OUTPUT_LANGUAGE
        template = RESEARCH_FACTCHECK_PROMPT_TEMPLATE if incident_type == "research" else FACTCHECK_PROMPT_TEMPLATE
        prompt = template.format(
            title=title,
            articles_text=articles_text,
            output_language=OUTPUT_LANGUAGE,
        )

        try:
            result, usage = await call_claude(prompt)
            facts = self._parse_response(result)
            logger.info(f"Faktencheck: {len(facts)} Fakten geprüft")
            return facts, usage
        except TimeoutError:
            raise  # Timeout nach oben durchreichen fuer Retry im Orchestrator
        except Exception as e:
            logger.error(f"Faktencheck-Fehler: {e}")
            return [], None

    async def check_incremental(
        self,
        title: str,
        new_articles: list[dict],
        existing_facts: list[dict],
        incident_type: str = "adhoc",
    ) -> tuple[list[dict], ClaudeUsage | None]:
        """Inkrementeller Faktencheck: Prüft nur neue Artikel gegen bestehende Fakten.

        Spart Tokens, da nur neue Artikel + Zusammenfassung der bestehenden Fakten gesendet werden.
        """
        if not new_articles:
            logger.info("Inkrementeller Faktencheck übersprungen: keine neuen Artikel")
            return [], None

        articles_text = self._format_articles_text(new_articles, max_articles=15)
        existing_facts_text = self._format_existing_facts(existing_facts)

        from config import OUTPUT_LANGUAGE
        if incident_type == "research":
            template = INCREMENTAL_RESEARCH_FACTCHECK_PROMPT_TEMPLATE
        else:
            template = INCREMENTAL_FACTCHECK_PROMPT_TEMPLATE

        prompt = template.format(
            title=title,
            articles_text=articles_text,
            existing_facts_text=existing_facts_text,
            output_language=OUTPUT_LANGUAGE,
        )

        try:
            result, usage = await call_claude(prompt)
            facts = self._parse_response(result)
            logger.info(f"Inkrementeller Faktencheck: {len(facts)} Fakten (neu + aktualisiert)")
            return facts, usage
        except TimeoutError:
            raise  # Timeout nach oben durchreichen fuer Retry im Orchestrator
        except Exception as e:
            logger.error(f"Inkrementeller Faktencheck-Fehler: {e}")
            return [], None

    def _parse_response(self, response: str) -> list[dict]:
        """Parst die Claude-Antwort als JSON-Array."""
        try:
            data = json.loads(response)
            if isinstance(data, list):
                return data
        except json.JSONDecodeError:
            pass

        match = re.search(r'\[.*\]', response, re.DOTALL)
        if match:
            try:
                data = json.loads(match.group())
                if isinstance(data, list):
                    return data
            except json.JSONDecodeError:
                pass

        logger.warning("Konnte Faktencheck-Antwort nicht als JSON parsen")
        return []