#!/usr/bin/env python3
"""Repeat paired-prompt residual patching on six pre-specified country/capital examples."""
import argparse
import csv
import hashlib
import json
import math
import statistics
from datetime import datetime, timezone
from pathlib import Path

import torch
import transformers
import pythia_intervention as intervention_source
from transformers import AutoTokenizer, AutoModelForCausalLM
from pythia_intervention import MODEL, REVISION, capture, intervene, single_token, identity_logit_max, validate_answer_boundaries

# Fixed exercise set: six simple English examples selected for one-token alignment.
EXAMPLES=[('France','Paris'),('Italy','Rome'),('Germany','Berlin'),('Spain','Madrid'),('Japan','Tokyo'),('China','Beijing')]
TEMPLATES={'standard':'The capital of {country} is','alternate':'In {country}, the capital city is'}


def sweep(model,tokenizer,selected=None,template="standard"):
    examples=[]
    for country,capital in (EXAMPLES if selected is None else selected):
        text=TEMPLATES[template].format(country=country);inputs=tokenizer(text,return_tensors='pt',add_special_tokens=False)
        ids=inputs['input_ids'][0].tolist();answer=single_token(tokenizer,' '+capital)
        logits,cache=capture(model,inputs)
        examples.append({'country':country,'capital':capital,'text':text,'inputs':inputs,'tokens':ids,'answer':answer,'logits':logits,'cache':cache})
    rows=[];skipped=[]
    for a in examples:
        for b in examples:
            if a is b:continue
            if len(a['tokens'])!=len(b['tokens']):skipped.append({'source':a['country'],'target':b['country'],'reason':'ulik tokenlængde'});continue
            different=[i for i,(x,y) in enumerate(zip(a['tokens'],b['tokens'])) if x!=y]
            if len(different)!=1 or different[0]==len(a['tokens'])-1 or a['answer']==b['answer']:
                skipped.append({'source':a['country'],'target':b['country'],'reason':'ikke ét justeret, forskelligt token og to svar'});continue
            try:validate_answer_boundaries(tokenizer,a['text'],b['text'],a['tokens'],b['tokens'],' '+a['capital'],' '+b['capital'])
            except ValueError:
                skipped.append({'source':a['country'],'target':b['country'],'reason':'svar er ikke et selvstændigt næste token efter begge prompts'});continue
            a0=float(a['logits'][a['answer']]-a['logits'][b['answer']]);b0=float(b['logits'][a['answer']]-b['logits'][b['answer']]);eligible=a0>0 and b0<0
            for layer in range(len(model.gpt_neox.layers)):
                for kind,pos in [('changed',different[0]),('last',len(a['tokens'])-1)]:
                    patched=intervene(model,b['inputs'],layer,pos,a['cache'][layer]);identity=intervene(model,b['inputs'],layer,pos,b['cache'][layer])
                    patched_diff=float(patched[a['answer']]-patched[b['answer']]);identity_diff=float(identity[a['answer']]-identity[b['answer']])
                    rows.append({'source':a['country'],'target':b['country'],'source_answer':a['capital'],'target_answer':b['capital'],
                      'source_difference':a0,'target_difference':b0,'relative_baseline_ok':int(eligible),'source_top_token':tokenizer.decode([int(a['logits'].argmax())]),'target_top_token':tokenizer.decode([int(b['logits'].argmax())]),
                      'layer':layer,'kind':kind,'position':pos,'patched_difference':patched_diff,'effect':patched_diff-b0,'identity_error':abs(identity_diff-b0),'identity_logit_max':identity_logit_max(identity,b['logits'])})
    return rows,skipped


def summarize(rows,skipped,selected=None,template="standard"):
    selected=EXAMPLES if selected is None else selected
    pairs={(r['source'],r['target']) for r in rows};eligible={(r['source'],r['target']) for r in rows if r['relative_baseline_ok']}
    cells=[]
    for layer in range(6):
        for kind in ('changed','last'):
            group=[r for r in rows if r['layer']==layer and r['kind']==kind];filtered=[r for r in group if r['relative_baseline_ok']]
            if not group:raise ValueError('Ingen par i en lag/positionsgruppe.')
            values=[r['effect'] for r in group];subset=[r['effect'] for r in filtered]
            cells.append({'layer':layer,'kind':kind,'count':len(group),'eligible_count':len(filtered),'mean_effect':statistics.mean(values),
                'median_effect':statistics.median(values),'min_effect':min(values),'max_effect':max(values),
                'eligible_mean_effect':statistics.mean(subset) if subset else None,'identity_error_max':max(r['identity_error'] for r in group),'identity_logit_max':max(r['identity_logit_max'] for r in group)})
    return {'format':'learning-lab-pythia-sweep-v1','model':MODEL,'revision':REVISION,'torch_version':str(torch.__version__),'transformers_version':transformers.__version__,
        'boundary_checked':True,'prompt_template':template,'prompt_count':len(selected),'countries':[country for country,_ in selected],'pair_count':len(pairs),'eligible_pair_count':len(eligible),'skipped':skipped,'cells':cells,
        'condition':'A scores its own answer above B’s answer, and B scores its own answer above A’s answer. This is relative, not top-token accuracy.'}


def main():
    p=argparse.ArgumentParser(description='Gentag Pythia-indgrebet på faste promptpar.')
    p.add_argument('--offline',action='store_true');p.add_argument('--output-dir',type=Path)
    p.add_argument('--template',choices=tuple(TEMPLATES),default='standard',help='Vælg standard eller alternate promptformulering.')
    p.add_argument('--countries',nargs='+',help='Vælg 2–6 forskellige eksempler: France Italy Germany Spain Japan China')
    args=p.parse_args()
    choices=dict(EXAMPLES)
    if args.countries is not None:
        if not 2<=len(args.countries)<=len(EXAMPLES) or len(set(args.countries))!=len(args.countries) or any(name not in choices for name in args.countries):
            p.error('Vælg 2–6 forskellige landenavne fra France Italy Germany Spain Japan China.')
        selected=[(name,choices[name]) for name in args.countries]
    else:selected=EXAMPLES
    if args.output_dir is not None and args.output_dir.exists():p.error(f'Outputmappen findes allerede: {args.output_dir}')
    torch.set_num_threads(1)
    try:
        sources={'pythia_sweep.py':Path(__file__).resolve(),'pythia_intervention.py':Path(intervention_source.__file__).resolve()}
        source_hashes={name:hashlib.sha256(path.read_bytes()).hexdigest() for name,path in sources.items()}
        tokenizer=AutoTokenizer.from_pretrained(MODEL,revision=REVISION,local_files_only=args.offline,trust_remote_code=False)
        model=AutoModelForCausalLM.from_pretrained(MODEL,revision=REVISION,local_files_only=args.offline,trust_remote_code=False,use_safetensors=True).eval()
        rows,skipped=sweep(model,tokenizer,selected,args.template);summary=summarize(rows,skipped,selected,args.template)
        if any(hashlib.sha256(path.read_bytes()).hexdigest()!=source_hashes[name] for name,path in sources.items()):
            raise RuntimeError('En kodefil ændrede sig under forsøget; kør igen med stabile filer.')
        summary['source_sha256']=source_hashes
    except (OSError,ValueError,RuntimeError) as exc:raise SystemExit(f'Forsøget kunne ikke gennemføres: {exc}') from exc
    if not all(math.isfinite(r[k]) for r in rows for k in ('source_difference','target_difference','patched_difference','effect','identity_error','identity_logit_max')):raise SystemExit('Mindst én måling er ikke endelig.')
    output=args.output_dir or Path('pythia-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}')
    (output/'summary.json').write_text(json.dumps(summary,ensure_ascii=False,indent=2),encoding='utf8')
    with (output/'pairs.csv').open('w',encoding='utf8',newline='') as file:
        writer=csv.DictWriter(file,fieldnames=list(rows[0]));writer.writeheader();writer.writerows(rows)
    print(f"{summary['pair_count']} ordnede par; {summary['eligible_pair_count']} opfylder den relative baseline-betingelse; {len(skipped)} sprunget over.")
    print(f'Gemt i {output}: summary.json og pairs.csv.')


if __name__=='__main__':main()
