#!/usr/bin/env python3
"""Python 3.9+, stdlib only. Synthetic evidence decisions, not a location test.

No network, DNS, browser, credentials, accounts, or configuration changes.
Contract versions and five-minute window are invented demonstration rules.
"""
from dataclasses import dataclass, replace
from datetime import datetime, timedelta
import re


@dataclass(frozen=True)
class Contract:
    authority: str
    expected: str
    job: str = "job-7"
    step: str = "product"
    source: str = "sample-store"
    schema: str = "market-country-v1"
    version: str = "release-A"
    start: str = "2026-11-18T02:00:00+00:00"
    end: str = "2026-11-18T02:05:00+00:00"


@dataclass(frozen=True)
class Evidence:
    name: str
    value: object
    job: str = "job-7"
    step: str = "product"
    trace: str = "trace-a"
    egress_trace: str = "trace-a"
    source: object = "sample-store"
    schema: object = "market-country-v1"
    version: object = "release-A"
    at: object = "2026-11-18T02:02:00+00:00"
    requested_route: str = "CA"
    account_locale: str = "en-GB"
    secondary_country: object = "CA"


def country(value):
    if not isinstance(value, str) or not re.fullmatch(r"[A-Z]{2}", value):
        raise ValueError("Use an uppercase two-letter country label; None is missing evidence")


def utc(value):
    if not isinstance(value, str):
        raise ValueError("Timestamp must be an ISO string")
    try:
        parsed = datetime.fromisoformat(value)
    except ValueError:
        raise ValueError("Invalid ISO timestamp")
    if parsed.tzinfo is None or parsed.utcoffset() != timedelta(0):
        raise ValueError("Timestamp must explicitly use UTC")
    return parsed


def decide(contract, evidence):
    if contract.authority not in {"rendered_market", "database_country"}:
        raise ValueError("Unknown authority: choose the task before collecting evidence")
    country(contract.expected)
    country(evidence.requested_route)
    for value in (evidence.value, evidence.secondary_country):
        if value is not None:
            country(value)
    start, end = utc(contract.start), utc(contract.end)
    if start >= end:
        raise ValueError("Invalid contract window")
    if not all(isinstance(v, str) and v.strip() for v in
               (contract.job, contract.step, contract.source, contract.schema, contract.version)):
        raise ValueError("Contract identity, source, schema and version are required")
    required = (evidence.value, evidence.source, evidence.schema, evidence.version,
                evidence.at, evidence.job, evidence.step, evidence.trace, evidence.egress_trace)
    if any(v is None or v == "" for v in required):
        return "HOLD_MISSING_EVIDENCE"
    comparable = (
        evidence.job == contract.job and evidence.step == contract.step
        and evidence.trace == evidence.egress_trace
        and evidence.source == contract.source and evidence.schema == contract.schema
        and evidence.version == contract.version
        and start <= utc(evidence.at) <= end
    )
    if not comparable:
        return "HOLD_NOT_COMPARABLE"
    if evidence.value != contract.expected:
        return "HOLD_REQUIREMENT_MISMATCH"
    if (contract.authority == "rendered_market"
            and evidence.secondary_country is not None
            and evidence.secondary_country != evidence.requested_route):
        return "ACCEPT_SAMPLE_ONLY_WITH_SECONDARY_REVIEW"
    return "ACCEPT_SAMPLE_ONLY"


PAGE = Contract(authority="rendered_market", expected="CA")
DB = Contract(authority="database_country", expected="CA",
              source="sample-db", schema="country-code-v1", version="db-20261118")
BASE = Evidence(name="G-01", value="CA")
DB_ROW = replace(BASE, source=DB.source, schema=DB.schema, version=DB.version)
CASES = (
    (PAGE, BASE, "ACCEPT_SAMPLE_ONLY"),
    (PAGE, replace(BASE, name="G-02", secondary_country="US"),
     "ACCEPT_SAMPLE_ONLY_WITH_SECONDARY_REVIEW"),
    (PAGE, replace(BASE, name="G-03", requested_route="US", secondary_country="US",
                   account_locale="en-US"), "ACCEPT_SAMPLE_ONLY"),
    (PAGE, replace(BASE, name="G-04", value=None), "HOLD_MISSING_EVIDENCE"),
    (DB, replace(DB_ROW, name="G-05", value="US"), "HOLD_REQUIREMENT_MISMATCH"),
    (DB, replace(DB_ROW, name="G-06", version="db-20261001"), "HOLD_NOT_COMPARABLE"),
    (PAGE, replace(BASE, name="G-07", job="different-job"), "HOLD_NOT_COMPARABLE"),
    (PAGE, replace(BASE, name="G-08", at="2026-11-18T02:06:00+00:00"),
     "HOLD_NOT_COMPARABLE"),
)


def verify():
    for contract, evidence, expected in CASES:
        assert decide(contract, evidence) == expected, evidence.name
    assert decide(PAGE, replace(BASE, egress_trace="other-trace")) == "HOLD_NOT_COMPARABLE"
    assert decide(PAGE, replace(BASE, source=None)) == "HOLD_MISSING_EVIDENCE"
    assert decide(DB, DB_ROW) == "ACCEPT_SAMPLE_ONLY"
    assert decide(PAGE, replace(BASE, value="US")) == "HOLD_REQUIREMENT_MISMATCH"
    # Context cannot replace the authoritative observation.
    assert decide(PAGE, replace(BASE, value=None, secondary_country="CA")) == "HOLD_MISSING_EVIDENCE"
    for contract, evidence in (
        (replace(PAGE, authority="majority_vote"), BASE),
        (PAGE, replace(BASE, value="garbage")),
        (PAGE, replace(BASE, at="2026-11-18T02:02:00")),
        (PAGE, replace(BASE, at="2026-11-18T02:02:00+01:00")),
    ):
        try:
            decide(contract, evidence)
        except ValueError:
            pass
        else:
            raise AssertionError("Invalid input accepted")


if __name__ == "__main__":
    verify()
    for contract, evidence, _ in CASES:
        print(evidence.name + ": " + decide(contract, evidence))
    print("PASS: eight synthetic cases and focused counterexamples; no live trial performed.")
