"""Deterministic AI load-test gate over invented aggregate slice results."""

from dataclasses import asdict, dataclass, fields
import hashlib
import itertools
import json
import math
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 finite_float(value, lower, upper, *, lower_inclusive=True):
    if type(value) is not float or not math.isfinite(value):
        raise ValueError("exact finite float required")
    lower_ok = value >= lower if lower_inclusive else value > lower
    if not lower_ok or value > upper:
        raise ValueError("bounded finite float required")
    return value


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


def bounded_sequence(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 identity_sequence(value, lower, upper):
    result = bounded_sequence(value, lower, upper)
    for item in result:
        identity(item)
    if len(set(result)) != len(result):
        raise ValueError("duplicate identity")
    return result


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 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):
    return identity_sequence(value, 7, 7)


@dataclass(frozen=True)
class LoadTestContract:
    scope: tuple = (
        "load-policy-v1",
        "workload-schema-v1",
        "quality-rubric-v1",
        "latency-schema-v1",
        "cancellation-schema-v1",
        "cache-policy-v1",
        "fixture-v1",
    )
    required_sequence_buckets: tuple = ("short", "medium", "long")
    required_traffic_patterns: tuple = ("steady", "ramp", "spike")
    required_cache_states: tuple = ("cold", "warm")
    minimum_requests_per_slice: int = 1_000
    max_p95_ttft_ms: float = 500.0
    max_p99_e2e_ms: float = 2_500.0
    max_error_rate: float = 0.01
    max_cancellation_leak_rate: float = 0.01
    max_retry_amplification: float = 1.10
    minimum_quality_pass_rate: float = 0.95
    minimum_generator_headroom: float = 0.20
    require_complete_telemetry: bool = True
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        object.__setattr__(
            self,
            "required_sequence_buckets",
            identity_sequence(self.required_sequence_buckets, 1, 16),
        )
        object.__setattr__(
            self,
            "required_traffic_patterns",
            identity_sequence(self.required_traffic_patterns, 1, 16),
        )
        object.__setattr__(
            self,
            "required_cache_states",
            identity_sequence(self.required_cache_states, 1, 8),
        )
        integer(self.minimum_requests_per_slice, 1, 100_000_000)
        finite_float(self.max_p95_ttft_ms, 0.0, 86_400_000.0, lower_inclusive=False)
        finite_float(self.max_p99_e2e_ms, 0.0, 86_400_000.0, lower_inclusive=False)
        if self.max_p99_e2e_ms < self.max_p95_ttft_ms:
            raise ValueError("end-to-end limit cannot be below first-token limit")
        finite_float(self.max_error_rate, 0.0, 1.0)
        finite_float(self.max_cancellation_leak_rate, 0.0, 1.0)
        finite_float(self.max_retry_amplification, 1.0, 100.0)
        finite_float(self.minimum_quality_pass_rate, 0.0, 1.0)
        finite_float(self.minimum_generator_headroom, 0.0, 1.0)
        if exact_bool(self.require_complete_telemetry) is not True:
            raise ValueError("complete telemetry is required")
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("load-test contract digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class SliceResult:
    scope: tuple
    run_id: str
    service_revision: str
    sequence_bucket: str
    traffic_pattern: str
    cache_state: str
    request_count: int
    completed_count: int
    error_count: int
    cancelled_count: int
    cancellation_leaks: int
    retry_attempts: int
    quality_checks: int
    quality_passes: int
    p95_ttft_ms: float
    p99_e2e_ms: float
    telemetry_complete: bool
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        for value in (
            self.run_id,
            self.service_revision,
            self.sequence_bucket,
            self.traffic_pattern,
            self.cache_state,
        ):
            identity(value)
        integer(self.request_count, 1, 100_000_000)
        integer(self.completed_count, 0, self.request_count)
        integer(self.error_count, 0, self.request_count)
        integer(self.cancelled_count, 0, self.request_count)
        if self.completed_count + self.error_count + self.cancelled_count != self.request_count:
            raise ValueError("request outcomes must exactly partition requests")
        integer(self.cancellation_leaks, 0, self.cancelled_count)
        integer(self.retry_attempts, 0, self.request_count * 10)
        integer(self.quality_checks, 0, self.completed_count)
        integer(self.quality_passes, 0, self.quality_checks)
        finite_float(self.p95_ttft_ms, 0.0, 86_400_000.0, lower_inclusive=False)
        finite_float(self.p99_e2e_ms, 0.0, 86_400_000.0, lower_inclusive=False)
        if self.p99_e2e_ms < self.p95_ttft_ms:
            raise ValueError("end-to-end latency cannot be below first-token latency")
        exact_bool(self.telemetry_complete)
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("slice result digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class LoadTestEvidence:
    scope: tuple
    contract_content_id: str
    workload_digest: str
    deterministic_seed: int
    generator_headroom: float
    slices: tuple
    content_id: str = ""

    def __post_init__(self):
        object.__setattr__(self, "scope", scope_tuple(self.scope))
        sha256_text(self.contract_content_id)
        sha256_text(self.workload_digest)
        integer(self.deterministic_seed, 0, 4_294_967_295)
        finite_float(self.generator_headroom, 0.0, 1.0)
        raw_slices = bounded_sequence(self.slices, 1, 1_000)
        checked = tuple(validate_record(item, SliceResult) for item in raw_slices)
        for item in checked:
            if item.scope != self.scope:
                raise ValueError("slice outside load-test scope")
        run_ids = {item.run_id for item in checked}
        revisions = {item.service_revision for item in checked}
        if len(run_ids) != 1 or len(revisions) != 1:
            raise ValueError("all slices require one run and service revision")
        dimensions = [
            (item.sequence_bucket, item.traffic_pattern, item.cache_state)
            for item in checked
        ]
        if len(set(dimensions)) != len(dimensions):
            raise ValueError("duplicate load-test slice")
        object.__setattr__(self, "slices", checked)
        expected = seal(self)
        if self.content_id and self.content_id != expected:
            raise ValueError("load-test evidence digest mismatch")
        object.__setattr__(self, "content_id", expected)


@dataclass(frozen=True)
class LoadTestReport:
    decision: str
    violations: tuple
    slice_count: int
    request_count: int
    worst_p95_ttft_ms: float
    worst_p99_e2e_ms: float
    error_rate: float
    cancellation_leak_rate: float
    retry_amplification: float
    quality_pass_rate: float
    evidence_id: str
    claim: str = "LOCAL_SYNTHETIC_GATE_NOT_CAPACITY_CERTIFICATION"


def audit_load_test(
    contract: LoadTestContract, evidence: LoadTestEvidence
) -> LoadTestReport:
    """Audit declared aggregate slices without generating or sending any traffic."""
    contract = validate_record(contract, LoadTestContract)
    evidence = validate_record(evidence, LoadTestEvidence)
    if evidence.scope != contract.scope or evidence.contract_content_id != contract.content_id:
        raise ValueError("evidence belongs to another load-test contract")

    expected = set(
        itertools.product(
            contract.required_sequence_buckets,
            contract.required_traffic_patterns,
            contract.required_cache_states,
        )
    )
    observed = {
        (item.sequence_bucket, item.traffic_pattern, item.cache_state)
        for item in evidence.slices
    }
    total_requests = sum(item.request_count for item in evidence.slices)
    total_errors = sum(item.error_count for item in evidence.slices)
    total_cancelled = sum(item.cancelled_count for item in evidence.slices)
    total_leaks = sum(item.cancellation_leaks for item in evidence.slices)
    total_retries = sum(item.retry_attempts for item in evidence.slices)
    total_quality_checks = sum(item.quality_checks for item in evidence.slices)
    total_quality_passes = sum(item.quality_passes for item in evidence.slices)
    worst_ttft = max(item.p95_ttft_ms for item in evidence.slices)
    worst_e2e = max(item.p99_e2e_ms for item in evidence.slices)
    error_rate = total_errors / total_requests
    cancellation_leak_rate = (
        total_leaks / total_cancelled if total_cancelled else 0.0
    )
    retry_amplification = (total_requests + total_retries) / total_requests
    quality_pass_rate = (
        total_quality_passes / total_quality_checks if total_quality_checks else 0.0
    )

    readiness = []
    if observed != expected:
        readiness.append("slice-coverage")
    if any(
        item.request_count < contract.minimum_requests_per_slice
        for item in evidence.slices
    ):
        readiness.append("sample-size")
    if evidence.generator_headroom < contract.minimum_generator_headroom:
        readiness.append("generator-headroom")
    if contract.require_complete_telemetry and any(
        not item.telemetry_complete for item in evidence.slices
    ):
        readiness.append("telemetry-incomplete")

    regressions = []
    if worst_ttft > contract.max_p95_ttft_ms:
        regressions.append("p95-ttft")
    if worst_e2e > contract.max_p99_e2e_ms:
        regressions.append("p99-e2e")
    if any(
        item.error_count / item.request_count > contract.max_error_rate
        for item in evidence.slices
    ):
        regressions.append("error-rate")
    if any(
        item.cancelled_count
        and item.cancellation_leaks / item.cancelled_count
        > contract.max_cancellation_leak_rate
        for item in evidence.slices
    ):
        regressions.append("cancellation-leak")
    if any(
        (item.request_count + item.retry_attempts) / item.request_count
        > contract.max_retry_amplification
        for item in evidence.slices
    ):
        regressions.append("retry-amplification")
    if any(
        item.quality_checks == 0
        or item.quality_passes / item.quality_checks
        < contract.minimum_quality_pass_rate
        for item in evidence.slices
    ):
        regressions.append("quality-pass-rate")

    violations = tuple(readiness + regressions)
    if regressions:
        decision = "FAIL_LOAD_TEST"
    elif readiness:
        decision = "HOLD_INCOMPLETE"
    else:
        decision = "PASS_LOAD_TEST"
    evidence_id = digest(
        {
            "contract": contract.content_id,
            "evidence": evidence.content_id,
            "decision": decision,
            "violations": violations,
        }
    )
    return LoadTestReport(
        decision,
        violations,
        len(evidence.slices),
        total_requests,
        worst_ttft,
        worst_e2e,
        error_rate,
        cancellation_leak_rate,
        retry_amplification,
        quality_pass_rate,
        evidence_id,
    )


def illustrative_fixture():
    contract = LoadTestContract()
    slices = []
    for bucket_index, bucket in enumerate(contract.required_sequence_buckets):
        for pattern_index, pattern in enumerate(contract.required_traffic_patterns):
            for cache_state in contract.required_cache_states:
                cold_penalty = 20.0 if cache_state == "cold" else 0.0
                slices.append(
                    SliceResult(
                        contract.scope,
                        "synthetic-run-2026-09",
                        "service-v12",
                        bucket,
                        pattern,
                        cache_state,
                        1_000,
                        970,
                        5,
                        25,
                        0,
                        20,
                        100,
                        98,
                        300.0
                        + bucket_index * 50.0
                        + pattern_index * 10.0
                        + cold_penalty,
                        1_200.0
                        + bucket_index * 300.0
                        + pattern_index * 100.0
                        + cold_penalty * 5.0,
                        True,
                    )
                )
    evidence = LoadTestEvidence(
        contract.scope,
        contract.content_id,
        digest(
            {
                "buckets": contract.required_sequence_buckets,
                "patterns": contract.required_traffic_patterns,
                "cache": contract.required_cache_states,
            }
        ),
        2_026_092_600,
        0.25,
        tuple(slices),
    )
    return contract, evidence


def main():
    contract, evidence = illustrative_fixture()
    report = audit_load_test(contract, evidence)
    print("example=illustrative_only")
    print(f"decision={report.decision}")
    print(f"slices={report.slice_count};requests={report.request_count}")
    print(
        f"worst_ttft_ms={report.worst_p95_ttft_ms:.3f};"
        f"worst_e2e_ms={report.worst_p99_e2e_ms:.3f}"
    )
    print(
        f"error_rate={report.error_rate:.3f};"
        f"cancel_leak_rate={report.cancellation_leak_rate:.3f}"
    )
    print(
        f"retry_amplification={report.retry_amplification:.3f};"
        f"quality_pass_rate={report.quality_pass_rate:.3f}"
    )
    print(f"claim={report.claim}")


if __name__ == "__main__":
    main()