"""Render-plan cache (TZ 2.6.3 p.3-4): process LRU -> HMAC-signed marshal file -> compile.

File layout: ``VPLN`` | u16 plan format | u8 py major | u8 py minor | 16-byte engine version |
32-byte HMAC-SHA256(body) | marshal body. Writes are atomic (tmp file + ``os.replace``).
"""

from __future__ import annotations

import hashlib
import hmac
import marshal
import os
import struct
import sys
import tempfile
import threading
from collections import OrderedDict
from collections.abc import Callable
from pathlib import Path
from typing import Any

from . import ENGINE_VERSION, PLAN_FORMAT

MAGIC = b"VPLN"
_HEADER = struct.Struct(">4sHBB16s32s")


def plan_key(*parts: str) -> str:
    """Cache key from version/document/font/asset hashes + engine + Python version."""
    raw = ":".join([*parts, ENGINE_VERSION, f"py{sys.version_info[0]}{sys.version_info[1]}"])
    return hashlib.sha256(raw.encode()).hexdigest()


class PlanCache:
    def __init__(self, directory: str | Path, secret: bytes, max_items: int = 32, max_mb: int = 128) -> None:
        self.dir = Path(directory)
        self.secret = secret
        self.max_items = max_items
        self.max_bytes = max_mb * 1024 * 1024
        self._lru: OrderedDict[str, tuple[dict[str, Any], int]] = OrderedDict()
        self._bytes = 0
        self._lock = threading.Lock()

    # ------------------------------------------------------------------ memory
    def _lru_get(self, key: str) -> dict[str, Any] | None:
        with self._lock:
            hit = self._lru.get(key)
            if hit is None:
                return None
            self._lru.move_to_end(key)
            return hit[0]

    def _lru_put(self, key: str, plan: dict[str, Any], size: int) -> None:
        with self._lock:
            if key in self._lru:
                self._bytes -= self._lru.pop(key)[1]
            self._lru[key] = (plan, size)
            self._bytes += size
            while self._lru and (len(self._lru) > self.max_items or self._bytes > self.max_bytes):
                _, (_, s) = self._lru.popitem(last=False)
                self._bytes -= s

    def clear_memory(self) -> None:
        with self._lock:
            self._lru.clear()
            self._bytes = 0

    # ------------------------------------------------------------------ disk
    def path(self, key: str) -> Path:
        return self.dir / key[:2] / f"{key}.plan"

    def _sign(self, body: bytes) -> bytes:
        return hmac.new(self.secret, body, hashlib.sha256).digest()

    def _read(self, key: str) -> tuple[dict[str, Any], int] | None:
        p = self.path(key)
        try:
            raw = p.read_bytes()
        except OSError:
            return None
        try:
            magic, fmt, major, minor, engine, sig = _HEADER.unpack_from(raw)
            body = raw[_HEADER.size :]
            if (
                magic != MAGIC
                or fmt != PLAN_FORMAT
                or (major, minor) != sys.version_info[:2]
                or engine.rstrip(b"\0").decode() != ENGINE_VERSION
                or not hmac.compare_digest(sig, self._sign(body))
            ):
                raise ValueError("plan header/signature mismatch")
            plan = marshal.loads(body)
        except Exception:
            try:
                p.unlink()
            except OSError:
                pass
            return None
        return plan, len(body)

    def _write(self, key: str, plan: dict[str, Any]) -> tuple[int, str]:
        body = marshal.dumps(plan)
        header = _HEADER.pack(
            MAGIC, PLAN_FORMAT, sys.version_info[0], sys.version_info[1], ENGINE_VERSION.encode()[:16], self._sign(body)
        )
        p = self.path(key)
        p.parent.mkdir(parents=True, exist_ok=True)
        fd, tmp = tempfile.mkstemp(dir=p.parent, prefix=".tmp-")
        try:
            with os.fdopen(fd, "wb") as f:
                f.write(header)
                f.write(body)
            os.replace(tmp, p)
        except BaseException:
            try:
                os.unlink(tmp)
            except OSError:
                pass
            raise
        return len(body), hashlib.sha256(header + body).hexdigest()

    # ------------------------------------------------------------------ api
    def get_or_compile(self, key: str, compile_fn: Callable[[], dict[str, Any]]) -> tuple[dict[str, Any], str]:
        """Return (plan, source) where source is ``lru`` | ``disk`` | ``compiled``."""
        plan = self._lru_get(key)
        if plan is not None:
            return plan, "lru"
        hit = self._read(key)
        if hit is not None:
            self._lru_put(key, *hit)
            return hit[0], "disk"
        plan = compile_fn()
        size, _ = self._write(key, plan)
        self._lru_put(key, plan, size)
        return plan, "compiled"

    def store(self, key: str, plan: dict[str, Any]) -> str:
        size, digest = self._write(key, plan)
        self._lru_put(key, plan, size)
        return digest
