"""Persistence and signed snapshots for search relevance reviews."""

from __future__ import annotations

import base64
import hashlib
import hmac
import json
import secrets
import sqlite3
import threading
import time
from pathlib import Path


MAX_COMMENT = 4000
MAX_REVIEWER = 120


class ReviewStore:
    def __init__(self, path: Path | str = ":memory:"):
        if path != ":memory:":
            Path(path).parent.mkdir(parents=True, exist_ok=True)
        self.connection = sqlite3.connect(path, check_same_thread=False)
        self.connection.row_factory = sqlite3.Row
        # ponytail: one SQLite lock; split connections only if review throughput matters.
        self._lock = threading.Lock()
        self.connection.execute("""
            CREATE TABLE IF NOT EXISTS search_reviews (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                created_at TEXT NOT NULL,
                reviewer TEXT NOT NULL,
                query TEXT NOT NULL,
                language TEXT NOT NULL,
                index_name TEXT NOT NULL,
                top_result_code TEXT,
                results_json TEXT NOT NULL,
                overall_comment TEXT NOT NULL
            )
        """)
        self.connection.commit()

    def save(self, review: dict) -> int:
        with self._lock:
            cursor = self.connection.execute(
                "INSERT INTO search_reviews(created_at, reviewer, query, language, index_name, top_result_code, results_json, overall_comment) VALUES(?, ?, ?, ?, ?, ?, ?, ?)",
                (review["created_at"], review["reviewer"], review["query"], review["language"], review["index_name"], review["top_result_code"], json.dumps(review["results"], ensure_ascii=False), review["overall_comment"]),
            )
            self.connection.commit()
            return int(cursor.lastrowid)

    def export(self) -> list[dict]:
        with self._lock:
            return [
                {**dict(row), "results": json.loads(row["results_json"])}
                for row in self.connection.execute("SELECT * FROM search_reviews ORDER BY id")
            ]


class ReviewSnapshots:
    def __init__(self, secret: bytes | None = None, ttl: int = 3600):
        self.secret = secret or secrets.token_bytes(32)
        self.ttl = ttl

    def create(self, query: str, language: str, index: str, results: list[dict]) -> str:
        payload = {"query": query, "language": language, "index_name": index, "results": results, "expires_at": int(time.time()) + self.ttl}
        encoded = base64.urlsafe_b64encode(json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode()).decode().rstrip("=")
        signature = hmac.new(self.secret, encoded.encode(), hashlib.sha256).hexdigest()
        return f"{encoded}.{signature}"

    def verify(self, token: str) -> dict:
        try:
            encoded, signature = token.split(".", 1)
            expected = hmac.new(self.secret, encoded.encode(), hashlib.sha256).hexdigest()
            if not hmac.compare_digest(signature, expected):
                raise ValueError
            payload = json.loads(base64.urlsafe_b64decode(encoded + "=" * (-len(encoded) % 4)))
            if payload["expires_at"] < int(time.time()):
                raise ValueError
            return payload
        except (ValueError, KeyError, TypeError, json.JSONDecodeError, UnicodeError) as error:
            raise ValueError("invalid or expired search snapshot") from error