"""Typed continuity package contract and canonical source row."""

from __future__ import annotations

import hashlib
import json
import re
from enum import StrEnum
from pathlib import Path
from typing import ClassVar, Final

from pydantic import BaseModel, ConfigDict, Field, model_validator

SOURCE_ROW_DIGEST: Final = "405b519c7f0ae51d413d26e4ca5bb1fd69786c3eb11a5dbe1f00e2701bd90d26"
SOURCE_FILE_DIGEST: Final = "7a8d7d6ecc66c863bc27793df6a5f3efd1ba0661cf3568095b6b9bcf4cb45208"
SOURCE_ROW_SIZE: Final = 792
ZERO_DIGEST: Final = "0" * 64
PACKAGE_ID: Final = "nutricoach-v150-day-status-continuity-r71-r1"
OBSERVER_NAMESPACE: Final = "observer-r71-continuity-r1"
SEQUENCE_ZERO_DIGEST: Final = "dd9cdc73c717380a6aa3e1d35edfcafc8ba949eaf7203029b159422330257cdf"
CUSTOMER_IDENTITY_DIGEST: Final = "253243ad46f32f8d456514b1c8a8fda4f605dc04874b69b1e3ded72de49c877c"
REMINDER_RESERVATION_ID: Final = (
    "weekly-reminder-5beb9e3cfe7e156864a1c80e788db4c9c4c92c4e23c3e8790a3c42a5d1ba227a"
)
_DIGEST: Final = re.compile(r"^[0-9a-f]{64}$")


class ContractError(RuntimeError):
    """An untrusted package contract is inadmissible."""


class Phase(StrEnum):
    """Exact durable transaction phases."""

    RESERVED = "RESERVED"
    OBSERVER_TIMER_FENCED = "OBSERVER_TIMER_FENCED"
    INPUTS_LOCKED_AND_VERIFIED = "INPUTS_LOCKED_AND_VERIFIED"
    APPEND_INTENT_DURABLE = "APPEND_INTENT_DURABLE"
    ROW_DURABLE = "ROW_DURABLE"
    PROVENANCE_DURABLE = "PROVENANCE_DURABLE"
    MANUAL_PASS_DURABLE = "MANUAL_PASS_DURABLE"
    TIMER_WATCH_ARMED = "TIMER_WATCH_ARMED"
    TIMER_PASS_DURABLE = "TIMER_PASS_DURABLE"
    COMMITTING = "COMMITTING"
    COMMITTED = "COMMITTED"


class FilePin(BaseModel):
    """Exact file bytes and identity admitted by the package."""

    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid")
    path: Path
    sha256: str = Field(pattern=r"^[0-9a-f]{64}$")
    device: int = Field(ge=0)
    inode: int = Field(gt=0)
    uid: int = Field(ge=0)
    gid: int = Field(ge=0)
    mode: int
    nlink: int = Field(ge=1)
    size: int = Field(ge=0)


class RootPin(BaseModel):
    """Exact no-follow root identity."""

    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid")
    path: Path
    device: int = Field(ge=0)
    inode: int = Field(gt=0)
    uid: int = Field(ge=0)
    gid: int = Field(ge=0)
    mode: int = 0o700
    nlink: int = 2


class PackageContract(BaseModel):
    """Canonical permission package binding every admitted input class."""

    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid")
    schema_version: str = Field(alias="schema")
    package_id: str
    authorization_root: Path
    execution_root: Path
    observer_namespace: str
    source_root: RootPin
    target_root: RootPin
    file_pins: tuple[FilePin, ...]
    controller_closure: tuple[FilePin, ...]
    installed_records: tuple[FilePin, ...]
    protected_files: tuple[FilePin, ...]
    candidate_digest: str = Field(pattern=r"^[0-9a-f]{64}$")
    sequence_zero_digest: str = Field(pattern=r"^[0-9a-f]{64}$")
    source_row_digest: str = Field(pattern=r"^[0-9a-f]{64}$")
    expected_frame_sha256: str = Field(pattern=r"^[0-9a-f]{64}$")
    zero_send_oracle_sha256: str = Field(pattern=r"^[0-9a-f]{64}$")
    package_digest: str = Field(pattern=r"^[0-9a-f]{64}$")

    @model_validator(mode="after")
    def validate_fixed_contract(self) -> PackageContract:
        """Reject aliases, stale namespaces, and self-inconsistent digests."""
        if self.package_id != PACKAGE_ID or self.observer_namespace != OBSERVER_NAMESPACE:
            raise ContractError("fixed package identity")
        if self.source_root.path == self.target_root.path:
            raise ContractError("authority roots alias")
        if self.source_row_digest != SOURCE_ROW_DIGEST:
            raise ContractError("source row digest")
        if self.expected_frame_sha256 != SOURCE_FILE_DIGEST:
            raise ContractError("expected frame digest")
        if self.sequence_zero_digest != SEQUENCE_ZERO_DIGEST:
            raise ContractError("sequence-zero pin")
        if self.package_digest != package_digest(self):
            raise ContractError("package digest")
        return self


def canonical_source_frame() -> bytes:
    """Return the design-bound canonical source frame."""
    row: dict[str, str | int | None] = {
        "canonical_digest": SEQUENCE_ZERO_DIGEST,
        "canonical_sequence": 0,
        "customer_identity_digest": CUSTOMER_IDENTITY_DIGEST,
        "kst_day": "2026-08-31",
        "logical_key": "0fb4a3f228f7fd1c81ad6cdd21cf1be01316bbd405316986a14e49d327e23fa7",
        "occurred_at_kst": "2026-08-31T23:00:00+09:00",
        "predecessor_row_digest": ZERO_DIGEST,
        "reminder_audit_id": "schedule-row-44",
        "reminder_reservation_id": REMINDER_RESERVATION_ID,
        "row_digest": SOURCE_ROW_DIGEST,
        "schema_version": "nutricoach-weekly-operations-v1",
        "source_event_digest": None,
        "source_event_id": None,
        "state": "missed",
    }
    return json.dumps(row, sort_keys=True, separators=(",", ":")).encode() + b"\n"


def canonical_json(value: BaseModel, *, exclude_digest: bool = False) -> bytes:
    """Encode one frozen model with the package canonical JSON contract."""
    excluded: set[str] = {"package_digest"} if exclude_digest else set()
    payload = value.model_dump(mode="json", exclude=excluded, by_alias=True)
    return json.dumps(payload, sort_keys=True, separators=(",", ":")).encode() + b"\n"


def package_digest(contract: PackageContract) -> str:
    """Derive the approval-bound digest while excluding only itself."""
    return hashlib.sha256(canonical_json(contract, exclude_digest=True)).hexdigest()


def approval_phrase(package_sha256: str) -> str:
    """Return the exact operator phrase bound to the final package digest."""
    if _DIGEST.fullmatch(package_sha256) is None:
        raise ContractError("approval digest")
    return f"AUTHORIZE NUTRICOACH DAY STATUS CONTINUITY {package_sha256}"