"""Read-only synthetic stock handoff. Python 3.9+, no dependencies or API calls.
python3 checkpoint_demo.py prepare
python3 checkpoint_demo.py validate result.json
python3 checkpoint_demo.py self-test
"""
import copy, hashlib, json, pathlib, sys, tempfile

ROWS = [
    {"sku": "DEMO-001", "available": 7, "target": 10},
    {"sku": "DEMO-002", "available": 15, "target": 12},
    {"sku": "DEMO-003", "available": 0, "target": 4},
]
def digest(value):
    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode()).hexdigest()

def checkpoint(rows):
    return {
        "schema_version": 1, "task_id": "synthetic-stock-20261110",
        "objective": "Report shortage=max(target-available,0) for every SKU. Do not place orders.",
        "source": {"kind": "synthetic fixture", "sha256": digest(rows)},
        "completed": [{"operation_id": "read-stock-1", "operation": "read_stock",
                       "status": "verified", "result": rows, "result_sha256": digest(rows)}],
        "pending": ["Produce all three SKU shortage rows", "Pass independent validator"],
        "side_effects": [], "constraints": ["No orders", "No external writes", "Keep all SKU IDs"],
    }

def verify_checkpoint(cp, rows):
    if cp.get("schema_version") != 1 or cp.get("source", {}).get("sha256") != digest(rows):
        raise ValueError("Source or schema mismatch")
    done = cp.get("completed", [])
    if len(done) != 1 or done[0].get("operation_id") != "read-stock-1":
        raise ValueError("Unexpected completed-operation ledger")
    op = done[0]
    if op.get("status") != "verified" or op.get("operation") != "read_stock":
        raise ValueError("Unverified tool operation")
    if op.get("result") != rows or op.get("result_sha256") != digest(rows):
        raise ValueError("Tool result changed")
    if cp.get("side_effects") != []:
        raise ValueError("Unexpected side effect")

def validate(result, rows):
    if not isinstance(result, dict) or set(result) != {"rows"} or not isinstance(result["rows"], list):
        raise ValueError("Expected exactly one rows array")
    expected = {r["sku"]: max(r["target"] - r["available"], 0) for r in rows}
    found = {}
    for item in result["rows"]:
        if not isinstance(item, dict) or set(item) != {"sku", "shortage"}:
            raise ValueError("Unexpected row fields")
        if not isinstance(item["sku"], str) or item["sku"] in found:
            raise ValueError("Invalid or duplicate SKU")
        if type(item["shortage"]) is not int:
            raise ValueError("Shortage must be an integer, not a string or boolean")
        found[item["sku"]] = item["shortage"]
    if found != expected:
        raise ValueError("Missing, extra, or incorrect SKU result")
    return {"accepted": True, "rows": len(found), "total_shortage": sum(found.values())}

def handoff(cp):
    return ("Resume this read-only task from verified application state. Do not claim access to prior reasoning. "
            "Do not call tools or place orders. Return only a JSON object with key rows, containing every "
            "SKU and integer shortage. No Markdown. Checkpoint:\n" + json.dumps(cp))

def self_test():
    cp = checkpoint(ROWS); verify_checkpoint(cp, ROWS)
    good = {"rows": [{"sku": r["sku"], "shortage": max(r["target"]-r["available"], 0)} for r in ROWS]}
    validate(good, ROWS); passed = ["valid checkpoint", "valid result"]
    variants = []
    for label in ["missing SKU", "duplicate SKU", "wrong quantity", "string quantity", "boolean quantity", "extra SKU"]:
        bad=copy.deepcopy(good)
        if label=="missing SKU":bad["rows"].pop()
        elif label=="duplicate SKU":bad["rows"].append(copy.deepcopy(bad["rows"][0]))
        elif label=="wrong quantity":bad["rows"][0]["shortage"]=99
        elif label=="string quantity":bad["rows"][0]["shortage"]="3"
        elif label=="boolean quantity":bad["rows"][0]["shortage"]=True
        else:bad["rows"].append({"sku":"UNKNOWN","shortage":0})
        variants.append((label,bad))
    for label,bad in variants:
        try:validate(bad, ROWS)
        except ValueError:passed.append("reject "+label)
        else:raise AssertionError(label)
    for label in ["changed source", "changed result", "unverified operation", "unexpected side effect"]:
        bad=copy.deepcopy(cp)
        if label=="changed source":bad["source"]["sha256"]="wrong"
        elif label=="changed result":bad["completed"][0]["result"]=[]
        elif label=="unverified operation":bad["completed"][0]["status"]="pending"
        else:bad["side_effects"]=["order"]
        try:verify_checkpoint(bad, ROWS)
        except ValueError:passed.append("reject "+label)
        else:raise AssertionError(label)
    print(json.dumps({"passed": passed, "scope":"Local synthetic checks, no model calls"},indent=2))

if __name__=="__main__":
    command=sys.argv[1] if len(sys.argv)>1 else "self-test"
    if command=="self-test":self_test()
    elif command=="prepare":
        cp=checkpoint(ROWS);verify_checkpoint(cp, ROWS)
        for name,value in [("checkpoint.json",json.dumps(cp,indent=2)),("handoff.txt",handoff(cp))]:
            with pathlib.Path(name).open("x") as f:f.write(value)
        print("Created checkpoint.json and handoff.txt; synthetic inputs, no model response.")
    elif command=="validate":
        cp=json.loads(pathlib.Path("checkpoint.json").read_text());verify_checkpoint(cp, ROWS)
        print(json.dumps(validate(json.loads(pathlib.Path(sys.argv[2]).read_text()),ROWS)))
    else:raise SystemExit("Use prepare, validate result.json, or self-test")