"""Call unchanged privacy handlers; compare literal reports and whole SQL rows."""
import argparse
from datetime import datetime, timezone
import hashlib
import inspect
import json
from pathlib import Path
import platform
import sqlite3
import sys
import tempfile

from deletion import Request, Store, buggy_delete

HERE = Path(__file__).resolve().parent
POLICY = json.loads((HERE / 'policy.json').read_text())
EXPECTED = json.loads((HERE / 'expected.json').read_text())
TARGET = POLICY['target_subject']
CONTROL = POLICY['control_subject']


def sha(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def identical(actual, expected):
    if type(actual) is not type(expected):
        return False
    if isinstance(expected, dict):
        return actual.keys() == expected.keys() and all(identical(actual[k], v) for k, v in expected.items())
    if isinstance(expected, list):
        return len(actual) == len(expected) and all(identical(a, e) for a, e in zip(actual, expected))
    return actual == expected


def observe(stores):
    return {s.name: [list(row) for row in s.connection.execute(
        'SELECT subject,value FROM records ORDER BY subject')] for s in stores}


def fingerprint(function):
    function = getattr(function, '__func__', function)
    assert Path(inspect.getsourcefile(function)).resolve() == HERE / 'deletion.py'
    return {'function': function.__qualname__, 'source_file': 'deletion.py',
            'source_sha256': sha(HERE / 'deletion.py'), 'first_source_line': function.__code__.co_firstlineno,
            'function_source_sha256': hashlib.sha256(inspect.getsource(function).encode()).hexdigest()}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--mode', choices=['baseline', 'corrected', 'swapped_report'], required=True)
    args = parser.parse_args()
    assert sha(HERE / 'deletion.py') == 'bdacf37a2c63971ced0a972e9a3022cf71d30eb12a7af9dae840dd8dce06cc9d'
    assert POLICY['destinations'] == ['profiles', 'analytics']
    rows, calls, traces = [], [], {'profiles': [], 'analytics': []}
    restore_boundary = None
    backup_rows = None
    with tempfile.TemporaryDirectory(prefix='privacy-outcome-teaching-') as directory:
        stores = []
        for name in POLICY['destinations']:
            connection = sqlite3.connect(Path(directory) / (name + '.sqlite'))
            connection.execute('CREATE TABLE records(subject TEXT PRIMARY KEY,value TEXT)')
            connection.executemany('INSERT INTO records VALUES (?,?)',
                                   [(TARGET, 'synthetic target'), (CONTROL, 'synthetic control')])
            connection.commit()
            connection.set_trace_callback(traces[name].append)
            stores.append(Store(name, connection))
        backup = sqlite3.connect(Path(directory) / 'analytics-backup.sqlite')
        try:
            initial = observe(stores)
            assert identical(initial, EXPECTED['initial_rows']), 'Literal fixture starting state not established'
            settings = {s.name: {'autocommit': getattr(s.connection, 'autocommit', 'unavailable'),
                                'isolation_level': s.connection.isolation_level,
                                'in_transaction_before_call': s.connection.in_transaction} for s in stores}

            def invoke(function, label, *arguments):
                for trace in traces.values():
                    trace.clear()
                record = {'label': label, 'callable': fingerprint(function), 'subject': TARGET,
                          'declared_store_channels': [s.name for s in stores]}
                returned = function(*arguments)
                record['returned'] = returned
                record['sql_during_call'] = {name: list(trace) for name, trace in traces.items()}
                record['in_transaction_after_call'] = {s.name: s.connection.in_transaction for s in stores}
                calls.append(record)
                return returned

            def check_step(case, returned, actual=None):
                actual = observe(stores) if actual is None else actual
                snapshot_ok = identical(returned, case['expected_snapshot'])
                row_ok = identical(actual, case['expected_rows'])
                rows.append({'id': case['id'], 'returned': returned, 'actual_rows': actual,
                             'expected_snapshot': case['expected_snapshot'], 'expected_rows': case['expected_rows'],
                             'aggregate_state_only_passed': returned.get('state') == case['expected_snapshot']['state'],
                             'typed_whole_snapshot_passed': snapshot_ok, 'typed_complete_rows_passed': row_ok,
                             'gate_passed': snapshot_ok and row_ok})

            if args.mode == 'baseline':
                stores[1].fail_next_delete = True
                returned = invoke(buggy_delete, 'buggy_partial_failure', stores, TARGET)
                actual = observe(stores)
                state_ok = identical(returned, EXPECTED['baseline']['expected_reported_state'])
                row_ok = identical(actual, EXPECTED['baseline']['expected_rows'])
                rows.append({'id': 'buggy_partial_failure', 'returned': returned,
                             'expected_reported_state': EXPECTED['baseline']['expected_reported_state'],
                             'actual_rows': actual, 'expected_rows': EXPECTED['baseline']['expected_rows'],
                             'faithful_state_passed': state_ok, 'typed_complete_rows_passed': row_ok,
                             'gate_passed': state_ok and row_ok})
            else:
                stores[1].connection.backup(backup)
                request = Request(TARGET, stores)
                stores[1].fail_next_delete = True
                returned = invoke(request.attempt, 'fixed_partial_failure')
                if args.mode == 'swapped_report':
                    actual_return = json.loads(json.dumps(returned))
                    returned = json.loads(json.dumps(returned))
                    returned['destinations']['profiles'], returned['destinations']['analytics'] = (
                        returned['destinations']['analytics'], returned['destinations']['profiles'])
                    check_step(EXPECTED['corrected'][0], returned)
                    rows[-1]['unaltered_real_return'] = actual_return
                    rows[-1]['adapter_control'] = 'Deliberately swapped destination report after real method call; aggregate left unresolved'
                else:
                    check_step(EXPECTED['corrected'][0], returned)
                    check_step(EXPECTED['corrected'][1], invoke(request.attempt, 'retry_after_recovery'))
                    check_step(EXPECTED['corrected'][2], invoke(request.attempt, 'repeat_completed_request'))
                    backup.backup(stores[1].connection)
                    restore_boundary = {'cached_request_snapshot_before_explicit_reconcile': request.snapshot(),
                                        'actual_rows_after_restore_before_reconcile': observe(stores),
                                        'automatic_restore_monitor': False}
                    check_step(EXPECTED['corrected'][3], invoke(request.reconcile, 'reconcile_after_restore'))
                    check_step(EXPECTED['corrected'][4], invoke(request.attempt, 'delete_restored_row'))
                backup_rows = [list(row) for row in backup.execute('SELECT subject,value FROM records ORDER BY subject')]
                assert identical(backup_rows, EXPECTED['backup_rows_before_cleanup'])
        finally:
            for store in stores:
                store.connection.close()
            backup.close()
    gate = all(r['gate_passed'] for r in rows)
    result = {'schema': 'privacy-outcome-literal-execution-v1', 'mode': args.mode,
              'executed_at_utc': datetime.now(timezone.utc).isoformat(),
              'runtime': {'python': platform.python_version(), 'sqlite': sqlite3.sqlite_version,
                          'implementation': platform.python_implementation(), 'platform': platform.system() + '/' + platform.machine(),
                          'optimize': sys.flags.optimize},
              'source_sha256': {name: sha(HERE / name) for name in ['deletion.py', 'policy.json', 'expected.json', 'contract.md', 'harness.py']},
              'initial_rows': initial, 'connection_settings': settings, 'calls': calls, 'observations': rows,
              'observation_count': len(rows), 'direct_handler_calls': len(calls),
              'restore_boundary_diagnostic': restore_boundary, 'backup_rows_before_temp_cleanup': backup_rows,
              'gate_passed': gate, 'legal_approval_or_compliance': 'not assessed',
              'observation_scope': 'Same live local connections; no reconnect, crash durability or every-copy erasure.'}
    print(json.dumps(result, indent=2))
    return 0 if gate else 1


if __name__ == '__main__':
    raise SystemExit(main())
