"""Freeze session judgments before separately reading reference labels. No API calls."""
import argparse
import hashlib
import json
import sys
from collections import Counter
from datetime import datetime, timezone
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
import benchmark_gpt6_astra as runner

ROOT = Path('gpt6-reassemble40/results/codex-session')


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


def write_new(path, value):
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open('x', encoding='utf-8') as f:
        json.dump(value, f, ensure_ascii=False, indent=2)
        f.write('\n')


def freeze():
    source = ROOT / 'judgments.json'
    records = json.loads(source.read_text())
    assert sorted(r['n'] for r in records) == list(range(31, 71))
    prepared = []
    files = {'judgments.json': digest(source)}
    for r in records:
        cid = f"case_{r['n']:03d}"
        instruction, meta, _ = runner.load_case(
            Path('gpt6-reassemble40/benchmark/cases') / cid
        )
        times, _ = runner.choose_timestamps(meta, 3, 2, 1, 30, 900)
        overview = [times[i] for i in sorted({round(i*(len(times)-1)/7) for i in range(8)})]
        viewed = overview + (times[-3:] if r.get('supplement') == 'tail' else [])
        assert r['verdict'] in ('success', 'failure', 'uncertain')
        assert 0 <= r['confidence'] <= 1
        for ev in r['evidence']:
            assert ev['camera'] in ('main', 'wrist', 'external_2')
            assert ev['timestamp_s'] in viewed, (cid, ev, viewed)
        sheets = [f'evidence/{cid}_overview_00.jpg']
        if r.get('supplement') == 'tail':
            sheets.append(f'evidence/{cid}_tail_00.jpg')
        for name in sheets:
            files[name] = digest(ROOT / name)
        prepared.append((cid, dict(r, case_id=cid, instruction=instruction,
            evaluation_mode='codex_session_visual_review',
            overview_timestamps_s=overview,
            native_tail_timestamps_s=times[-3:] if r.get('supplement') == 'tail' else [],
            viewed_sheets=sheets)))
    for cid, record in prepared:
        name = f'cases/{cid}.json'
        write_new(ROOT / name, record)
        files[name] = digest(ROOT / name)
    manifest = {
        'benchmark': 'JudgerBench40', 'case_count': 40,
        'evaluation_mode': 'codex_session_visual_review',
        'requested_session_model': 'Astra (user-selected Codex session)',
        'independently_verified_api_model_snapshot': None,
        'external_judgment_api_calls': 0,
        'codex_session_cost_and_tokens': None,
        'strict_blind_evaluation': False,
        'limitations': [
            'Existing conversation contains previous labels/discussions; not an isolated blind evaluation.',
            'Judgments use contact sheets extracted from videos, not native continuous-video ingestion.',
            '8 overview timepoints per case at 320x240 per view; selected cases have 3 native 640x480 tail frames per view; JPEG quality 95.',
            'Adaptive review within a shared session differs from independent API requests and their full sampling.',
            'Confidence is subjective and uncalibrated. No model training or parameter updates occurred.',
            'Within this review, judgments were saved before loading the reference-label file for comparison.'
        ],
        'reference_rubric_sha256': hashlib.sha256(runner.SYSTEM_PROMPT.encode()).hexdigest(),
        'rubric_use': 'Session followed the existing rubric; not a verbatim isolated API prompt replay.',
        'counts': dict(Counter(r['verdict'] for r in records)),
        'frozen_at_utc': datetime.now(timezone.utc).isoformat(),
        'sha256': files,
    }
    write_new(ROOT / 'freeze_manifest.json', manifest)
    print(json.dumps({k:v for k,v in manifest.items() if k != 'sha256'}, ensure_ascii=False, indent=2))


def compare():
    manifest = json.loads((ROOT / 'freeze_manifest.json').read_text())
    for name, expected in manifest['sha256'].items():
        assert digest(ROOT / name) == expected, f'Frozen artifact changed: {name}'
    reference = Path('gpt6-reassemble40/benchmark/ground_truth/labels.jsonl')
    labels = {r['case_id']: r for r in
              (json.loads(line) for line in reference.read_text().splitlines() if line.strip())}
    rows = []
    for n in range(31, 71):
        cid = f'case_{n:03d}'
        r = json.loads((ROOT / f'cases/{cid}.json').read_text())
        rows.append(dict(case_id=cid, instruction=r['instruction'],
            reference_outcome=labels[cid]['outcome'], prediction=r['verdict'],
            matches_reference=r['verdict'] == labels[cid]['outcome'],
            confidence=r['confidence'], summary=r['summary']))
    counts = Counter((r['reference_outcome'], r['prediction']) for r in rows)
    tp, fp = counts['success', 'success'], counts['failure', 'success']
    tn, fn = counts['failure', 'failure'], counts['success', 'failure']
    uncertain = sum(r['prediction'] == 'uncertain' for r in rows)
    precision = tp / (tp+fp) if tp+fp else None
    recall = tp / sum(r['reference_outcome'] == 'success' for r in rows)
    result = dict(case_count=len(rows), exact_matches=tp+tn,
        overall_reference_agreement=(tp+tn)/len(rows),
        decided_reference_agreement=(tp+tn)/(len(rows)-uncertain),
        decision_coverage=(len(rows)-uncertain)/len(rows),
        success_precision=precision, success_recall=recall,
        success_f1=2*precision*recall/(precision+recall),
        tp=tp, tn=tn, fp=fp, fn=fn, uncertain=uncertain,
        reference_sha256=digest(reference),
        reference_status_counts=dict(Counter(r['annotation_status'] for r in labels.values())),
        compared_at_utc=datetime.now(timezone.utc).isoformat(),
        caveat='Agreement with source labels, not independently adjudicated accuracy; not a strict blind API benchmark.',
        discrepancies=[r for r in rows if not r['matches_reference']], rows=rows)
    write_new(ROOT / 'comparison.json', result)
    print(json.dumps({k:v for k,v in result.items() if k != 'rows'}, ensure_ascii=False, indent=2))


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--compare', action='store_true')
    args = parser.parse_args()
    compare() if args.compare else freeze()