"""Immutable preflight, UUID single-worker queues, and event-driven receipts."""
from pathlib import Path
import argparse
import ctypes
import json
import os
import select
import subprocess
import sys
import time

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT))


def queue(route, output):
    from pallet.mask_model_improvement import CONFIGS
    from pallet.mask_model_training_data import GPU_UUIDS, write, read
    names = [k for k, v in CONFIGS.items() if v['route'] == route]
    write(output/f'queue_{route}_start.json', dict(pid=os.getpid(), route=route, runs=names,
        cuda_visible_devices=GPU_UUIDS[route], sequential=True, max_updates_per_run=1000))
    completed = []
    for name in names:
        env = dict(os.environ, CUDA_VISIBLE_DEVICES=GPU_UUIDS[route],
                   OMP_NUM_THREADS='4', MKL_NUM_THREADS='4', PYTHONUNBUFFERED='1', TMPDIR='/tmp/opencode')
        log = output/f'{name}.log'
        with log.open('xb') as stream:
            process = subprocess.Popen([sys.executable, str(Path(__file__).resolve()), 'worker', name,
                '--output', str(output)], env=env, stdout=stream, stderr=subprocess.STDOUT)
            write(output/f'{name}_process.json', dict(pid=process.pid, route=route, name=name,
                cuda_visible_devices=GPU_UUIDS[route], log=str(log.relative_to(PROJECT))))
            code = process.wait()  # kernel process exit, never status/log polling
        completed.append(dict(name=name, returncode=code,
            state='completed' if code == 0 else 'failed_evidence_retained'))
        print(json.dumps(completed[-1]), flush=True)
        if code:
            # Do not change code, restart silently, or launch downstream variants
            # after a failed anchor. A fresh version requires an explicit fix.
            write(output/f'queue_{route}_completion.json', dict(state='blocked_failed_run', runs=completed,
                unstarted=names[len(completed):]))
            return code
    write(output/f'queue_{route}_completion.json', dict(state='completed_all_bounded_runs', runs=completed))
    return 0


def wait_receipt(output, names):
    """Linux inotify create/close events; no sleep/repeated status polling."""
    libc = ctypes.CDLL(None, use_errno=True)
    libc.inotify_init1.argtypes = [ctypes.c_int]; libc.inotify_init1.restype = ctypes.c_int
    libc.inotify_add_watch.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_uint32]
    libc.inotify_add_watch.restype = ctypes.c_int
    descriptor = libc.inotify_init1(os.O_CLOEXEC)
    if descriptor < 0:
        raise OSError(ctypes.get_errno(), 'inotify initialization failed')
    watched = set()
    def watch(path):
        if path in watched:
            return
        if libc.inotify_add_watch(descriptor, os.fsencode(path), 0x00000100 | 0x00000080 | 0x00000008) < 0:
            raise OSError(ctypes.get_errno(), 'inotify watch failed')
        watched.add(path)
    try:
        watch(output)
        while True:
            receipts = {}
            for name in names:
                directory = output/name
                if directory.is_dir():
                    watch(directory)
                failure = directory/'failure.json'
                receipt = directory/'first_actual_training_batch.json'
                if failure.is_file():
                    raise RuntimeError(f'Run failed: {failure.read_text()}')
                if receipt.is_file():
                    # Ignore intermediate open-write events; CLOSE_WRITE
                    # provides complete immutable receipt data on next event.
                    try:
                        receipts[name] = json.loads(receipt.read_text())
                    except json.JSONDecodeError:
                        pass
            if len(receipts) == len(names):
                print(json.dumps(dict(state='both_actual_optimizer_steps_received', runs=receipts)), flush=True)
                return
            select.select([descriptor], [], [])
            os.read(descriptor, 65536)
    finally:
        os.close(descriptor)


def finalize(output):
    from pallet.mask_model_improvement_data import audit_after
    from pallet.mask_model_training_data import read, write, digest
    from pallet.mask_model_improvement import CONFIGS
    queues = {r: read(output/f'queue_{r}_completion.json') for r in ('m1', 'm2')}
    runs = {}
    for name in CONFIGS:
        complete = output/name/'completion.json'
        if complete.is_file():
            runs[name] = dict(completion=read(complete), completion_sha256=digest(complete),
                             dev=read(output/name/'dev_quality.json'), calibration=read(output/name/'calibration_quality.json'))
        else:
            failure = output/name/'failure.json'
            runs[name] = dict(state='failed_or_not_started', failure=read(failure) if failure.exists() else None)
    preservation = audit_after(output)
    result = dict(state='bounded_screen_finished_not_release', queues=queues, runs=runs,
        preservation=preservation, production_activated=False, official_val_test_predictions=0,
        frozen_source='v10 raw events; later human changes remain history, never training append',
        accepted_quality=None, production_deliveries=0,
        followup='No A4/A5/new seeds without completed-screen candidate gate; no quality threshold relaxation')
    write(output/'FINAL_HANDOFF.json', result)
    print(json.dumps(dict(state=result['state'], runs={k: v.get('completion', {}).get('actual_optimizer_updates') for k, v in runs.items()},
                         production_activated=False)), flush=True)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('command', choices=['queue', 'worker', 'declare', 'wait-start', 'finalize'])
    parser.add_argument('name', nargs='?')
    parser.add_argument('--output', type=Path)
    parser.add_argument('--wait-pid', type=int, action='append', default=[])
    args = parser.parse_args()
    from pallet.mask_model_improvement_data import OUTPUT
    output = (args.output or OUTPUT).resolve()
    if args.wait_pid:
        # Proven ctypes fallback works even when this Python omits os.pidfd_open.
        from verify_mask_model_training_history_v2 import wait_for_process_exit
        for pid in args.wait_pid:
            wait_for_process_exit(pid)
    if args.command == 'queue':
        return queue(args.name, output)
    if args.command == 'worker':
        from pallet.mask_model_improvement import worker
        worker(args.name, output)
    elif args.command == 'declare':
        from pallet.mask_model_improvement import predeclare
        predeclare(output)
    elif args.command == 'wait-start':
        wait_receipt(output, ['A0', 'B0'])
    elif args.command == 'finalize':
        finalize(output)
    return 0


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