#!/usr/bin/env python3
"""Train a tiny educational low-rank adapter on Pythia's frozen output layer."""
import argparse
import hashlib
import json
import math
from datetime import datetime, timezone
from pathlib import Path

import torch
from torch import nn
import torch.nn.functional as F
import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL='EleutherAI/pythia-70m'
REVISION='a39f36b100fe8a5377810d56c3f4789b9c53ac42'
# Artificial repeated patterns; validation prompts are held out, not independent of the template.
TRAIN=[('A dax is',' red'),('A blick is',' blue'),('A wug is',' green'),('A zorp is',' yellow')]
VALID=[('The dax is',' red'),('The blick is',' blue')]
# Small public reference set; not an independent benchmark or a safety evaluation.
REFERENCE=[('The capital of France is',' Paris'),('The capital of Italy is',' Rome'),('The capital of Japan is',' Tokyo')]

def prompt_key(prompt):return ' '.join(prompt.split()).casefold()

def validate_dataset(data):
    if not isinstance(data,dict) or set(data)!={'format','train','validation'} or data['format']!='learning-lab-adapter-data-v1':raise ValueError('Datasættet skal have format, train og validation.')
    result={};seen=set()
    for split,minimum in [('train',2),('validation',1)]:
        rows=data[split]
        if not isinstance(rows,list) or not minimum<=len(rows)<=16:raise ValueError(f'{split} skal have {minimum}–16 eksempler.')
        result[split]=[]
        for row in rows:
            if not isinstance(row,dict) or set(row)!={'prompt','answer'}:raise ValueError('Hvert eksempel skal have prompt og answer.')
            prompt,answer=row['prompt'],row['answer']
            if not isinstance(prompt,str) or not isinstance(answer,str) or not prompt.strip() or not answer.strip() or len(prompt)>200 or len(answer)>80 or any(0xD800<=ord(c)<=0xDFFF for c in prompt+answer):raise ValueError('Prompt eller svar er tomt eller for langt.')
            key=prompt_key(prompt)
            if key in seen:raise ValueError('Den samme prompt må ikke gentages, heller ikke på tværs af splits.')
            seen.add(key);result[split].append((prompt,answer))
    return result

def validate_test_dataset(data, training_data):
    if not isinstance(data,dict) or set(data)!={'format','test'} or data['format']!='learning-lab-adapter-test-v1':raise ValueError('Testfilen skal have format og test.')
    # Reuse field, length and duplicate checks, including against the supplied training prompts.
    checked=validate_dataset({'format':'learning-lab-adapter-data-v1','train':training_data['train'],'validation':data['test']})['validation']
    excluded={prompt_key(row['prompt']) for row in training_data['validation']} | {prompt_key(prompt) for prompt,_ in REFERENCE}
    if any(prompt_key(prompt) in excluded for prompt,_ in checked):raise ValueError('En testprompt matcher en validerings- eller referenceprompt.')
    return checked

def builtin_dataset():
    return {'format':'learning-lab-adapter-data-v1',**{key:[{'prompt':p,'answer':a} for p,a in rows] for key,rows in [('train',TRAIN),('validation',VALID)]}}

class OutputAdapter(nn.Module):
    """Frozen W plus B @ A; only A and B are optimized. Not a PEFT file."""
    def __init__(self,base,rank=4,scale=1.0):
        super().__init__()
        if not isinstance(base,nn.Linear) or not 1<=rank<=16: raise ValueError('Ugyldigt outputlag eller rank.')
        self.base=base
        for p in self.base.parameters(): p.requires_grad_(False)
        self.a=nn.Parameter(torch.empty(rank,base.in_features))
        self.b=nn.Parameter(torch.zeros(base.out_features,rank))
        nn.init.kaiming_uniform_(self.a,a=math.sqrt(5))
        self.scale=scale
    def forward(self,x): return self.base(x)+F.linear(F.linear(x,self.a),self.b)*self.scale

def prepare(tokenizer,rows):
    if not rows: raise ValueError('Datasættet er tomt.')
    prepared=[]
    for prompt,answer in rows:
        ids=tokenizer(prompt,return_tensors='pt',add_special_tokens=False)
        target=tokenizer(answer,add_special_tokens=False).input_ids
        combined=tokenizer(prompt+answer,add_special_tokens=False).input_ids
        if not 1<=ids['input_ids'].shape[-1]<=128:raise ValueError('En prompt skal indeholde 1–128 tokens.')
        if len(target)!=1 or combined!=ids['input_ids'][0].tolist()+target:
            raise ValueError(f'Svaret {answer!r} skal være ét selvstændigt token efter {prompt!r}.')
        prepared.append((prompt,answer,ids,int(target[0])))
    return prepared

def measure(model,rows):
    model.eval();results=[]
    with torch.no_grad():
        for prompt,answer,inputs,target in rows:
            logits=model(**inputs,use_cache=False).logits[0,-1]
            lp=F.log_softmax(logits,dim=-1)
            results.append({'prompt':prompt,'answer':answer,'answer_id':target,'loss':float(-lp[target]),'probability':float(lp[target].exp()),'rank':1+int((logits>logits[target]).sum()),'answer_logit':float(logits[target]),'log_normalizer':float(torch.logsumexp(logits,dim=-1))})
    return results

def experiment(model,tokenizer,steps=20,rate=.01,rank=4,seed=7,dataset=None,best_capture=None):
    if not 1<=steps<=100 or not 0<rate<=.05: raise ValueError('Vælg 1–100 skridt og en læringsrate over 0 og højst 0,05.')
    torch.manual_seed(seed)
    data=validate_dataset(dataset if dataset is not None else builtin_dataset())
    train=prepare(tokenizer,data['train']);valid=prepare(tokenizer,data['validation'])
    used={prompt_key(prompt) for split in data.values() for prompt,_ in split}
    reference_rows=[row for row in REFERENCE if prompt_key(row[0]) not in used]
    reference=prepare(tokenizer,reference_rows) if reference_rows else []
    for p in model.parameters():p.requires_grad_(False)
    model.embed_out=OutputAdapter(model.embed_out,rank=rank)
    adapter=model.embed_out
    total=sum(p.numel() for p in model.parameters());trainable=sum(p.numel() for p in model.parameters() if p.requires_grad)
    before={'train':measure(model,train),'validation':measure(model,valid),'reference':measure(model,reference)}
    optimizer=torch.optim.AdamW([adapter.a,adapter.b],lr=rate,weight_decay=0)
    history=[]
    def snapshot(step):
        return {'step':step,'train_loss':sum(r['loss'] for r in measure(model,train))/len(train),'validation_loss':sum(r['loss'] for r in measure(model,valid))/len(valid),'reference_loss':sum(r['loss'] for r in measure(model,reference))/len(reference) if reference else None}
    def record(step):
        point=snapshot(step);history.append(point)
        if best_capture is not None and ('loss' not in best_capture or point['validation_loss']<best_capture['loss']):
            best_capture.update(step=step,loss=point['validation_loss'],a=adapter.a.detach().cpu().clone(),b=adapter.b.detach().cpu().clone())
    record(0)
    for step in range(1,steps+1):
        model.train();optimizer.zero_grad()
        for _,_,inputs,target in train:
            logits=model(**inputs,use_cache=False).logits[0,-1]
            (F.cross_entropy(logits.unsqueeze(0),torch.tensor([target]))/len(train)).backward()
        optimizer.step()
        if step%5==0 or step==steps:record(step)
    after={'train':measure(model,train),'validation':measure(model,valid),'reference':measure(model,reference)}
    return {'format':'learning-lab-pythia-adapter-v1','model':MODEL,'revision':REVISION,'torch_version':str(torch.__version__),'transformers_version':transformers.__version__,'rank':rank,'scale':adapter.scale,'steps':steps,'rate':rate,'seed':seed,'trainable_parameters':trainable,'total_parameters':total,'reference_excluded':len(REFERENCE)-len(reference_rows),'before':before,'after':after,'history':history},adapter

def restore_adapter(model,path):
    """Load our own adapter on the matching frozen base; it is not PEFT format."""
    if path.stat().st_size>10_000_000: raise ValueError('Adapterfilen er for stor.')
    saved=torch.load(path,map_location='cpu',weights_only=True)
    if not isinstance(saved,dict) or set(saved)!={'a','b','rank','scale','model','revision'} or saved['model']!=MODEL or saved['revision']!=REVISION or type(saved['rank']) is not int or not 1<=saved['rank']<=16 or type(saved['scale']) not in (int,float) or saved['scale']!=1.0:raise ValueError('Adapterens metadata er ugyldige.')
    a,b=saved['a'],saved['b'];rank=saved['rank'];base=model.embed_out
    if not isinstance(base,nn.Linear) or not isinstance(a,torch.Tensor) or not isinstance(b,torch.Tensor) or a.shape!=(rank,base.in_features) or b.shape!=(base.out_features,rank) or not a.is_floating_point() or not b.is_floating_point() or not torch.isfinite(a).all() or not torch.isfinite(b).all():raise ValueError('Adapterens vægte er ugyldige.')
    for p in model.parameters():p.requires_grad_(False)
    model.embed_out=OutputAdapter(base,rank=rank)
    with torch.no_grad():model.embed_out.a.copy_(a);model.embed_out.b.copy_(b)
    return model

def main():
    p=argparse.ArgumentParser(description='Træn en lille lavrangsadapter på Pythia-70M.')
    p.add_argument('--offline',action='store_true');p.add_argument('--steps',type=int,default=20);p.add_argument('--rate',type=float,default=.01);p.add_argument('--output-dir',type=Path);p.add_argument('--data',type=Path,help='Brug egne trænings- og valideringseksempler i JSON.');p.add_argument('--evaluate-adapter',type=Path,help='Genindlæs en gemt adapter og mål den uden at træne.');p.add_argument('--test-data',type=Path,help='Mål en genindlæst adapter på separat test-JSON.');p.add_argument('--test-output',type=Path,help='Gem testmålingen som en ny JSON-fil.');args=p.parse_args()
    if not 1<=args.steps<=100 or not 0<args.rate<=.05:p.error('Vælg 1–100 skridt og en læringsrate over 0 og højst 0,05.')
    if args.test_output and not args.test_data:p.error('--test-output kræver --test-data.')
    if args.test_data and not args.evaluate_adapter:p.error('--test-data kræver --evaluate-adapter og bruges ikke under træning.')
    if args.output_dir is not None and args.output_dir.exists():p.error('Outputmappen findes allerede.')
    torch.set_num_threads(1)
    try:
        raw=args.data.read_bytes() if args.data else json.dumps(builtin_dataset(),ensure_ascii=False,sort_keys=True).encode('utf-8')
        if len(raw)>65536:raise ValueError('Datafilen må højst fylde 64 KB.')
        dataset=json.loads(raw.decode('utf-8'));prepared=validate_dataset(dataset)
        test=None
        if args.test_data:
            test_raw=args.test_data.read_bytes()
            if len(test_raw)>65536:raise ValueError('Testfilen må højst fylde 64 KB.')
            test=validate_test_dataset(json.loads(test_raw.decode('utf-8')),dataset)
        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)
        if args.evaluate_adapter:
            restore_adapter(model,args.evaluate_adapter)
            used={prompt_key(prompt) for split in prepared.values() for prompt,_ in split}
            reference=[row for row in REFERENCE if prompt_key(row[0]) not in used]
            groups=[('Test',test)] if test is not None else [('Træning',prepared['train']),('Validering',prepared['validation']),('Reference',reference)]
            if test is not None:print('Testen sammenlignes med de angivne trænings- og valideringsdata; oprindelsen kan ikke verificeres.')
            for label,examples in groups:
                rows=measure(model,prepare(tokenizer,examples)) if examples else []
                if not rows:print(f'{label}: ingen eksempler.');continue
                print(f"{label}: gennemsnitligt tab {sum(row['loss'] for row in rows)/len(rows):.3f}")
                if test is not None and args.test_output:
                    report={'format':'learning-lab-adapter-test-result-v1','model':MODEL,'revision':REVISION,'adapter_sha256':hashlib.sha256(args.evaluate_adapter.read_bytes()).hexdigest(),'data_sha256':hashlib.sha256(raw).hexdigest(),'test_sha256':hashlib.sha256(test_raw).hexdigest(),'rows':rows}
                    with args.test_output.open('x',encoding='utf-8') as output:json.dump(report,output,ensure_ascii=False,indent=2,allow_nan=False)
                    print(f'Testresultat gemt i {args.test_output}.')
                for row in rows:
                    percentage='<0.001' if 0<row['probability']<.00001 else f"{100*row['probability']:.3f}"
                    print(f"  {row['prompt']} → {row['answer']}: {percentage} %, rang {row['rank']}.")
            return
        best={}
        result,adapter=experiment(model,tokenizer,args.steps,args.rate,dataset=dataset,best_capture=best)
        result['data_sha256']=hashlib.sha256(raw).hexdigest();result['data_origin']='user' if args.data else 'builtin'
    except (OSError,UnicodeError,ValueError,RuntimeError) as exc:raise SystemExit(f'Forsøget kunne ikke gennemføres: {exc}') from exc
    output=args.output_dir or Path('pythia-adapter-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('Outputmappen findes allerede.')
    torch.save({'a':adapter.a.detach().cpu(),'b':adapter.b.detach().cpu(),'rank':result['rank'],'scale':result['scale'],'model':MODEL,'revision':REVISION},output/'adapter.pt')
    torch.save({'a':best['a'],'b':best['b'],'rank':result['rank'],'scale':result['scale'],'model':MODEL,'revision':REVISION},output/'adapter-best.pt')
    result['best_adapter_step']=best['step']
    result['best_adapter_sha256']=hashlib.sha256((output/'adapter-best.pt').read_bytes()).hexdigest()
    result['source_sha256']=hashlib.sha256(Path(__file__).read_bytes()).hexdigest()
    result['adapter_sha256']=hashlib.sha256((output/'adapter.pt').read_bytes()).hexdigest()
    (output/'adapter-result.json').write_text(json.dumps(result,ensure_ascii=False,indent=2,allow_nan=False),encoding='utf-8')
    print(f"Trænet {result['trainable_parameters']:,} af {result['total_parameters']:,} parametre. Træningstab {result['history'][0]['train_loss']:.3f} → {result['history'][-1]['train_loss']:.3f}; valideringstab {result['history'][0]['validation_loss']:.3f} → {result['history'][-1]['validation_loss']:.3f}. Gemt i {output}.")

if __name__=='__main__':main()
