"""Run original Node paired-source contract on a pinned agent image."""
from pathlib import Path
import argparse
import datetime
import hashlib
import json
import subprocess
import traceback
import uuid

parser = argparse.ArgumentParser()
parser.add_argument('--task-dir', required=True)
parser.add_argument('--image', required=True)
parser.add_argument('--world', choices=['all_buggy', 'all_fixed', 'candidate'], required=True)
parser.add_argument('--candidate-patches')
parser.add_argument('--output', required=True)
parser.add_argument('--prepare-only', action='store_true')
args = parser.parse_args()
T = Path(args.task_dir).resolve()
D = Path(args.output).resolve()
D.mkdir(parents=True, exist_ok=False)
HERE = Path(__file__).resolve().parent
task = json.loads((T / 'task.json').read_text())
assert task['instance_id'] == 'runtime-node-65621' and '@sha256:' in args.image
N = 'crossswe-node65621-' + args.world + '-' + uuid.uuid4().hex[:10]
S = {'state': 'PREPARING_ORIGINAL_CONTRACT', 'world': args.world, 'image': args.image, 'task_sha256': hashlib.sha256((T / 'task.json').read_bytes()).hexdigest(), 'container': N, 'slots': [], 'issues': []}


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


def put(path, value):
    path.write_text(json.dumps(value, indent=2) + '\n')


def save():
    S['updated_utc'] = datetime.datetime.now(datetime.timezone.utc).isoformat()
    put(D / 'result.json', S)


def run(label, argv, data=None, check=True):
    with (D / (label + '.stdout.raw')).open('xb') as stdout, (D / (label + '.stderr.raw')).open('xb') as stderr:
        p = subprocess.run(argv, input=data, stdout=stdout, stderr=stderr, timeout=5400)
    record = {'argv': argv, 'returncode': p.returncode, 'stdout': str(D / (label + '.stdout.raw')), 'stdout_sha256': sha(D / (label + '.stdout.raw')), 'stderr': str(D / (label + '.stderr.raw')), 'stderr_sha256': sha(D / (label + '.stderr.raw'))}
    put(D / (label + '.execution.json'), record)
    assert not check or p.returncode == 0, label
    return record


snapshot = '''from pathlib import Path
import subprocess,json,hashlib,os
rows=[]
for root in ['/testbed/nodejs/node','/testbed/nodejs/node-addon-api']:
 manifest=[]
 for raw in subprocess.check_output(['git','-C',root,'ls-files','--cached','--others','--exclude-standard','-z']).split(b'\\0'):
  if not raw:continue
  path=Path(root)/os.fsdecode(raw)
  if path.is_symlink():data=os.fsencode(os.readlink(path))
  elif path.is_file():data=path.read_bytes()
  else:continue
  manifest.append([os.fsdecode(raw),hashlib.sha256(data).hexdigest()])
 rows.append({'root':root,'head':subprocess.check_output(['git','-C',root,'rev-parse','HEAD'],text=True).strip(),'working_source_manifest_sha256':hashlib.sha256(json.dumps(manifest).encode()).hexdigest()})
print(json.dumps(rows,sort_keys=True))
'''
save()
try:
    for artifact in task['artifacts']:
        assert sha(T / artifact['path']) == artifact['sha256']
    contract = json.loads((T / 'evaluation/contract.json').read_text())
    run('create', ['docker', 'run', '-d', '--name', N, '--label', 'org.crossswe.instance=runtime-node-65621', '--network=none', '--cpus=16', '--memory=20g', '--memory-swap=20g', args.image, 'sleep', 'infinity'])
    info = json.loads(subprocess.check_output(['docker', 'inspect', N]))[0]
    put(D / 'container-inspect.json', info)
    image = json.loads(subprocess.check_output(['docker', 'image', 'inspect', args.image]))[0]
    assert info['Image'] == image['Id'] and not info['Mounts'] and info['HostConfig']['NetworkMode'] == 'none'
    S['image_id'] = image['Id']
    save()
    for repository in task['repositories']:
        root = repository['container_path']
        key = repository['key']
        assert subprocess.check_output(['docker', 'exec', '-w', root, N, 'git', 'rev-parse', 'HEAD'], text=True).strip() == repository['base_commit']
        assert not subprocess.check_output(['docker', 'exec', '-w', root, N, 'git', 'diff', '--name-only']).strip()
        if args.world == 'all_fixed':
            run('frozen-Gold-' + key, ['docker', 'exec', '-i', '-w', root, N, 'git', 'apply', '-'], (T / repository['gold_patch']['path']).read_bytes())
        elif args.world == 'candidate':
            assert args.candidate_patches
            patch = Path(args.candidate_patches) / (key + '.patch')
            if patch.exists() and patch.stat().st_size:
                run('candidate-' + key, ['docker', 'exec', '-i', '-w', root, N, 'git', 'apply', '-'], patch.read_bytes())
        for index, patch in enumerate(repository['test_patches']):
            run('frozen-test-' + key + '-' + str(index), ['docker', 'exec', '-i', '-w', root, N, 'git', 'apply', '-'], (T / patch['path']).read_bytes())
    run('trusted-material-directories', ['docker', 'exec', N, 'mkdir', '-p', '/crossrepo-patches', '/opt/crossswe-eval-resource-bin'])
    for artifact in contract['test_files']:
        run('original-helper-' + artifact['original_path'], ['docker', 'cp', str(T / artifact['path']), N + ':/crossrepo-patches/' + artifact['original_path']])
    resource = HERE / 'node-make-resource.sh'
    run('resource-only-make-scheduler', ['docker', 'cp', str(resource), N + ':/opt/crossswe-eval-resource-bin/make'])
    run('resource-only-scheduler-mode', ['docker', 'exec', N, 'chmod', '755', '/opt/crossswe-eval-resource-bin/make'])
    run('source-before-setup', ['docker', 'exec', '-i', N, 'python3', '-B', '-'], snapshot.encode())
    if args.prepare_only:
        S['state'] = 'PREPARED_ONLY_NO_TESTS_EXECUTED'
    else:
        S['state'] = 'ORIGINAL_FROZEN_SETUP_RUNNING'
        save()
        environment = ['-e', 'PATH=/opt/crossswe-eval-resource-bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin', '-e', 'CC=/usr/bin/clang-19', '-e', 'CXX=/usr/bin/clang++-19']
        for entry in sorted(contract['commands'], key=lambda item: item.get('evaluation_setup_order', 0)):
            if entry.get('evaluation_setup_command'):
                run('frozen-setup-' + entry['repository'], ['docker', 'exec', *environment, '-w', entry['container_path'], N, 'sh', '-c', entry['evaluation_setup_command']])
        run('source-after-setup', ['docker', 'exec', '-i', N, 'python3', '-B', '-'], snapshot.encode())
        assert (D / 'source-before-setup.stdout.raw').read_bytes() == (D / 'source-after-setup.stdout.raw').read_bytes(), 'frozen setup failed to restore source'
        run('actual-native-runtime-source-binding', ['docker', 'cp', N + ':/tmp/crossrepo-node-build.json', str(D / 'actual-native-runtime-build.json')])
        S['state'] = 'ORIGINAL_FOUR_SLOTS_RUNNING'
        save()
        for entry in contract['commands']:
            for phase, field in [('p2p', 'pass_to_pass'), ('f2p', 'fail_to_pass')]:
                label = entry['repository'] + '-' + phase
                execution = run(label, ['docker', 'exec', *environment, '-w', entry['container_path'], N, 'sh', '-c', entry[field]], check=False)
                events = []
                for line in Path(execution['stdout']).read_text().splitlines():
                    try:
                        event = json.loads(line)
                    except ValueError:
                        continue
                    if isinstance(event, dict):
                        events.append(event)
                cases = [row for row in events if row.get('type') == 'case']
                summaries = [row for row in events if row.get('type') == 'summary']
                expected = 8 if phase == 'p2p' else 16
                complete = len(cases) == len({row['name'] for row in cases}) == expected and all(row['mode'] == phase and row['status'] in ['pass', 'fail'] for row in cases)
                complete = complete and len(summaries) == 1 and summaries[0]['total'] == expected and summaries[0]['skipped'] == 0 and summaries[0]['failed'] == sum(row['status'] == 'fail' for row in cases)
                if not complete:
                    S['issues'].append(label + ': complete original case evidence missing')
                expected_code = 1 if any(row['status'] == 'fail' for row in cases) else 0
                if execution['returncode'] != expected_code:
                    S['issues'].append(label + ': native returncode/case outcomes disagree')
                for case in cases:
                    if case['status'] == 'fail':
                        allowed = args.world == 'all_buggy' and phase == 'f2p' and ('public C API rejects read-only arrays' in case.get('error', '') or 'public object construction overload unavailable' in case.get('error', ''))
                        if args.world != 'candidate' and not allowed:
                            S['issues'].append(label + ': failure is not the frozen base missing-public-API outcome: ' + case['name'])
                S['slots'].append({'repository': entry['repository'], 'phase': phase, 'frozen_command': entry[field], 'execution': execution, 'cases': cases, 'native_summaries': summaries, 'complete': complete})
                save()
        run('source-after-programs', ['docker', 'exec', '-i', N, 'python3', '-B', '-'], snapshot.encode())
        assert (D / 'source-after-setup.stdout.raw').read_bytes() == (D / 'source-after-programs.stdout.raw').read_bytes()
        S.update(state='FORMAL_ORIGINAL_CASES_EXECUTED_REVIEW_PENDING', source_unchanged_during_programs=True, raw_case_observations=sum(len(row['cases']) for row in S['slots']))
except BaseException:
    S['state'] = 'FORMAL_WORLD_BLOCKED'
    S['issues'].append(traceback.format_exc())
finally:
    run('final-inspect', ['docker', 'inspect', N], check=False)
    run('retire-owned-world-container', ['docker', 'rm', '-f', N], check=False)
    save()
good = S['state'] == 'PREPARED_ONLY_NO_TESTS_EXECUTED' and not S['slots'] if args.prepare_only else S['state'] == 'FORMAL_ORIGINAL_CASES_EXECUTED_REVIEW_PENDING' and not S['issues'] and len(S['slots']) == 4
print(json.dumps({'state': S['state'], 'world': args.world, 'raw_case_observations': S.get('raw_case_observations', 0), 'issues': S['issues'], 'expected_outcomes': good}))
raise SystemExit(0 if good else 1)