"""Python 3.11+, standard library. Local teaching model; never contacts a provider."""
import hashlib
import json
import sqlite3
import tempfile
from pathlib import Path


def connect(path):
    db = sqlite3.connect(path)
    db.execute('PRAGMA synchronous=FULL')
    return db


def fingerprint(order, cents):
    if type(cents) is not int or cents <= 0:
        raise ValueError('positive integer cents required')
    return hashlib.sha256(json.dumps([order, cents], separators=(',', ':')).encode()).hexdigest()


class Provider:
    """One transactional SQLite database models the external system's contract."""
    def __init__(self, path):
        self.db = connect(path)
        self.db.executescript('''
        CREATE TABLE IF NOT EXISTS refunds (
          tenant TEXT, op TEXT, digest TEXT, cents INTEGER,
          PRIMARY KEY (tenant, op));
        ''')

    def submit(self, tenant, op, digest, cents):
        # Atomic deduplication + effect, not a client-side check-then-act.
        with self.db:
            self.db.execute('BEGIN IMMEDIATE')
            old = self.db.execute('SELECT digest FROM refunds WHERE tenant=? AND op=?',
                                  (tenant, op)).fetchone()
            if old and old[0] != digest:
                raise ValueError('provider key conflict')
            if not old:
                self.db.execute('INSERT INTO refunds VALUES (?,?,?,?)',
                                (tenant, op, digest, cents))
        return {'state': 'succeeded', 'digest': digest}

    def status(self, tenant, op):
        row = self.db.execute('SELECT digest FROM refunds WHERE tenant=? AND op=?',
                              (tenant, op)).fetchone()
        return None if row is None else {'state': 'succeeded', 'digest': row[0]}

    def count(self):
        return self.db.execute('SELECT COUNT(*) FROM refunds').fetchone()[0]


class AgentExecutor:
    def __init__(self, path, provider):
        self.db, self.provider = connect(path), provider
        self.db.execute('''CREATE TABLE IF NOT EXISTS operations (
          tenant TEXT, op TEXT, digest TEXT, order_id TEXT, cents INTEGER,
          state TEXT, PRIMARY KEY(tenant,op))''')
        self.db.commit()

    def state(self, tenant, op):
        row = self.db.execute('SELECT state FROM operations WHERE tenant=? AND op=?',
                              (tenant, op)).fetchone()
        return row[0] if row else None

    def mark(self, tenant, op, state):
        with self.db:
            self.db.execute('UPDATE operations SET state=? WHERE tenant=? AND op=?',
                            (state, tenant, op))

    def execute(self, tenant, op, order, cents, *, authorized, lose_ack=False,
                crash_after_provider=False):
        digest = fingerprint(order, cents)
        row = self.db.execute('SELECT digest,state FROM operations WHERE tenant=? AND op=?',
                              (tenant, op)).fetchone()
        if row and row[0] != digest:
            raise ValueError('same operation ID with different intent')
        if row and row[1] == 'succeeded':
            return 'succeeded'
        if not row:
            if not authorized:
                return 'blocked'
            with self.db:
                self.db.execute('INSERT INTO operations VALUES (?,?,?,?,?,?)',
                                (tenant, op, digest, order, cents, 'prepared'))
        # Reconcile first, even if permission to create a new effect has expired.
        # This demo assumes a separate permission to inspect this tenant's status.
        result = self.provider.status(tenant, op)
        if result:
            if result['digest'] != digest:
                raise ValueError('status intent mismatch')
            self.mark(tenant, op, 'succeeded')
            return 'succeeded'
        if not authorized:
            return 'blocked'
        # A missing status alone is NOT proof of no effect. Safe repeat here depends
        # on Provider.submit's durable atomic idempotency contract, with no expiry.
        self.mark(tenant, op, 'submitted')
        self.provider.submit(tenant, op, digest, cents)
        if crash_after_provider:
            raise RuntimeError('injected crash after provider commit')
        if lose_ack:
            self.mark(tenant, op, 'unknown')
            return 'unknown'
        self.mark(tenant, op, 'succeeded')
        return 'succeeded'


def run():
    with tempfile.TemporaryDirectory() as folder:
        root = Path(folder)
        provider = Provider(root / 'provider.sqlite')
        client = AgentExecutor(root / 'agent.sqlite', provider)
        assert client.execute('shop', 'refund-1', 'order-7', 2500,
                              authorized=True, lose_ack=True) == 'unknown'
        assert provider.count() == 1
        client.db.close()
        client = AgentExecutor(root / 'agent.sqlite', provider)
        assert client.execute('shop', 'refund-1', 'order-7', 2500,
                              authorized=False) == 'succeeded'
        assert provider.count() == 1
        try:
            client.execute('shop', 'refund-1', 'order-7', 3000, authorized=True)
            raise AssertionError('changed intent accepted')
        except ValueError:
            pass
        assert client.execute('shop', 'refund-2', 'order-8', 500,
                              authorized=False) == 'blocked'
        try:
            client.execute('shop', 'refund-3', 'order-9', 700,
                           authorized=True, crash_after_provider=True)
        except RuntimeError:
            pass
        assert client.state('shop', 'refund-3') == 'submitted'
        client.db.close()
        client = AgentExecutor(root / 'agent.sqlite', provider)
        assert client.execute('shop', 'refund-3', 'order-9', 700,
                              authorized=True) == 'succeeded'
        # Direct duplicate delivery exercises provider-side atomic deduplication.
        d = fingerprint('order-9', 700)
        provider.submit('shop', 'refund-3', d, 700)
        assert provider.count() == 2
        # Distinct tenant namespace: same op is a different operation.
        assert client.execute('shop-2', 'refund-3', 'order-9', 700,
                              authorized=True) == 'succeeded'
        assert provider.count() == 3
        client.db.close()
        provider.db.close()
    print('PASS: lost acknowledgement, restart, conflict, expired permission, crash window, duplicate delivery, tenant namespace')
    print('effects=3; duplicate-effects=0; no network; deterministic; no random seed needed')


if __name__ == '__main__':
    run()
