"""Fresh M2-only retry version; no changes to pinned/running M1 workers."""
from pathlib import Path
import argparse
import json
import os
import subprocess
import sys

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT))
OUTPUT = PROJECT/'outputs/pallet_mask_model_improvement_v4'


def prepare():
    import shutil
    from pallet.mask_model_improvement_data import OUTPUT as source
    from pallet.mask_model_training_data import read, write, verify_dataset, digest
    OUTPUT.mkdir(mode=0o700)
    manifest, _ = verify_dataset(source)
    # New independent copy, never hardlink mutable checkpoints/data. The entire
    # model-facing 263-mask freeze and its source bindings remain byte-identical.
    names = set(manifest['files']) | {'dataset_manifest.json', 'private/preservation_before.json',
        'private/preservation_after_freeze.json', 'private/visual_review_decisions.json',
        'private/eligibility_audit.jsonl', 'private/global_native_hashes.jsonl', 'research_permit.json'}
    for name in sorted(names):
        destination = OUTPUT/name
        destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
        shutil.copyfile(source/name, destination)
        destination.chmod(0o600)
        if digest(destination) != digest(source/name):
            raise ValueError('Copy differs: '+name)
    verify_dataset(OUTPUT)
    write(OUTPUT/'RETRY_SCOPE.json', dict(reason='RF-DETR 1.11 scheduler option belongs in lr_scheduler_kwargs',
        previous_failed_B0='outputs/pallet_mask_model_improvement_v3/B0/failure.json',
        previous_failure_sha256=digest(source/'B0/failure.json'),
        dataset_manifest_sha256=digest(source/'dataset_manifest.json'),
        model_facing_data_byte_identical=True, task_checkpoint_reused=False,
        M1_runs_remain_in='outputs/pallet_mask_model_improvement_v3',
        running_M1_code_or_data_modified=False, M2_run_names=['B0', 'B1'],
        B0_B1_model_loss_matcher_optimizer_ema_postprocess_configs_unchanged=True))


def queue():
    from pallet.mask_model_training_data import GPU_UUIDS, write
    names = ['B0', 'B1']
    write(OUTPUT/'queue_m2_start.json', dict(pid=os.getpid(), runs=names,
        cuda_visible_devices=GPU_UUIDS['m2'], fresh_generic_per_run=True))
    completed = []
    for name in names:
        env = dict(os.environ, CUDA_VISIBLE_DEVICES=GPU_UUIDS['m2'],
                   OMP_NUM_THREADS='4', MKL_NUM_THREADS='4', PYTHONUNBUFFERED='1', TMPDIR='/tmp/opencode')
        with (OUTPUT/f'{name}.log').open('xb') as stream:
            process = subprocess.Popen([sys.executable, str(Path(__file__).resolve()), 'worker', name],
                env=env, stdout=stream, stderr=subprocess.STDOUT)
            write(OUTPUT/f'{name}_process.json', dict(pid=process.pid, name=name, cuda_visible_devices=GPU_UUIDS['m2']))
            code = process.wait()
        completed.append(dict(name=name, returncode=code))
        print(json.dumps(completed[-1]), flush=True)
        if code:
            write(OUTPUT/'queue_m2_completion.json', dict(state='failed_evidence_retained', runs=completed,
                unstarted=names[len(completed):]))
            return code
    write(OUTPUT/'queue_m2_completion.json', dict(state='completed_all_bounded_runs', runs=completed))
    return 0


def finalize():
    from pallet.mask_model_training_data import read, write, digest, require, verify_dataset
    from pallet.mask_model_improvement_data import OUTPUT as m1, audit_after
    from pallet.mask_model_improvement import CONFIGS
    runs = {}
    for name, config in CONFIGS.items():
        root = m1 if config['route'] == 'm1' else OUTPUT
        complete = root/name/'completion.json'
        if complete.exists():
            completion = read(complete)
            require(digest(root/name/completion['checkpoint']) == completion['checkpoint_sha256'], 'Completed checkpoint changed')
            runs[name] = dict(root=str(root.relative_to(PROJECT)), completion=completion,
                completion_sha256=digest(complete), dev=read(root/name/'dev_quality.json'),
                calibration=read(root/name/'calibration_quality.json'))
        else:
            failure = root/name/'failure.json'
            runs[name] = dict(root=str(root.relative_to(PROJECT)), state='failed_or_not_started',
                             failure=read(failure) if failure.exists() else None)
    verify_dataset(m1); verify_dataset(OUTPUT)
    preservation = audit_after(m1)
    result = dict(state='completed_bounded_screen_not_released' if all('completion' in r for r in runs.values()) else 'partial_or_failed_not_released',
        runs=runs, preservation=preservation, immutable_data_sha256=digest(m1/'dataset_manifest.json'),
        frozen_data_identical=digest(m1/'dataset_manifest.json') == digest(OUTPUT/'dataset_manifest.json'),
        accepted_quality=None, production_deliveries=0, production_activation=False,
        formal_val_test_prediction_count=0, source='v10 raw versions, not future latest GT',
        failed_v3_B0_preserved=True, candidate_followup='No automatic A4/A5/new seeds; inspect complete group-stratified fixed-screen evidence')
    write(OUTPUT/'FINAL_HANDOFF.json', result)
    print(json.dumps(dict(state=result['state'], updates={k:v.get('completion',{}).get('actual_optimizer_updates') for k,v in runs.items()},
        dev_iou_medians={k:v.get('dev',{}).get('all',{}).get('iou_median') for k,v in runs.items()}, production_activation=False)), flush=True)


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('command', choices=['prepare', 'declare', 'queue', 'worker', 'wait-start', 'finalize'])
    parser.add_argument('name', nargs='?')
    parser.add_argument('--wait-pid', type=int, action='append', default=[])
    args = parser.parse_args()
    if args.wait_pid:
        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 == 'prepare':
        prepare()
    elif args.command == 'declare':
        from pallet.mask_model_improvement import predeclare
        predeclare(OUTPUT)
    elif args.command == 'worker':
        from pallet.mask_model_improvement_retry import config_compatibility
        from pallet.mask_model_improvement import worker
        with config_compatibility():
            worker(args.name, OUTPUT)
    elif args.command == 'queue':
        raise SystemExit(queue())
    elif args.command == 'wait-start':
        from run_mask_model_improvement import wait_receipt
        wait_receipt(OUTPUT, ['B0'])
    else:
        finalize()
