"""
FilGoalBot — On-disk LLM response cache.

Keyed on (model, intent, sorted chunk_ids, normalised query, prompt_version).
Intentionally file-based + JSON: trivial to inspect, trivial to invalidate by
deletion, and survives across processes (eval re-runs, API restarts).

TTL is intent-aware. Match results go stale in hours; player bios stay fresh
for weeks. See INTENT_TTL_SECONDS.

Saves Groq tokens on:
  - eval re-runs (same 50 questions, same retrieved chunks)
  - production duplicates (the same query within the eviction window)
"""

import hashlib
import json
import time
from pathlib import Path

from qa_engine import prompts  # PROMPT_VERSION read lazily — see _make_key

CACHE_DIR = Path(".cache/llm")
CACHE_DIR.mkdir(parents=True, exist_ok=True)

# Default for unknown intents and ablation tests. Real intents are looked up
# in INTENT_TTL_SECONDS below.
DEFAULT_TTL_SECONDS = 30 * 24 * 3600

# Intent-aware TTLs. The cache key includes chunk_ids — so when fresh
# articles arrive the key shifts and stale entries are skipped naturally
# — but TTL is the safety net for cases where the corpus is static
# (e.g. eval re-runs) and the underlying facts move on.
#
# Tuned to the rate at which each intent's facts go stale in reality:
#   match_result : a score changes once, but lineup/scorer chatter
#                  evolves through the day → short window.
#   lineup       : valid until kickoff, sometimes 12–48h.
#   team_news    : presser quotes age out in a few days.
#   transfer_news: rumours linger for a window, finalised deals are
#                  stable once announced → a week is the right middle.
#   player_info  : bios and stats are slow-moving.
#   general      : true trivia (rules, history) effectively immortal.
INTENT_TTL_SECONDS: dict[str, int] = {
    "match_result":     6 * 3600,
    "lineup":          12 * 3600,
    "team_news":        3 * 24 * 3600,
    "transfer_news":    7 * 24 * 3600,
    "player_info":     14 * 24 * 3600,
    "general_football": 30 * 24 * 3600,
}


def ttl_for(intent: str) -> int:
    """Resolve the cache TTL for an intent, falling back to the default."""
    return INTENT_TTL_SECONDS.get(intent, DEFAULT_TTL_SECONDS)


def _make_key(
    model: str,
    intent: str,
    chunk_ids: list[str],
    query: str,
) -> str:
    payload = json.dumps(
        {
            "model": model,
            "intent": intent,
            "chunks": sorted(chunk_ids),
            "query": query.strip().lower(),
            # PROMPT_VERSION folded in so editing prompts.py auto-invalidates
            # every prior cached answer. Without this, a prompt rewrite would
            # be shadowed by stale completions until the TTL expired.
            # Looked up at call time, not import time, so a runtime bump
            # of prompts.PROMPT_VERSION (and tests that monkeypatch it)
            # actually shifts the key.
            "prompt_v": prompts.PROMPT_VERSION,
        },
        ensure_ascii=False,
        sort_keys=True,
    )
    return hashlib.sha256(payload.encode("utf-8")).hexdigest()[:32]


def get(model: str, intent: str, chunk_ids: list[str], query: str,
        ttl_seconds: int | None = None) -> str | None:
    """Look up a cached answer. ttl_seconds=None → look up per-intent TTL
    (production default). Pass an explicit value to override (tests use 0
    to force staleness)."""
    if ttl_seconds is None:
        ttl_seconds = ttl_for(intent)
    key = _make_key(model, intent, chunk_ids, query)
    path = CACHE_DIR / f"{key}.json"
    if not path.exists():
        return None
    try:
        entry = json.loads(path.read_text(encoding="utf-8"))
    except (json.JSONDecodeError, OSError):
        return None
    if time.time() - entry.get("ts", 0) >= ttl_seconds:
        return None
    return entry.get("answer")


def put(model: str, intent: str, chunk_ids: list[str], query: str,
        answer: str) -> None:
    key = _make_key(model, intent, chunk_ids, query)
    path = CACHE_DIR / f"{key}.json"
    path.write_text(
        json.dumps(
            {"ts": time.time(), "answer": answer, "query": query, "intent": intent,
             "prompt_v": prompts.PROMPT_VERSION},
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )


def estimate_tokens(text: str) -> int:
    """Rough token estimate for budget guard. Arabic averages ~3 chars/token
    on llama tokenizers; we use 3 to err conservative (overestimate)."""
    return max(1, len(text) // 3)