#!/usr/bin/env python3
"""Mini-MVP: Frage -> Suchbegriffe vom lokalen LLM -> ripgrep -> Antwort mit Quellen.

Benötigt:
- Ollama unter http://127.0.0.1:11434
- ripgrep (rg)
- Markdown-Dateien im Suchordner

Beispiel:
  python3 04-ask-documents.py --model qwen3:14b --docs /srv/knp-ai/testwissen
"""

from __future__ import annotations
import argparse
import json
import re
import subprocess
import shutil
from pathlib import Path
import urllib.request


OLLAMA_URL = "http://127.0.0.1:11434/api/chat"


def ollama(model: str, prompt: str) -> str:
    body = json.dumps({
        "model": model,
        "stream": False,
        "messages": [{"role": "user", "content": prompt}],
    }).encode("utf-8")
    req = urllib.request.Request(
        OLLAMA_URL, data=body, headers={"Content-Type": "application/json"}
    )
    with urllib.request.urlopen(req, timeout=300) as response:
        data = json.load(response)
    return data["message"]["content"].strip()


def search_terms(model: str, question: str) -> list[str]:
    prompt = f"""Erzeuge für die folgende interne Dokumentensuche 4 bis 7 kurze Suchbegriffe
oder Wortgruppen auf Deutsch. Nimm Synonyme und fachlich naheliegende Begriffe auf.
Gib ausschließlich ein JSON-Array mit Strings zurück, ohne Erklärung.

Frage: {question}
"""
    raw = ollama(model, prompt)
    match = re.search(r"\[[\s\S]*\]", raw)
    if not match:
        return [question]
    try:
        terms = json.loads(match.group(0))
        return [str(x).strip() for x in terms if str(x).strip()][:7] or [question]
    except json.JSONDecodeError:
        return [question]



# Nur fuer den Rueckfall auf Einzelwoerter: haeufige Fragewoerter auslassen.
STOPWORDS = {
    "aber", "auch", "auf", "aus", "bei", "das", "dem", "den", "der",
    "des", "die", "ein", "eine", "einem", "einen", "einer", "eines",
    "er", "es", "fuer", "für", "hat", "haben", "hier", "ich", "ihm",
    "ihn", "ihr", "ihre", "im", "in", "ist", "man", "mit", "nach",
    "oder", "sein", "sind", "sie", "soll", "und", "uns", "von",
    "vor", "war", "was", "welche", "welchen", "welcher", "welches",
    "werden", "wie", "wird", "wir", "wo", "wurde", "zum", "zur",
}


def fallback_keywords(question: str, llm_terms: list[str]) -> list[str]:
    """Kernwoerter aus der Originalfrage zuerst, dann aus LLM-Vorschlaegen.

    Lange generierte Phrasen muessen nicht wortwoertlich im Dokument stehen.
    Die Fallback-Suche nutzt deshalb einzelne Woerter ohne Regex-Interpretation.
    """
    words = re.findall(r"[^\W_][\w-]{2,}", " ".join([question, *llm_terms]), re.UNICODE)
    result: list[str] = []
    seen: set[str] = set()
    for word in words:
        key = word.casefold()
        if key in STOPWORDS or key in seen or word.isdigit():
            continue
        seen.add(key)
        result.append(word)
        if len(result) >= 24:
            break
    return result


def rg_search(docs: str, terms: list[str], max_chars: int = 30000) -> str:
    blocks: list[str] = []
    seen: set[str] = set()
    for term in terms:
        proc = subprocess.run(
            ["rg", "-n", "-i", "-F", "-C", "2", "--glob", "*.md", "--", term, docs],
            text=True, capture_output=True
        )
        if proc.returncode not in (0, 1):
            continue
        for block in re.split(r"\n--\n", proc.stdout):
            block = block.strip()
            if not block or block in seen:
                continue
            seen.add(block)
            blocks.append(f"### Suchbegriff: {term}\n{block}")
            if sum(len(x) for x in blocks) >= max_chars:
                return "\n\n".join(blocks)
    return "\n\n".join(blocks)


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", required=True)
    ap.add_argument("--docs", required=True)
    args = ap.parse_args()

    question = input("Frage: ").strip()
    if not question:
        raise SystemExit("Keine Frage eingegeben.")

    if not Path(args.docs).is_dir():
        raise SystemExit(f"Dokumentenordner fehlt: {args.docs}")
    if not shutil.which("rg"):
        raise SystemExit("ripgrep fehlt. Bitte: sudo apt install ripgrep")

    terms = search_terms(args.model, question)
    print("\nSuchbegriffe:", ", ".join(terms))
    context = rg_search(args.docs, terms)
    if not context:
        keywords = fallback_keywords(question, terms)
        print("\nKeine exakten Wortgruppen gefunden. Einzelwortsuche:", ", ".join(keywords))
        context = rg_search(args.docs, keywords)
    if not context:
        print("\nKeine passenden Fundstellen gefunden.")
        return

    prompt = f"""Beantworte die Frage ausschließlich anhand der folgenden Fundstellen.
Wenn die Fundstellen nicht reichen, sage das ausdrücklich.
Nenne bei Aussagen die jeweilige Datei und möglichst die Zeilennummer aus den Treffern.
Erfinde keine Quellen.

FRAGE:
{question}

FUNDSTELLEN:
{context}
"""
    answer = ollama(args.model, prompt)
    print("\nAntwort:\n")
    print(answer)


if __name__ == "__main__":
    main()
