"""Deterministic cost-quality-latency gate over invented slice evidence."""

from dataclasses import asdict, dataclass, fields
import hashlib
import json
import re


IDENTITY = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:/@-]{0,127}")
SHA256 = re.compile(r"[a-f0-9]{64}")


def identity(value):
    if type(value) is not str or not IDENTITY.fullmatch(value):
        raise ValueError("exact bounded identity required")
    return value


def sha256_text(value):
    if type(value) is not str or not SHA256.fullmatch(value):
        raise ValueError("exact lowercase SHA-256 required")
    return value


def integer(value, lower, upper):
    if type(value) is not int or not lower <= value <= upper:
        raise ValueError("bounded non-boolean integer required")
    return value


def exact_bool(value):
    if type(value) is not bool:
        raise ValueError("exact boolean required")
    return value


def bounded_tuple(value, lower, upper):
    if type(value) not in (tuple, list):
        raise ValueError("bounded tuple or list required")
    integer(len(value), lower, upper)
    return tuple(value)


def digest(value):
    try:
        encoded = json.dumps(
            value, sort_keys=True, separators=(",", ":"), allow_nan=False
        ).encode()
    except (TypeError, ValueError, OverflowError) as error:
        raise ValueError("canonical JSON value required") from error
    return hashlib.sha256(encoded).hexdigest()


def token(label):
    identity(label)
    return hashlib.sha256(label.encode()).hexdigest()


def seal(record):
    if type(record.content_id) is not str:
        raise ValueError("content digest requires exact string")
    data = asdict(record)
    data.pop("content_id")
    return digest(data)


def validate_record(record, cls):
    if type(record) is not cls:
        raise ValueError("concrete frozen record required")
    try:
        rebuilt = cls(
            **{field.name: getattr(record, field.name) for field in fields(cls)}
        )
    except (AttributeError, TypeError, ValueError, OverflowError) as error:
        raise ValueError("malformed record") from error
    if record != rebuilt or record.content_id != rebuilt.content_id:
        raise ValueError("noncanonical or modified record")
    return rebuilt


def scope_tuple(value):
    result = bounded_tuple(value, 6, 6)
    for item in result:
        identity(item)
    if len(set(result)) != len(result):
        raise ValueError("duplicate scope identity")
    return result


@dataclass(frozen=True)
class SliceBudget:
    name: str
    minimum_quality_permille: int
    max_p95_latency_ms: int
    max_cost_microunits_per_request: int
    max_cost_microunits_per_success: int
    minimum_quality_samples: int
    minimum_observation_windows: int

    def __post_init__(self):
        identity(self.name)
        integer(self.minimum_quality_permille, 0, 1_000)
        integer(self.max_p95_latency_ms, 1, 86_400_000)
        integer(self.max_cost_microunits_per_request, 1, 1_000_000_000)
        integer(self.max_cost_microunits_per_success, 1, 1_000_000_000_000)
        integer(self.minimum_quality_samples, 1, 1_000_000_000)
        integer(self.minimum_observation_windows, 1, 1_000_000)


def slice_budgets(value):
    values = bounded_tuple(value, 1, 32)
    canonical = []
    for budget in values:
        if type(budget) is not SliceBudget:
            raise ValueError("concrete slice budget required")
        try:
            rebuilt = SliceBudget(**asdict(budget))
        except (TypeError, ValueError, OverflowError) as error:
            raise ValueError("malformed slice budget") from error
        if budget != rebuilt:
            raise ValueError("noncanonical slice budget")
        canonical.append(rebuilt)
    if len({budget.name for budget in canonical}) != len(canonical):
        raise ValueError("duplicate slice budget")
    return tuple(canonical)


@dataclass(frozen=True)
class OperatingEnvelopeContract:
    scope: tuple = (
        "product-contract-v1",
        "quality-policy-v1",
        "latency-slo-v1",
        "cost-policy-v1",
        "traffic-forecast-v1",
        "fixture-v1",
    )
    budgets: tuple = (
        SliceBudget("interactive", 920, 350, 35_000, 40_000, 1_000, 3),
        SliceBudget("batch", 900, 5_000, 15_000, 17_000, 500, 3),
        SliceBudget("safety-boundary", 980, 800, 55_000, 60_000, 1_000, 3),
    )
    max_monthly_cost_units: int = 45_000
    minimum_telemetry_permille: int = 990
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        object.__setattr__(self, "budgets", slice_budgets(self.budgets))
        integer(self.max_monthly_cost_units, 1, 1_000_000_000_000)
        integer(self.minimum_telemetry_permille, 0, 1_000)
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("operating-envelope contract digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class SliceMeasurement:
    scope: tuple
    slice_name: str
    quality_passes: int
    quality_trials: int
    p95_latency_ms: int
    cost_microunits_per_request: int
    successful_outcomes: int
    attempted_outcomes: int
    projected_monthly_requests: int
    observation_windows: int
    evidence_fresh: bool
    evidence_digest: str
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        identity(self.slice_name)
        integer(self.quality_trials, 1, 1_000_000_000)
        integer(self.quality_passes, 0, self.quality_trials)
        integer(self.p95_latency_ms, 1, 86_400_000)
        integer(self.cost_microunits_per_request, 1, 1_000_000_000)
        integer(self.attempted_outcomes, 1, 1_000_000_000)
        integer(self.successful_outcomes, 0, self.attempted_outcomes)
        integer(self.projected_monthly_requests, 1, 1_000_000_000_000)
        integer(self.observation_windows, 1, 1_000_000)
        exact_bool(self.evidence_fresh)
        sha256_text(self.evidence_digest)
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("slice-measurement digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class OperatingEnvelopeEvidence:
    scope: tuple
    contract_content_id: str
    measurements: tuple
    telemetry_covered_requests: int
    telemetry_total_requests: int
    review_fresh: bool
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        sha256_text(self.contract_content_id)
        values = bounded_tuple(self.measurements, 1, 32)
        canonical = []
        for measurement in values:
            rebuilt = validate_record(measurement, SliceMeasurement)
            if rebuilt.scope != self.scope:
                raise ValueError("measurement outside operating-envelope scope")
            canonical.append(rebuilt)
        if len({measurement.slice_name for measurement in canonical}) != len(canonical):
            raise ValueError("duplicate slice measurement")
        integer(self.telemetry_total_requests, 1, 1_000_000_000_000)
        integer(
            self.telemetry_covered_requests,
            0,
            self.telemetry_total_requests,
        )
        exact_bool(self.review_fresh)
        object.__setattr__(self, "measurements", tuple(canonical))
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("operating-envelope evidence digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class EnvelopeGateReport:
    decision: str
    monthly_cost_units: int
    evaluated_slices: tuple
    violations: tuple
    evidence_id: str
    claim: str = "LOCAL_ENVELOPE_GATE_NOT_SLO_OR_FINANCIAL_CERTIFICATION"


def gate_operating_envelope(
    contract: OperatingEnvelopeContract, evidence: OperatingEnvelopeEvidence
):
    """Gate every declared slice independently, plus total forecast cost."""
    contract = validate_record(contract, OperatingEnvelopeContract)
    evidence = validate_record(evidence, OperatingEnvelopeEvidence)
    if evidence.scope != contract.scope or evidence.contract_content_id != contract.content_id:
        raise ValueError("evidence belongs to another operating-envelope contract")

    budgets = {budget.name: budget for budget in contract.budgets}
    actual = {measurement.slice_name: measurement for measurement in evidence.measurements}
    violations = []
    for name in sorted(set(budgets) - set(actual)):
        violations.append(f"{name}/missing-measurement")
    for name in sorted(set(actual) - set(budgets)):
        violations.append(f"{name}/undeclared-slice")
    for name in sorted(set(budgets) & set(actual)):
        budget = budgets[name]
        measurement = actual[name]
        if measurement.quality_trials < budget.minimum_quality_samples:
            violations.append(f"{name}/quality-samples")
        if measurement.quality_passes * 1_000 < budget.minimum_quality_permille * measurement.quality_trials:
            violations.append(f"{name}/quality")
        if measurement.p95_latency_ms > budget.max_p95_latency_ms:
            violations.append(f"{name}/latency")
        if measurement.cost_microunits_per_request > budget.max_cost_microunits_per_request:
            violations.append(f"{name}/unit-cost")
        if (
            measurement.cost_microunits_per_request
            * measurement.attempted_outcomes
            > budget.max_cost_microunits_per_success
            * measurement.successful_outcomes
        ):
            violations.append(f"{name}/cost-per-success")
        if measurement.observation_windows < budget.minimum_observation_windows:
            violations.append(f"{name}/observation-windows")
        if not measurement.evidence_fresh or not evidence.review_fresh:
            violations.append(f"{name}/stale-evidence")

    total_microunits = sum(
        measurement.cost_microunits_per_request
        * measurement.projected_monthly_requests
        for measurement in evidence.measurements
    )
    monthly_cost_units = (total_microunits + 999_999) // 1_000_000
    if monthly_cost_units > contract.max_monthly_cost_units:
        violations.append("aggregate/monthly-cost")
    if (
        evidence.telemetry_covered_requests * 1_000
        < contract.minimum_telemetry_permille * evidence.telemetry_total_requests
    ):
        violations.append("aggregate/telemetry-coverage")
    decision = (
        "WITHIN_OPERATING_ENVELOPE"
        if not violations
        else "HOLD_OUTSIDE_OPERATING_ENVELOPE"
    )
    return EnvelopeGateReport(
        decision=decision,
        monthly_cost_units=monthly_cost_units,
        evaluated_slices=tuple(sorted(set(budgets) & set(actual))),
        violations=tuple(violations),
        evidence_id=evidence.content_id,
    )


def illustrative_fixture():
    contract = OperatingEnvelopeContract()

    def measurement(
        name,
        passes,
        trials,
        latency,
        unit_cost,
        successful_outcomes,
        attempted_outcomes,
        requests,
    ):
        return SliceMeasurement(
            scope=contract.scope,
            slice_name=name,
            quality_passes=passes,
            quality_trials=trials,
            p95_latency_ms=latency,
            cost_microunits_per_request=unit_cost,
            successful_outcomes=successful_outcomes,
            attempted_outcomes=attempted_outcomes,
            projected_monthly_requests=requests,
            observation_windows=3,
            evidence_fresh=True,
            evidence_digest=token(f"{name}-measurement"),
        )

    evidence = OperatingEnvelopeEvidence(
        scope=contract.scope,
        contract_content_id=contract.content_id,
        measurements=(
            measurement("interactive", 940, 1_000, 300, 30_000, 900, 1_000, 1_000_000),
            measurement("batch", 460, 500, 4_000, 12_000, 450, 500, 500_000),
            measurement("safety-boundary", 990, 1_000, 700, 50_000, 900, 1_000, 100_000),
        ),
        telemetry_covered_requests=9_950,
        telemetry_total_requests=10_000,
        review_fresh=True,
    )
    return contract, evidence


def main():
    contract, evidence = illustrative_fixture()
    report = gate_operating_envelope(contract, evidence)
    print("example=illustrative_only")
    print(f"decision={report.decision}")
    print(f"slices={','.join(report.evaluated_slices)}")
    print(f"monthly_cost_units={report.monthly_cost_units}")
    print(f"violations={','.join(report.violations)}")
    print(f"claim={report.claim}")


if __name__ == "__main__":
    main()