"""Original LockedIn Labs industry workflow proof lab. Python 3.11+, stdlib only.

All records are invented. The only write is a handoff note in scratch SQLite.
This does not contact a bank, insurer, clinician, model or application API.
Run: python3 fde-industry-proof-lab.py --domain healthcare --json
"""
import argparse
from dataclasses import asdict, dataclass, replace
import json
import sqlite3


@dataclass(frozen=True)
class Packet:
    domain: str
    workspace: str = "training-north"
    source_workspace: str = "training-north"
    review_workspace: str = "training-north"
    case_id: str = "SYNTHETIC-104"
    reviewed_case_id: str = "SYNTHETIC-104"
    case_version: int = 2
    source_version: int = 3
    reviewed_case_version: int = 2
    reviewed_source_version: int = 3
    source_kind: str = ""
    observed_state: str = ""
    proposed_note: str = ""
    reviewed_note: str = ""
    reviewer_role: str = "operations_reviewer"
    review: str = "accepted"
    request_kind: str = "status_handoff"
    event_id: str = "synthetic-event-7"


# Exercise policy, not a payer policy, legal decision table or production adapter.
POLICY = {
    "healthcare": {
        ("payer_authorization", "pending"): "awaiting_authorization",
        ("payer_authorization", "approved"): "authorization_recorded",
        ("payer_remittance", "paid"): "payment_recorded",
    },
    "finance": {
        ("dispute_case", "investigating"): "awaiting_investigation",
        ("dispute_case", "provisional_credit"): "temporary_credit_recorded",
        ("dispute_case", "final_credit"): "final_credit_recorded",
    },
}


def connect():
    db = sqlite3.connect(":memory:")
    db.execute("CREATE TABLE notes (workspace TEXT, case_id TEXT, event_id TEXT, note TEXT, case_version INTEGER, source_version INTEGER, UNIQUE(workspace, case_id, event_id))")
    return db


def publish_handoff(db, packet, *, omit_meaning_check=False):
    """Trusted fixtures stand in for server-loaded identity, source and review.

    A deployed endpoint MUST NOT accept these facts from an agent or browser.
    The in-memory, sequential lab does not prove concurrent source freshness.
    """
    trace = []

    def stop(reason):
        return {"outcome": "withheld", "reason": reason, "trace": trace, "writes": 0}

    trace.append("Check the current workspace of the source and review")
    if packet.source_workspace != packet.workspace or packet.review_workspace != packet.workspace:
        return stop("workspace_mismatch")
    trace.append("Limit this exercise to administrative status handoffs")
    if packet.request_kind != "status_handoff":
        return stop("human_specialist_required")
    trace.append("Require the expected source type and a recognized business state")
    expected = POLICY.get(packet.domain, {}).get((packet.source_kind, packet.observed_state))
    if expected is None:
        return stop("insufficient_authoritative_evidence")
    trace.append("Keep the proposed note within what the source actually establishes")
    if not omit_meaning_check and packet.proposed_note != expected:
        return stop("business_meaning_mismatch")
    trace.append("Bind an authorized review to this exact case, note and source revision")
    if packet.reviewer_role != "operations_reviewer" or packet.review != "accepted":
        return stop("review_required")
    if (packet.case_id, packet.proposed_note) != (packet.reviewed_case_id, packet.reviewed_note):
        return stop("review_content_mismatch")
    if (packet.case_version, packet.source_version) != (packet.reviewed_case_version, packet.reviewed_source_version):
        return stop("stale_review")
    trace.append("Write the private handoff once; an identical retry reuses it")
    with db:
        previous = db.execute("SELECT note, case_version, source_version FROM notes WHERE workspace=? AND case_id=? AND event_id=?", (packet.workspace, packet.case_id, packet.event_id)).fetchone()
        desired = (packet.proposed_note, packet.case_version, packet.source_version)
        if previous is not None:
            if previous != desired:
                return stop("idempotency_conflict")
            return {"outcome": "replayed", "reason": "same_handoff", "trace": trace, "writes": 0}
        db.execute("INSERT INTO notes VALUES (?,?,?,?,?,?)", (packet.workspace, packet.case_id, packet.event_id, *desired))
    return {"outcome": "recorded", "reason": "supported_handoff", "trace": trace, "writes": 1}


def base_packet(domain):
    if domain == "healthcare":
        return Packet(domain=domain, source_kind="payer_authorization", observed_state="approved", proposed_note="authorization_recorded", reviewed_note="authorization_recorded")
    if domain == "finance":
        return Packet(domain=domain, source_kind="dispute_case", observed_state="provisional_credit", proposed_note="temporary_credit_recorded", reviewed_note="temporary_credit_recorded")
    raise ValueError("Choose healthcare or finance")


def scenarios(domain):
    base = base_packet(domain)
    trap = "payment_recorded" if domain == "healthcare" else "final_credit_recorded"
    final_kind = "payer_remittance" if domain == "healthcare" else "dispute_case"
    final_state = "paid" if domain == "healthcare" else "final_credit"
    return {
        "supported": [base],
        "meaning-trap": [replace(base, proposed_note=trap, reviewed_note=trap)],
        "missing-evidence": [replace(base, source_kind="model_summary")],
        "stale-review": [replace(base, source_version=4)],
        "wrong-workspace": [replace(base, review_workspace="training-south")],
        "wrong-reviewer": [replace(base, reviewer_role="drafting_agent")],
        "specialist-question": [replace(base, request_kind="clinical_decision" if domain == "healthcare" else "dispute_adjudication")],
        "identical-retry": [base, base],
        "changed-retry": [base, replace(base, source_kind=final_kind, observed_state=final_state, proposed_note=trap, reviewed_note=trap)],
        "supported-final": [replace(base, source_kind=final_kind, observed_state=final_state, proposed_note=trap, reviewed_note=trap)],
    }


def run(domain, *, omit_meaning_check=False):
    reports = []
    for name, packets in scenarios(domain).items():
        with connect() as db:
            attempts = []
            for packet in packets:
                before = db.execute("SELECT note, case_version, source_version FROM notes ORDER BY rowid").fetchall()
                result = publish_handoff(db, packet, omit_meaning_check=omit_meaning_check)
                after = db.execute("SELECT note, case_version, source_version FROM notes ORDER BY rowid").fetchall()
                attempts.append({"input": asdict(packet), "before": before, "result": result, "after": after})
            outcomes = [attempt["result"] for attempt in attempts]
            rows = db.execute("SELECT note, case_version, source_version FROM notes ORDER BY rowid").fetchall()
        db.close()
        reports.append({"case": name, "source": {"kind": packets[0].source_kind, "state": packets[0].observed_state}, "proposal": packets[0].proposed_note, "outcomes": outcomes, "saved_notes": rows, "attempts": attempts})
    return {"domain": domain, "mode": "deliberately_broken_meaning_check" if omit_meaning_check else "guarded", "synthetic": True, "cases": reports}


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--domain", choices=["healthcare", "finance"], required=True)
    parser.add_argument("--json", action="store_true")
    parser.add_argument("--omit-meaning-check", action="store_true", help="Deliberately broken teaching comparison, scratch data only")
    args = parser.parse_args()
    report = run(args.domain, omit_meaning_check=args.omit_meaning_check)
    if args.json:
        print(json.dumps(report, indent=2))
    else:
        print(f"Synthetic {report['domain']} exercise / {report['mode']}")
        for case in report["cases"]:
            print(case["case"], [(item["outcome"], item["reason"]) for item in case["outcomes"]], "saved:", len(case["saved_notes"]))