#!/usr/bin/env python3
"""Sweep all distinct first-symbol pairs in Learning Lab's tiny transformer."""
import argparse
import csv
import hashlib
import json
import math
import statistics
from datetime import datetime, timezone
from pathlib import Path

import torch
from transformer import TinyTransformer, VOCAB
from patch_transformer import run_experiment


def split(symbol, second):
    return 'validation' if (symbol + second) % 4 == 0 else 'training'


def sweep(model):
    rows=[]
    for source in range(VOCAB):
        for target in range(VOCAB):
            if source==target: continue
            for second in range(VOCAB):
                results=run_experiment(model,source,target,second)
                a,b=results['source'],results['target']
                i,e,p=results['identity'],results['patch_early'],results['patch_final']
                change=p['logit_difference']-b['logit_difference']
                rows.append({'source':source,'target':target,'second':second,
                    'source_split':split(source,second),'target_split':split(target,second),
                    'source_correct':int(a['prediction']==source),'target_correct':int(b['prediction']==target),
                    'source_logit_difference':a['logit_difference'],'target_logit_difference':b['logit_difference'],
                    'patched_logit_difference':p['logit_difference'],'patch_effect':change,
                    'identity_error':abs(i['logit_difference']-b['logit_difference']),
                    'early_error':abs(e['logit_difference']-b['logit_difference']),
                    'full_patch_error':abs(p['logit_difference']-a['logit_difference']),
                    'patched_matches_source_prediction':int(p['prediction']==a['prediction'])})
    return rows


def summarize(rows):
    if not rows: return None
    effects=[r['patch_effect'] for r in rows]
    valid=[r for r in rows if r['source_correct'] and r['target_correct']]
    def avg(key): return statistics.mean(r[key] for r in rows)
    return {'count':len(rows),'source_accuracy':avg('source_correct'),'target_accuracy':avg('target_correct'),
            'both_correct_count':len(valid),'patch_matches_source_rate':avg('patched_matches_source_prediction'),
            'patch_effect_mean':statistics.mean(effects),'patch_effect_min':min(effects),'patch_effect_max':max(effects),
            'identity_error_max':max(r['identity_error'] for r in rows),
            'early_error_max':max(r['early_error'] for r in rows),
            'full_patch_error_max':max(r['full_patch_error'] for r in rows)}


def build_report(rows,model_hash):
    groups={'all':rows,'both_training':[r for r in rows if r['source_split']==r['target_split']=='training'],
            'mixed':[r for r in rows if r['source_split']!=r['target_split']],
            'both_validation':[r for r in rows if r['source_split']==r['target_split']=='validation']}
    return {'format':'learning-lab-patching-sweep-v1','model_sha256':model_hash,
            'torch_version':str(torch.__version__),'pair_count':len(rows),
            'groups':{name:summarize(group) for name,group in groups.items()},
            'description':'Ordered distinct first-symbol pairs, same second symbol, each from 0–5. Results from one model; pairs are dependent.'}


def main():
    p=argparse.ArgumentParser(description='Undersøg alle 180 inputpar for én trænet model.')
    p.add_argument('--model',type=Path,required=True);p.add_argument('--output-dir',type=Path)
    args=p.parse_args()
    if not args.model.is_file():p.error(f'Modelfilen findes ikke: {args.model}')
    model=TinyTransformer()
    try:model.load_state_dict(torch.load(args.model,map_location='cpu',weights_only=True))
    except Exception as exc:p.error(f'Kunne ikke indlæse modelvægtene: {exc}')
    model.eval();torch.set_num_threads(1)
    model_hash=hashlib.sha256(args.model.read_bytes()).hexdigest()
    rows=sweep(model);report=build_report(rows,model_hash)
    if not all(math.isfinite(r[k]) for r in rows for k in ('patch_effect','identity_error','early_error','full_patch_error')):
        p.error('Mindst én måling er ikke endelig. Kontrollér modellen.')
    output=args.output_dir or Path('sweep-runs')/datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S_%fZ')
    try:output.mkdir(parents=True,exist_ok=False)
    except FileExistsError:p.error(f'Outputmappen findes allerede: {output}')
    with (output/'pairs.csv').open('w',encoding='utf-8',newline='') as file:
        writer=csv.DictWriter(file,fieldnames=list(rows[0]));writer.writeheader();writer.writerows(rows)
    (output/'summary.json').write_text(json.dumps(report,ensure_ascii=False,indent=2),encoding='utf-8')
    for key,group in report['groups'].items():
        if group:print(f"{key}: n={group['count']}, gennemsnitlig logit-ændring={group['patch_effect_mean']:+.3f}, korrekt i begge={group['both_correct_count']}")
    print(f'Gemt i {output}: pairs.csv og summary.json. Alle resultater vedrører én model.')


if __name__=='__main__':main()
