#!/usr/bin/env python3
"""Paired-prompt residual-stream patching on a pinned open Pythia checkpoint."""
import argparse
import csv
import json
from datetime import datetime, timezone
from pathlib import Path

import torch
import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL='EleutherAI/pythia-70m'
REVISION='a39f36b100fe8a5377810d56c3f4789b9c53ac42'


def single_token(tokenizer, text):
    ids=tokenizer(text,add_special_tokens=False).input_ids
    if len(ids)!=1:raise ValueError(f'Svaret {text!r} skal være præcis ét token; blev {len(ids)}.')
    return ids[0]


def validate_answer_boundaries(tokenizer, source_text, target_text, source_ids, target_ids, source_answer, target_answer):
    source_id=single_token(tokenizer,source_answer);target_id=single_token(tokenizer,target_answer)
    if source_id==target_id:raise ValueError('Svarene skal være forskellige tokens.')
    for text,prefix in ((source_text,source_ids),(target_text,target_ids)):
        for answer,token_id in ((source_answer,source_id),(target_answer,target_id)):
            combined=tokenizer(text+answer,add_special_tokens=False).input_ids
            if combined!=prefix+[token_id]:raise ValueError(f'Svaret {answer!r} skal være ét selvstændigt token efter begge prompts. Prøv eventuelt et foranstillet mellemrum.')
    return source_id,target_id


def capture(model, inputs):
    values={};handles=[]
    for index,layer in enumerate(model.gpt_neox.layers):
        def save(_module,_args,output,index=index):
            if not isinstance(output,tuple) or not isinstance(output[0],torch.Tensor):raise RuntimeError('Uventet lag-output. Kontrollér Transformers-versionen.')
            values[index]=output[0].detach().clone()
        handles.append(layer.register_forward_hook(save))
    try:
        with torch.no_grad():logits=model(**inputs,use_cache=False).logits[0,-1].detach()
    finally:
        for handle in handles:handle.remove()
    return logits,values


def intervene(model,inputs,layer,position,vector):
    def hook(_module,_args,output):
        if not isinstance(output,tuple) or not isinstance(output[0],torch.Tensor):raise RuntimeError('Uventet lag-output.')
        hidden=output[0].clone();hidden[:,position,:]=vector[:,position,:]
        return (hidden,*output[1:])
    handle=model.gpt_neox.layers[layer].register_forward_hook(hook)
    try:
        with torch.no_grad():return model(**inputs,use_cache=False).logits[0,-1].detach()
    finally:handle.remove()


def identity_logit_max(identity, baseline):
    """Maximum absolute difference across all next-token logits."""
    if identity.shape != baseline.shape: raise ValueError('Logit shapes differ')
    return float((identity - baseline).abs().max())


def measure(model,tokenizer,source_text,target_text,source_answer,target_answer):
    source=tokenizer(source_text,return_tensors='pt',add_special_tokens=False)
    target=tokenizer(target_text,return_tensors='pt',add_special_tokens=False)
    a_ids=source['input_ids'][0].tolist();b_ids=target['input_ids'][0].tolist()
    if len(a_ids)!=len(b_ids) or not 2<=len(a_ids)<=64:raise ValueError('Prompts skal have samme tokenlængde mellem 2 og 64.')
    differences=[i for i,(a,b) in enumerate(zip(a_ids,b_ids)) if a!=b]
    if len(differences)!=1:raise ValueError('Prompts skal afvige i præcis ét token. Kontrollér tokeniseringen.')
    pos=differences[0];last=len(a_ids)-1
    if pos==last:raise ValueError('Det forskellige token må ikke være sidste position i dette forsøg.')
    source_id,target_id=validate_answer_boundaries(tokenizer,source_text,target_text,a_ids,b_ids,source_answer,target_answer)
    clean,cache_a=capture(model,source);corrupt,cache_b=capture(model,target)
    def describe(logits):
        probs=logits.softmax(-1)
        return {'difference':float(logits[source_id]-logits[target_id]),'source_probability':float(probs[source_id]),'target_probability':float(probs[target_id]),'top_token':tokenizer.decode([int(logits.argmax())])}
    baseline=describe(clean);other=describe(corrupt);rows=[]
    for layer in range(len(model.gpt_neox.layers)):
        for label,position in [('changed',pos),('last',last)]:
            patched=intervene(model,target,layer,position,cache_a[layer]);identity=intervene(model,target,layer,position,cache_b[layer]);values=describe(patched)
            rows.append({'layer':layer,'position':position,'kind':label,'patched_difference':values['difference'],'effect':values['difference']-other['difference'],'patched_source_probability':values['source_probability'],'patched_target_probability':values['target_probability'],'identity_error':abs(describe(identity)['difference']-other['difference']),'identity_logit_max':identity_logit_max(identity,corrupt)})
    return {'format':'learning-lab-pythia-v1','model':MODEL,'revision':REVISION,'torch_version':str(torch.__version__),'transformers_version':transformers.__version__,
        'source_text':source_text,'target_text':target_text,'source_answer':source_answer,'target_answer':target_answer,
        'source_tokens':[tokenizer.decode([i]) for i in a_ids],'target_tokens':[tokenizer.decode([i]) for i in b_ids],
        'changed_position':pos,'boundary_checked':True,'source':baseline,'target':other,'interventions':rows}


def read_case(path):
    if path.stat().st_size > 10000:
        raise ValueError('Casefilen må højst være 10 KB.')
    case=json.loads(path.read_text(encoding='utf-8'))
    fields=('source','target','source_answer','target_answer')
    if not isinstance(case,dict) or set(case)!=set(fields)|{'format'} or case['format']!='learning-lab-pythia-case-v1':
        raise ValueError('Casefilen har ikke det forventede format.')
    values=[case[k] for k in fields]
    if any(not isinstance(v,str) or len(v)>300 or any(0xD800<=ord(c)<=0xDFFF for c in v) for v in values):
        raise ValueError('Hvert felt skal være tekst med højst 300 gyldige tegn.')
    return values


def main():
    p=argparse.ArgumentParser(description='Undersøg patching i den åbne Pythia-70M-model.')
    p.add_argument('--offline',action='store_true',help='Brug kun allerede hentede modeldata')
    p.add_argument('--source');p.add_argument('--target')
    p.add_argument('--source-answer');p.add_argument('--target-answer')
    p.add_argument('--case',type=Path,help='Brug en casefil fra tokenkontrollen')
    p.add_argument('--output-dir',type=Path)
    args=p.parse_args()
    if args.output_dir is not None and args.output_dir.exists():p.error(f'Outputmappen findes allerede: {args.output_dir}')
    supplied=[args.source,args.target,args.source_answer,args.target_answer]
    if args.case and any(v is not None for v in supplied):p.error('--case kan ikke kombineres med de fire tekstargumenter.')
    if args.case:
        try: args.source,args.target,args.source_answer,args.target_answer=read_case(args.case)
        except (OSError,UnicodeError,ValueError,json.JSONDecodeError) as exc:p.error(f'Casefilen kunne ikke læses: {exc}')
    else:
        defaults=['The capital of France is','The capital of Italy is',' Paris',' Rome']
        args.source,args.target,args.source_answer,args.target_answer=[default if value is None else value for value,default in zip(supplied,defaults)]
    if any(len(v)>300 or any(0xD800<=ord(c)<=0xDFFF for c in v) for v in (args.source,args.target,args.source_answer,args.target_answer)):p.error('Tekster må højst være 300 gyldige tegn.')
    torch.set_num_threads(1)
    try:
        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)
        model.eval();result=measure(model,tokenizer,args.source,args.target,args.source_answer,args.target_answer)
    except (OSError,ValueError,RuntimeError) as exc:raise SystemExit(f'Forsøget kunne ikke gennemføres: {exc}') from exc
    output=args.output_dir or Path('pythia-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/'pythia.json').write_text(json.dumps(result,ensure_ascii=False,indent=2),encoding='utf-8')
    with (output/'interventions.csv').open('w',encoding='utf-8',newline='') as file:
        writer=csv.DictWriter(file,fieldnames=list(result['interventions'][0]));writer.writeheader();writer.writerows(result['interventions'])
    print(f"A logit-forskel {result['source']['difference']:+.3f}; B {result['target']['difference']:+.3f}.")
    print(f"Mest sandsynlige token: A {result['source']['top_token']!r}, B {result['target']['top_token']!r}.")
    print(f'Gemt i {output}: pythia.json og interventions.csv. Indlæs pythia.json i Learn the Machine.')


if __name__=='__main__':main()
