"""Pinned shipped public knowledge for weekly owner drafts."""

from __future__ import annotations

import hashlib
from dataclasses import dataclass
from enum import StrEnum
from pathlib import Path
from typing import ClassVar, Final, override

from pydantic import BaseModel, ConfigDict, ValidationError

_PACKAGE_NAME: Final = "weekly-owner-principles-v1.json"
_PACKAGE_SHA256: Final = "58bc20cd172db2ad307246ec3b9d4244c6d1322ed5b5ac9b82db1d7ec82e2af7"
_SCHEMA: Final = "nutricoach-weekly-owner-principles-v1"


class WeeklyPrincipleId(StrEnum):
    RECORDED_TREND = "recorded_trend"
    MISSING_IS_UNKNOWN = "missing_is_unknown"
    OWNER_DECIDES = "owner_decides"


class WeeklyEmphasis(StrEnum):
    SUMMARY_FIRST = "summary_first"
    LIMITS_FIRST = "limits_first"


@dataclass(frozen=True, slots=True)
class WeeklyKnowledgeError(ValueError):
    reason: str

    @override
    def __str__(self) -> str:
        return f"weekly public knowledge is invalid: {self.reason}"


@dataclass(frozen=True, slots=True)
class WeeklyPrinciple:
    principle_id: WeeklyPrincipleId
    approved_text: str
    template: str


class _PrincipleInput(BaseModel):
    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid", strict=True)

    id: str
    approved_text: str
    template: str


class _PackageInput(BaseModel):
    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid", strict=True)

    schema_: str
    principles: list[_PrincipleInput]


class _KnowledgeSeal:
    __slots__: Final = ()


_SEAL: Final = _KnowledgeSeal()


@dataclass(frozen=True, slots=True)
class VerifiedWeeklyPublicKnowledge:
    principles: tuple[WeeklyPrinciple, ...]
    package_digest: str
    _seal: _KnowledgeSeal

    def verify(self) -> bool:
        if self._seal is not _SEAL or self.package_digest != _PACKAGE_SHA256:
            return False
        return self == load_shipped_weekly_public_knowledge()

    def principle(self, principle_id: WeeklyPrincipleId) -> WeeklyPrinciple:
        for principle in self.principles:
            if principle.principle_id is principle_id:
                return principle
        raise WeeklyKnowledgeError("principle id")


def load_shipped_weekly_public_knowledge() -> VerifiedWeeklyPublicKnowledge:
    """Load the exact packaged finite principle set; callers cannot inject records."""
    path = Path(__file__).resolve().parent / "policies" / _PACKAGE_NAME
    payload = path.read_bytes()
    if hashlib.sha256(payload).hexdigest() != _PACKAGE_SHA256:
        raise WeeklyKnowledgeError("package digest")
    try:
        raw = _PackageInput.model_validate_json(
            payload.replace(b'"schema":', b'"schema_":', 1)
        )
    except ValidationError as error:
        raise WeeklyKnowledgeError("package JSON") from error
    if raw.schema_ != _SCHEMA:
        raise WeeklyKnowledgeError("package schema")
    if len(raw.principles) != 3:
        raise WeeklyKnowledgeError("package records")
    principles: list[WeeklyPrinciple] = []
    for record in raw.principles:
        try:
            principle_id = WeeklyPrincipleId(record.id)
        except ValueError as error:
            raise WeeklyKnowledgeError("principle id") from error
        if not record.approved_text or not record.template:
            raise WeeklyKnowledgeError("principle text")
        principles.append(WeeklyPrinciple(principle_id, record.approved_text, record.template))
    if tuple(item.principle_id for item in principles) != tuple(WeeklyPrincipleId):
        raise WeeklyKnowledgeError("principle inventory")
    return VerifiedWeeklyPublicKnowledge(tuple(principles), _PACKAGE_SHA256, _SEAL)