"""Python 3.10+, standard library only. Local synthetic provider; no email/API."""
import hashlib
import json
import sqlite3
import tempfile
from pathlib import Path


def digest(payload):
    return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()


def open_db(path):
    db = sqlite3.connect(path)
    db.execute("CREATE TABLE IF NOT EXISTS operations (id TEXT PRIMARY KEY, hash TEXT, state TEXT)")
    db.commit()
    return db


def execute(local, provider, key, payload, approval, allowed=True, paid=False,
            crash_after_send=False, lookup_available=True):
    # Recheck current authority and business preconditions on every resume.
    if not allowed or paid or approval != digest(payload):
        return "blocked"
    row = local.execute("SELECT hash,state FROM operations WHERE id=?", (key,)).fetchone()
    if row and row[0] != digest(payload):
        return "blocked"
    if row and row[1] == "accepted":
        return "accepted"
    if row and row[1] == "dispatching" and not lookup_available:
        return "unknown"
    # The mock provider durably supports lookup and a unique idempotency key.
    prior = provider.execute("SELECT hash FROM operations WHERE id=?", (key,)).fetchone()
    if prior and prior[0] != digest(payload):
        return "blocked"
    if not prior:
        local.execute("INSERT OR REPLACE INTO operations VALUES (?,?,?)",
                      (key, digest(payload), "dispatching"))
        local.commit()
        provider.execute("INSERT INTO operations VALUES (?,?,?)",
                         (key, digest(payload), "accepted"))
        provider.commit()
        if crash_after_send:
            raise RuntimeError("simulated crash after provider acceptance")
    local.execute("INSERT OR REPLACE INTO operations VALUES (?,?,?)",
                  (key, digest(payload), "accepted"))
    local.commit()
    return "accepted"


def main():
    with tempfile.TemporaryDirectory() as directory:
        root = Path(directory)
        local = open_db(root / "local.sqlite")
        provider = open_db(root / "provider.sqlite")
        payload = {"recipient": "customer@example.test", "invoice": "INV-42", "body": "Reminder"}
        approval = digest(payload)
        try:
            execute(local, provider, "tenant-A:INV-42:reminder-1", payload, approval,
                    crash_after_send=True)
        except RuntimeError:
            pass
        local.close()  # Reopen durable local state after the simulated crash.
        local = open_db(root / "local.sqlite")
        key = "tenant-A:INV-42:reminder-1"
        assert execute(local, provider, key, payload, approval, lookup_available=False) == "unknown"
        assert execute(local, provider, key, payload, approval) == "accepted"
        assert execute(local, provider, key, payload, approval) == "accepted"
        assert execute(local, provider, "new", payload, approval, allowed=False) == "blocked"
        assert execute(local, provider, "new", payload, approval, paid=True) == "blocked"
        changed = {**payload, "recipient": "other@example.test"}
        assert execute(local, provider, "new", changed, approval) == "blocked"
        count = provider.execute("SELECT count(*) FROM operations").fetchone()[0]
        assert count == 1
        print("checks=7 provider_acceptances=1 local_state=accepted")
        local.close()
        provider.close()


if __name__ == "__main__":
    main()
