"""
AI Agent Telegram receipt approval package snapshot.

Loads the latest committed P2-403E approval package for Telegram queue,
delivery, acknowledgement, failure, and retry receipts. This module never
writes gateway queues, calls Telegram Bot API, changes receiver routes, sends
notifications, or starts runtime workers.
"""

from __future__ import annotations

import json
from pathlib import Path
from typing import Any

from src.services.snapshot_paths import default_evaluations_dir

_DEFAULT_EVALUATIONS_DIR = default_evaluations_dir(Path(__file__))
_SNAPSHOT_PATTERN = "ai_agent_telegram_receipt_approval_package_*.json"
_SCHEMA_VERSION = "ai_agent_telegram_receipt_approval_package_v1"


def load_latest_ai_agent_telegram_receipt_approval_package(
    evaluations_dir: Path | None = None,
) -> dict[str, Any]:
    """Load the newest committed AI Agent Telegram receipt approval package."""
    directory = evaluations_dir or _DEFAULT_EVALUATIONS_DIR
    candidates = sorted(directory.glob(_SNAPSHOT_PATTERN))
    if not candidates:
        raise FileNotFoundError(
            f"no AI Agent Telegram receipt approval package snapshots found in {directory}"
        )

    latest = candidates[-1]
    with latest.open(encoding="utf-8") as handle:
        payload = json.load(handle)

    if not isinstance(payload, dict):
        raise ValueError(f"{latest}: expected JSON object")
    _require_schema(payload, str(latest))
    _require_read_only_boundaries(payload, str(latest))
    _require_package_safety(payload, str(latest))
    _require_rollup_consistency(payload, str(latest))
    return payload


def _require_schema(payload: dict[str, Any], label: str) -> None:
    actual = payload.get("schema_version")
    if actual != _SCHEMA_VERSION:
        raise ValueError(f"{label}: expected schema_version={_SCHEMA_VERSION}, got {actual!r}")
    status = payload.get("program_status") or {}
    if status.get("read_only_mode") is not True:
        raise ValueError(f"{label}: program_status.read_only_mode must be true")
    if status.get("runtime_authority") != "approval_package_only_no_telegram_send":
        raise ValueError(f"{label}: runtime_authority must stay approval_package_only_no_telegram_send")


def _require_read_only_boundaries(payload: dict[str, Any], label: str) -> None:
    boundaries = payload.get("approval_boundaries") or {}
    enabled = sorted(key for key, value in boundaries.items() if value is not False)
    if enabled:
        raise ValueError(f"{label}: approval boundaries must remain false: {enabled}")

    truth = payload.get("telegram_truth") or {}
    false_flags = {
        "telegram_send_allowed",
        "gateway_queue_write_allowed",
        "direct_bot_api_allowed",
        "receiver_route_change_allowed",
        "runtime_worker_allowed",
    }
    unsafe = sorted(flag for flag in false_flags if truth.get(flag) is not False)
    if unsafe:
        raise ValueError(f"{label}: Telegram truth flags must remain false: {unsafe}")

    zero_counts = {
        "live_queued_receipt_count",
        "live_delivered_receipt_count",
        "live_acknowledged_receipt_count",
        "live_failed_receipt_count",
        "live_retry_count",
    }
    non_zero = sorted(key for key in zero_counts if truth.get(key) != 0)
    if non_zero:
        raise ValueError(f"{label}: live Telegram receipt counts must remain zero: {non_zero}")


def _require_package_safety(payload: dict[str, Any], label: str) -> None:
    package = payload.get("receipt_package") or {}
    required_fields = set(package.get("required_fields") or [])
    required_minimum = {
        "receipt_event_id",
        "incident_id",
        "target_channel_alias",
        "message_template_id",
        "redacted_message_summary",
        "delivery_correlation_id",
        "retry_policy_ref",
        "owner_review_required",
    }
    missing = sorted(required_minimum - required_fields)
    if missing:
        raise ValueError(f"{label}: receipt package missing required fields: {missing}")
    if package.get("owner_review_required") is not True:
        raise ValueError(f"{label}: owner review must be required")
    if package.get("retry_policy_required") is not True:
        raise ValueError(f"{label}: retry policy must be required")
    if package.get("delivery_receipt_required") is not True:
        raise ValueError(f"{label}: delivery receipt must be required")

    redaction = payload.get("display_redaction_contract") or {}
    if redaction.get("redaction_required") is not True:
        raise ValueError(f"{label}: frontend redaction must be required")
    for flag in ("raw_payload_display_allowed", "private_reasoning_display_allowed", "secret_value_display_allowed"):
        if redaction.get(flag) is not False:
            raise ValueError(f"{label}: {flag} must remain false")

    retry = payload.get("retry_contract") or {}
    if retry.get("retry_required") is not True:
        raise ValueError(f"{label}: retry_contract.retry_required must be true")
    if not retry.get("retry_steps"):
        raise ValueError(f"{label}: retry steps must not be empty")


def _require_rollup_consistency(payload: dict[str, Any], label: str) -> None:
    rollups = payload.get("rollups") or {}
    gates = payload.get("receipt_gates") or []
    lanes = payload.get("receipt_lanes") or []
    package = payload.get("receipt_package") or {}
    truth = payload.get("telegram_truth") or {}
    expected_counts = {
        "receipt_gate_count": len(gates),
        "receipt_lane_count": len(lanes),
        "blocked_runtime_action_count": len({gate.get("blocked_runtime_action") for gate in gates}),
        "required_field_count": len(package.get("required_fields") or []),
        "forbidden_field_count": len(package.get("forbidden_fields") or []),
    }
    mismatched = {
        key: {"expected": expected, "actual": rollups.get(key)}
        for key, expected in expected_counts.items()
        if rollups.get(key) != expected
    }
    if mismatched:
        raise ValueError(f"{label}: rollup counts must match payload sections: {mismatched}")

    approval_required = sorted(
        gate.get("gate_id") for gate in gates if gate.get("status") == "approval_required"
    )
    if sorted(rollups.get("approval_required_gate_ids") or []) != approval_required:
        raise ValueError(f"{label}: rollups.approval_required_gate_ids mismatch")

    live_total = sum(
        int(truth.get(key) or 0)
        for key in (
            "live_queued_receipt_count",
            "live_delivered_receipt_count",
            "live_acknowledged_receipt_count",
            "live_failed_receipt_count",
            "live_retry_count",
        )
    )
    if rollups.get("live_receipt_count_total") != live_total:
        raise ValueError(f"{label}: rollups.live_receipt_count_total mismatch")
