"""Content-addressed JSON cache and environment state records."""

from __future__ import annotations

import json
import os
import tempfile
from pathlib import Path
from typing import Any

from .config import TranslationConfig, sha256_text


def canonical_json(value: Any) -> str:
    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))


def segment_cache_key(source: str, config: TranslationConfig) -> str:
    normalized = "\n".join(line.rstrip() for line in source.strip().splitlines())
    payload = {
        "source": normalized,
        "source_language": config.source_language,
        "target_language": config.target_language,
        "model_id": config.model_id,
        "model_revision": config.model_revision,
        "prompt_hash": config.prompt_hash,
        "glossary_hash": config.glossary_hash,
        "segmenter_version": config.segmenter_version,
    }
    return sha256_text(canonical_json(payload))


class TranslationCache:
    """A deliberately small JSON-file cache for mounted Bucket storage."""

    def __init__(self, root: Path, config: TranslationConfig, write: bool = True):
        self.root = root
        self.config = config
        self.write_enabled = write

    def segment_path(self, key: str) -> Path:
        return self.root / "segments" / key[:2] / f"{key}.json"

    def get(self, key: str) -> dict[str, Any] | None:
        path = self.segment_path(key)
        if not path.exists():
            return None
        with path.open(encoding="utf-8") as handle:
            record = json.load(handle)
        if record.get("source_hash") != key or record.get("model_revision") != self.config.model_revision:
            return None
        if record.get("validation", {}).get("passed") is not True:
            return None
        return record

    def put(self, key: str, record: dict[str, Any]) -> None:
        if not self.write_enabled:
            return
        path = self.segment_path(key)
        path.parent.mkdir(parents=True, exist_ok=True)
        _atomic_write_json(path, record)

    def run_path(self, environment: str, source_sha: str, job_id: str) -> Path:
        return self.root / "runs" / "transformers" / "ja" / environment / source_sha / f"{job_id}.json"

    def write_run(self, environment: str, source_sha: str, job_id: str, manifest: dict[str, Any]) -> Path | None:
        if not self.write_enabled:
            return None
        path = self.run_path(environment, source_sha, job_id)
        path.parent.mkdir(parents=True, exist_ok=True)
        _atomic_write_json(path, manifest)
        return path

    def state_path(self, environment: str) -> Path:
        return self.root / "state" / f"transformers-ja-{environment}.json"

    def read_state(self, environment: str) -> dict[str, Any]:
        path = self.state_path(environment)
        if not path.exists():
            return {
                "environment": environment,
                "merged_source_sha": None,
                "open_pr_source_sha": None,
                "open_pr_number": None,
                "open_pr_state": None,
            }
        with path.open(encoding="utf-8") as handle:
            return json.load(handle)

    def write_state(self, environment: str, state: dict[str, Any]) -> Path | None:
        if not self.write_enabled:
            return None
        path = self.state_path(environment)
        path.parent.mkdir(parents=True, exist_ok=True)
        _atomic_write_json(path, state)
        return path


def _atomic_write_json(path: Path, value: dict[str, Any]) -> None:
    fd, temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
    try:
        with os.fdopen(fd, "w", encoding="utf-8") as handle:
            json.dump(value, handle, ensure_ascii=False, sort_keys=True, indent=2)
            handle.write("\n")
        os.replace(temporary, path)
    except Exception:
        try:
            os.unlink(temporary)
        except FileNotFoundError:
            pass
        raise