#!/usr/bin/env python3
"""Synthetic, offline decision-provenance fixture; Python 3.9+ standard library."""
from __future__ import annotations

import hashlib
import json
from typing import Dict, Tuple


def canonical(value: object) -> str:
    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True)


def sha256(value: object) -> str:
    return hashlib.sha256(canonical(value).encode("utf-8")).hexdigest()


# These are declared synthetic definitions, not retrieved source data or production settings.
DEFINITIONS = {
    "rule": {
        "accept-v3": {"required": ["sku", "currency"], "outcome": "VALID"},
        "accept-v4": {"required": ["sku", "currency", "tax_basis"], "outcome": "VALID"},
    },
    "parser": {"parser-7": {"fields": ["sku", "currency"]}},
    "config": {"route-policy-2": {"route_class": "approved_read"}},
}


def definition_digest(kind: str, version: str) -> str:
    return sha256(DEFINITIONS[kind][version])


def supplied_fingerprint(kind: str, version: str) -> str:
    """Create a fixture row even when its version is deliberately unknown."""
    if version not in DEFINITIONS[kind]:
        return "unknown-version"
    return definition_digest(kind, version)


def record(job_id: str, rule: str = "accept-v3", parser: str = "parser-7",
           config: str = "route-policy-2", outcome: str = "VALID") -> Dict[str, str]:
    outcome_summary = {"job_id": job_id, "required_fields": DEFINITIONS["rule"][rule]["required"],
                       "validator_outcome": outcome}
    return {
        "job_id": job_id,
        "authorization_ref": "AUTH-SYN-24",
        "rule_version": rule,
        "rule_definition_sha256": supplied_fingerprint("rule", rule),
        "parser_version": parser,
        "parser_definition_sha256": supplied_fingerprint("parser", parser),
        "config_version": config,
        "config_definition_sha256": supplied_fingerprint("config", config),
        "outcome_claim": outcome,
        "normalized_outcome": canonical(outcome_summary),
        "outcome_summary_sha256": sha256(outcome_summary),
        "evidence_ref": "EVID-SYN-001",
        "decision": "ACCEPTED",
        "decision_owner": "synthetic-reviewer",
        "decision_time": "2026-10-01T09:00:00Z",
    }


def reconstruct(entry: object) -> Tuple[str, str]:
    """Rebuild a narrow decision explanation from declared references, fail closed."""
    if not isinstance(entry, dict):
        return "HOLD", "ledger entry is not an object"
    required = {"job_id", "authorization_ref", "rule_version", "rule_definition_sha256", "parser_version", "parser_definition_sha256",
                "config_version", "outcome_claim", "normalized_outcome", "outcome_summary_sha256",
                "config_definition_sha256", "evidence_ref", "decision", "decision_owner", "decision_time"}
    if set(entry) != required:
        return "HOLD", "ledger shape is incomplete or contains an unknown field"
    if not all(isinstance(entry[key], str) and entry[key] for key in required):
        return "HOLD", "a required ledger value is missing or not a non-empty string"
    if entry["decision"] != "ACCEPTED":
        return "HOLD", "fixture reconstructs accepted decisions only"
    if entry["rule_version"] not in DEFINITIONS["rule"]:
        return "HOLD", "missing rule definition"
    if entry["parser_version"] not in DEFINITIONS["parser"]:
        return "HOLD", "missing parser definition"
    if entry["config_version"] not in DEFINITIONS["config"]:
        return "HOLD", "missing configuration definition"
    if entry["rule_definition_sha256"] != definition_digest("rule", entry["rule_version"]):
        return "HOLD", "referenced rule definition differs from its archived fingerprint"
    if entry["parser_definition_sha256"] != definition_digest("parser", entry["parser_version"]):
        return "HOLD", "referenced parser definition differs from its archived fingerprint"
    if entry["config_definition_sha256"] != definition_digest("config", entry["config_version"]):
        return "HOLD", "referenced configuration definition differs from its archived fingerprint"
    rule = DEFINITIONS["rule"][entry["rule_version"]]
    parser = DEFINITIONS["parser"][entry["parser_version"]]
    config = DEFINITIONS["config"][entry["config_version"]]
    if rule["outcome"] != entry["outcome_claim"]:
        return "HOLD", "outcome claim does not satisfy the referenced rule"
    if set(rule["required"]) != set(parser["fields"]):
        return "HOLD", "parser field contract does not match the referenced rule"
    if config["route_class"] != "approved_read":
        return "HOLD", "configuration definition is outside this synthetic acceptance policy"
    try:
        normalized_outcome = json.loads(entry["normalized_outcome"])
    except json.JSONDecodeError:
        return "HOLD", "normalized outcome is not valid JSON"
    expected_summary = {"job_id": entry["job_id"], "required_fields": rule["required"],
                        "validator_outcome": entry["outcome_claim"]}
    if normalized_outcome != expected_summary:
        return "HOLD", "normalized outcome does not match the referenced archived rule"
    expected = sha256(expected_summary)
    if expected != entry["outcome_summary_sha256"]:
        return "HOLD", "outcome-summary digest does not match the declared synthetic summary"
    return "RECONSTRUCTED", (f"accepted under archived {entry['rule_version']} with "
                             f"{entry['parser_version']} and {entry['config_version']}")


def check(label: str, entry: object, expected: str) -> None:
    result, reason = reconstruct(entry)
    assert result == expected, (label, result, reason)
    print(f"{label}: {result} — {reason}")


def main() -> None:
    accepted = record("JOB-SYN-001")
    missing_parser = record("JOB-SYN-002", parser="parser-absent")
    config_mismatch = record("JOB-SYN-003", config="route-policy-absent")
    outcome_wrong = record("JOB-SYN-004", outcome="INVALID")
    tampered_digest = record("JOB-SYN-005")
    tampered_digest["outcome_summary_sha256"] = "0" * 64
    malformed = None
    mutated_rule = record("JOB-SYN-006")
    check("positive accepted decision", accepted, "RECONSTRUCTED")
    # This is a present-day comparison only: it does not rewrite the archived decision.
    current_rule = DEFINITIONS["rule"]["accept-v4"]
    old_fields = json.loads(accepted["normalized_outcome"])["required_fields"]
    assert set(old_fields) != set(current_rule["required"])
    print("version delta: ACCEPTED_UNDER_ARCHIVED_V3; NOT_ACCEPTED_UNDER_CURRENT_V4")
    check("negative missing parser definition", missing_parser, "HOLD")
    check("negative missing configuration definition", config_mismatch, "HOLD")
    check("negative outcome claim", outcome_wrong, "HOLD")
    check("negative mismatched outcome digest", tampered_digest, "HOLD")
    check("negative malformed ledger", malformed, "HOLD")
    archived_rule = DEFINITIONS["rule"]["accept-v3"]
    try:
        DEFINITIONS["rule"]["accept-v3"] = {
            **archived_rule, "required": [*archived_rule["required"], "tax_basis"]
        }
        check("negative changed archived rule definition", mutated_rule, "HOLD")
    finally:
        DEFINITIONS["rule"]["accept-v3"] = archived_rule
    print("PASS: synthetic fixture only; no network, files, secrets, or source payloads.")


if __name__ == "__main__":
    main()
