"""Run only against a disposable PostgreSQL container with no published port.

Usage: python3 experiment.py --container dreamtsoft-editorial-locks-20261120
Requires Docker CLI and psql inside that container; Python standard library only.
No AI, public-network requests, timing benchmark or PgBouncer process.
"""
import argparse
import json
import re
import subprocess


class Session:
    def __init__(self, container):
        self.process = subprocess.Popen(
            ['docker', 'exec', '-i', container, 'psql', '-XAtq', '-v', 'ON_ERROR_STOP=1', '-U', 'postgres'],
            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
        )
        self.query("SET statement_timeout = '5s';")

    def query(self, sql):
        self.process.stdin.write(sql + '\n\\echo __LAB_END__\n')
        self.process.stdin.flush()
        rows = []
        while True:
            line = self.process.stdout.readline()
            if not line:
                raise RuntimeError('Disposable lab session ended unexpectedly: ' + repr(rows))
            line = line.strip()
            if line == '__LAB_END__':
                return rows
            if line and not line.startswith('WARNING:'):
                rows.append(line)

    def boolean(self, sql):
        rows = self.query(sql)
        assert len(rows) == 1 and rows[0] in {'t', 'f'}, rows
        return rows[0] == 't'

    def close(self):
        if self.process.poll() is None:
            self.process.stdin.write('\\q\n')
            self.process.stdin.flush()
            self.process.stdin.close()
            self.process.wait(timeout=10)
        assert self.process.returncode == 0


def run(container):
    a, b = Session(container), Session(container)
    rows = []
    key = 73475001
    try:
        version = a.query('SHOW server_version;')[0]
        assert a.query('SELECT pg_backend_pid();') != b.query('SELECT pg_backend_pid();')
        for count in range(1, 5):
            for _ in range(count):
                assert a.boolean(f'SELECT pg_try_advisory_lock({key});')
            visible = int(a.query("SELECT count(*) FROM pg_locks WHERE pid=pg_backend_pid() AND locktype='advisory';")[0])
            assert visible == 1
            assert not b.boolean(f'SELECT pg_try_advisory_lock({key});')
            checkpoints = []
            for step in range(1, count + 1):
                assert a.boolean(f'SELECT pg_advisory_unlock({key});')
                acquired = b.boolean(f'SELECT pg_try_advisory_lock({key});')
                checkpoints.append(acquired)
                assert acquired == (step == count)
                if acquired:
                    assert b.boolean(f'SELECT pg_advisory_unlock({key});')
            rows.append(dict(case='session_stack', acquisitions=count, releaseOperations=count,
                             visibleLockRows=visible, contenderAfterEachRelease=checkpoints))
            a.query('BEGIN;')
            for _ in range(count):
                assert a.boolean(f'SELECT pg_try_advisory_xact_lock({key});')
            assert not b.boolean(f'SELECT pg_try_advisory_lock({key});')
            a.query('COMMIT;')
            assert b.boolean(f'SELECT pg_try_advisory_lock({key});')
            assert b.boolean(f'SELECT pg_advisory_unlock({key});')
            rows.append(dict(case='transaction_stack', acquisitions=count, releaseOperations=1,
                             contenderAfterCommit=True))
        a.query('BEGIN;')
        assert a.boolean(f'SELECT pg_try_advisory_lock({key});')
        a.query('ROLLBACK;')
        assert not b.boolean(f'SELECT pg_try_advisory_lock({key});')
        assert a.boolean(f'SELECT pg_advisory_unlock({key});')
        rows.append(dict(case='session_rollback', contenderAfterRollback=False))
        a.query('BEGIN;')
        assert a.boolean(f'SELECT pg_try_advisory_xact_lock({key});')
        a.query('ROLLBACK;')
        assert b.boolean(f'SELECT pg_try_advisory_lock({key});')
        assert b.boolean(f'SELECT pg_advisory_unlock({key});')
        rows.append(dict(case='transaction_rollback', contenderAfterRollback=True))
        assert a.boolean(f'SELECT pg_try_advisory_lock({key});')
        wrong = b.boolean(f'SELECT pg_advisory_unlock({key});')
        assert not wrong and not b.boolean(f'SELECT pg_try_advisory_lock({key});')
        assert a.boolean(f'SELECT pg_advisory_unlock({key});')
        rows.append(dict(case='wrong_backend_unlock', unlockReturned=False, contenderEntered=False))
        assert a.boolean(f'SELECT pg_try_advisory_lock({key});')
        a.query('BEGIN;')
        assert a.boolean(f'SELECT pg_advisory_unlock({key});')
        a.query('ROLLBACK;')
        assert b.boolean(f'SELECT pg_try_advisory_lock({key});')
        assert b.boolean(f'SELECT pg_advisory_unlock({key});')
        rows.append(dict(case='unlock_survives_rollback', contenderAfterRollback=True))
        assert a.boolean(f'SELECT pg_try_advisory_xact_lock({key});')
        assert b.boolean(f'SELECT pg_try_advisory_lock({key});')
        assert b.boolean(f'SELECT pg_advisory_unlock({key});')
        rows.append(dict(case='autocommit_xact', contenderAfterStatement=True))
        pid = a.query('SELECT pg_backend_pid();')[0]
        assert a.boolean(f'SELECT pg_try_advisory_lock({key});')
        # Two logical callers are represented explicitly by two uses of A.
        # No real connection pool or PgBouncer is being executed here.
        assert a.boolean(f'SELECT pg_try_advisory_lock({key});')
        assert a.query('SELECT pg_backend_pid();')[0] == pid
        assert not b.boolean(f'SELECT pg_try_advisory_lock({key});')
        assert a.boolean(f'SELECT pg_advisory_unlock({key});')
        assert a.boolean(f'SELECT pg_advisory_unlock({key});')
        rows.append(dict(case='same_backend_reused', sameBackend=True, secondLogicalCallerAcquired=True,
                         independentBackendAcquired=False, simulatedPoolReuse=True))
        assert a.boolean(f'SELECT pg_try_advisory_lock({key});')
        a.close()
        acquired = False
        for _ in range(20):
            acquired = b.boolean(f'SELECT pg_try_advisory_lock({key});')
            if acquired:
                break
        assert acquired
        assert b.boolean(f'SELECT pg_advisory_unlock({key});')
        rows.append(dict(case='session_exit', contenderAfterBackendExit=True))
        assert len(rows) == 15
        return dict(serverVersion=version,caseCount=len(rows),cases=rows,
                    scope='Two real PostgreSQL backends; simulated logical reuse; no PgBouncer or benchmark')
    finally:
        a.close()
        b.close()


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--container', required=True)
    arguments = parser.parse_args()
    if not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9_.-]*', arguments.container):
        parser.error('Provide a local disposable container name')
    print(json.dumps(run(arguments.container), indent=2, sort_keys=True))
