"""CyberBrain26: konzervativní automatické ukládání dlouhodobé paměti."""

from __future__ import annotations

import re
from datetime import UTC, datetime
from pathlib import Path
from typing import Any

MAX_MEMORY_CHARS = 500
CONVERSATIONS_DIR = Path("data/conversations")

SENSITIVE_PATTERNS = (
    "password", "heslo", "passwd",
    "api key", "apikey", "api_key",
    "token", "secret", "bearer ",
    "private key", "ssh-rsa",
    "sk-", "ghp_", "xoxb-",
)

# Konzervativní signály trvalé informace / preference / pravidla / rozhodnutí.
MEMORY_SIGNALS = (
    "zapamatuj si",
    "preferuji", "preferuju", "mám rád", "mam rad",
    "nechci", "chci aby", "chci, aby",
    "rozhodnutí", "rozhodnuti",
    "nastavení", "nastaveni",
    "pravidlo", "konfigurace",
    "projekt", "port ", "cesta ",
    "používej", "pouzivej",
)

QUESTION_PREFIXES = (
    "co ", "jak ", "proč ", "proc ", "kdy ",
    "můžeš ", "muzes ", "umíš ", "umis ",
    "udělej ", "udelej ", "napiš ", "napis ",
)

def _normalize(text: str) -> str:
    return re.sub(r"\s+", " ", text.strip()).casefold()

def contains_sensitive_data(text: str) -> bool:
    lowered = _normalize(text)
    return any(pattern in lowered for pattern in SENSITIVE_PATTERNS)

def candidate_kind(text: str) -> str:
    lowered = _normalize(text)
    if any(word in lowered for word in ("preferuji", "preferuju", "mám rád", "mam rad", "nechci")):
        return "preference"
    if any(word in lowered for word in ("rozhodnutí", "rozhodnuti", "projekt", "konfigurace", "nastavení", "nastaveni")):
        return "project_decision"
    if any(word in lowered for word in ("pravidlo", "používej", "pouzivej")):
        return "rule"
    return "fact"

def extract_candidate(user_text: str) -> dict[str, str] | None:
    text = re.sub(r"\s+", " ", user_text.strip())
    lowered = text.casefold()

    if not text or len(text) > MAX_MEMORY_CHARS:
        return None
    if contains_sensitive_data(text):
        return None
    if lowered.startswith(QUESTION_PREFIXES):
        return None
    if not any(signal in lowered for signal in MEMORY_SIGNALS):
        return None

    if lowered.startswith("zapamatuj si"):
        text = text[len("zapamatuj si"):].lstrip(" ,:-")
        if not text:
            return None

    # Vynechat text, který je zjevně pouze instrukce pro jednorázové generování.
    if text.casefold().startswith(("napiš ", "napis ", "udělej ", "udelej ")):
        return None

    return {"content": text, "kind": candidate_kind(text)}

def is_duplicate(content: str) -> bool:
    try:
        from memory_core import list_memory  # type: ignore[import-not-found]
    except Exception:
        # Když nelze paměť přečíst, raději neukládat automaticky.
        return True
    wanted = _normalize(content)
    for item in list_memory(status="active"):
        existing = _normalize(str(item.get("content", "")))
        if existing == wanted:
            return True
    return False

def remember_if_relevant(user_text: str, source: str = "webapp-auto") -> dict[str, Any] | None:
    candidate = extract_candidate(user_text)
    if not candidate or is_duplicate(candidate["content"]):
        return None

    try:
        from memory_core import remember
    except Exception:
        return None
    record = remember(
        content=candidate["content"],
        kind=candidate["kind"],
        source=source,
        confidence="auto_candidate",
    )
    return {
        "id": record["id"],
        "content": record["content"],
        "kind": record["metadata"]["kind"],
    }

def import_unprocessed_conversations(limit_files: int = 50) -> dict[str, int]:
    """Jednorázově projde dosud neimportované JSON chaty; neukládá celé dialogy."""
    result = {"files_seen": 0, "saved": 0, "skipped": 0, "errors": 0}

    if not CONVERSATIONS_DIR.exists():
        return result

    files = sorted(CONVERSATIONS_DIR.glob("*.json"))[:limit_files]
    for path in files:
        result["files_seen"] += 1
        try:
            import json
            data = json.loads(path.read_text(encoding="utf-8"))

            # Marker znamená: tento soubor byl už jednou vyhodnocen.
            if data.get("auto_memory_imported_at"):
                result["skipped"] += 1
                continue

            for message in data.get("history", []):
                if message.get("role") != "user":
                    continue
                if remember_if_relevant(
                    str(message.get("content", "")),
                    source="webapp-conversation-import",
                ):
                    result["saved"] += 1

            data["auto_memory_imported_at"] = datetime.now(UTC).isoformat()
            path.write_text(
                json.dumps(data, ensure_ascii=False, indent=2),
                encoding="utf-8",
            )
        except Exception:
            result["errors"] += 1

    return result