#!/usr/bin/env python3
"""Compare paired prompts on a fixed local model; the model is not trained."""
import argparse
import csv
import hashlib
import json
import math
import re
from datetime import datetime, timezone
from pathlib import Path

import torch
import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL='EleutherAI/pythia-70m'
REVISION='a39f36b100fe8a5377810d56c3f4789b9c53ac42'
MODELS={'pythia':(MODEL,REVISION),'smollm2':('HuggingFaceTB/SmolLM2-135M','93efa2f097d58c2a74874c7e644dbc9b0cee75a2')}
FORMAT='learning-lab-safety-cases-v1'


def validate_cases(data):
    if not isinstance(data,dict) or data.get('format')!=FORMAT or not isinstance(data.get('hypothesis'),str) or len(data['hypothesis'])>500:
        raise ValueError('Ugyldigt format eller hypotese (højst 500 tegn).')
    threat=data.get('threat_model')
    if 'threat_model' in data and (not isinstance(threat,dict) or any(not isinstance(threat.get(k),str) or len(threat[k])>300 for k in ('context','control','consequence'))):
        raise ValueError('Trusselsbeskrivelsen skal have tre tekstfelter på højst 300 tegn.')
    cases=data.get('cases')
    if not isinstance(cases,list) or not 3<=len(cases)<=24:
        raise ValueError('Der skal være 3–24 cases.')
    ids=set();prompts={};splits=set();variant_splits=set();controls=0
    for case in cases:
        if not isinstance(case,dict):raise ValueError('En case er ugyldig.')
        if 'review' in case:
            review=case['review']
            if not isinstance(review,dict) or review.get('meaning') not in ('unreviewed','appears_same','different','uncertain') or review.get('answer') not in ('unreviewed','appears_correct','incorrect','uncertain') or not isinstance(review.get('note'),str) or len(review['note'])>300:
                raise ValueError('Ugyldig manuel vurdering af case.')
        ident=case.get('id');split=case.get('split');kind=case.get('kind')
        if not isinstance(ident,str) or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9_-]{0,39}',ident) or ident in ids:raise ValueError('Case-id skal være unikt og bruge bogstaver, tal, - eller _.')
        ids.add(ident)
        if split not in ('development','evaluation') or kind not in ('control','variant'):raise ValueError('Ukendt split eller case-type.')
        splits.add(split)
        if kind=='variant':variant_splits.add(split)
        a,b,answer=case.get('prompt_a'),case.get('prompt_b'),case.get('answer')
        if any(not isinstance(x,str) for x in (a,b,answer)) or not a.strip() or not b.strip() or not answer.strip() or max(len(a),len(b))>500 or len(answer)>80:raise ValueError('Prompt og svar skal være ikke-tomme og inden for længdegrænsen.')
        if (kind=='control') != (a==b):raise ValueError('Control kræver identiske prompts; variant kræver forskellige prompts.')
        controls+=int(kind=='control')
        for prompt in {a,b}:
            if prompt in prompts and prompts[prompt]!=ident:raise ValueError('Samme prompt bruges i flere cases; vælg forskellige cases.')
            prompts[prompt]=ident
    if splits!={'development','evaluation'} or variant_splits!=splits or not controls:raise ValueError('Brug mindst én variant i hvert split og mindst én identisk kontrol.')
    return data


def prepare(data,tokenizer):
    prepared=[]
    for case in validate_cases(data)['cases']:
        target=tokenizer(case['answer'],add_special_tokens=False).input_ids
        if len(target)!=1:raise ValueError(f"{case['id']}: svaret skal være præcis ét token, inkl. eventuelt mellemrum.")
        for key in ('prompt_a','prompt_b'):
            prompt=case[key];ids=tokenizer(prompt,add_special_tokens=False).input_ids
            full=tokenizer(prompt+case['answer'],add_special_tokens=False).input_ids
            if not 1<=len(ids)<=256 or full!=ids+target:raise ValueError(f"{case['id']}: prompt skal være 1–256 tokens, og svaret skal være ét token direkte efter prompten.")
        prepared.append((case,int(target[0])))
    return prepared


def evaluate(data,tokenizer,model):
    rows=[]
    for case,target in prepare(data,tokenizer):
        metrics=[]
        for key in ('prompt_a','prompt_b'):
            encoded=tokenizer(case[key],return_tensors='pt',add_special_tokens=False)
            with torch.inference_mode():logits=model(**encoded,use_cache=False).logits[0,-1].detach()
            if logits.ndim!=1 or not torch.isfinite(logits).all() or not 0<=target<logits.numel():raise ValueError('Ugyldige logits eller svar-token.')
            probabilities=logits.softmax(-1);top=int(logits.argmax());prob=float(probabilities[target])
            if not math.isfinite(prob):raise ValueError('Ugyldig sandsynlighed.')
            metrics.append({'token_count':int(encoded['input_ids'].shape[-1]),'top_token_id':top,'top_token':tokenizer.decode([top]),'top_is_answer':top==target,'answer_probability':prob,'answer_rank':1+int((logits>logits[target]).sum())})
        rows.append({**case,'answer_id':target,'a':metrics[0],'b':metrics[1]})
    return rows


def report(result):
    rows=result['rows']; lines=['# Min prompt-evaluering','','## Plan','', 'Hypotese fra casefilen:']
    lines.extend('> '+line for line in (result['hypothesis'] or '(ingen hypotese)').splitlines())
    threat=result.get('threat_model')
    if threat:
        lines += ['', '## Afgrænsning af risiko', '']
        for key,label in (('context','Situation'),('control','Mulig ændring'),('consequence','Mulig konsekvens')):
            lines.append(f'{label}:')
            lines.extend('> '+line for line in (threat[key] or '(ikke udfyldt)').splitlines())
    if any('review' in row for row in rows):
        lines += ['', '## Egne vurderinger af cases', '', 'Dette er brugerens vurderinger, ikke uafhængigt verificerede facit. De indgår ikke i modellens input.']
        meaning={'unreviewed':'ikke vurderet','appears_same':'ser ud til at betyde det samme','different':'ser ud til at ændre betydning','uncertain':'usikker'}
        answer={'unreviewed':'ikke vurderet','appears_correct':'ser korrekt ud','incorrect':'ser forkert ud','uncertain':'usikker'}
        for row in rows:
            if 'review' not in row:continue
            review=row['review']
            lines += ['', f"{row['id']}: betydning: {meaning[review['meaning']]}; facit: {answer[review['answer']]}"]
            lines.extend('> '+line for line in (review['note'] or '(ingen begrundelse)').splitlines())
    lines += ['',f"Model: {result['model']} @ {result['revision']}",f"Casefil SHA-256: {result['cases_sha256']}",f"Program SHA-256: {result['source_sha256']}",'','## Målinger: kun varianter','', '| Split | Antal | Top-token korrekt A | Top-token korrekt B | Top-token ændret |','| --- | ---: | ---: | ---: | ---: |']
    for split in ('development','evaluation'):
        variants=[r for r in rows if r['split']==split and r['kind']=='variant']
        lines.append(f"| {split} | {len(variants)} | {sum(r['a']['top_is_answer'] for r in variants)} | {sum(r['b']['top_is_answer'] for r in variants)} | {sum(r['a']['top_token_id']!=r['b']['top_token_id'] for r in variants)} |")
    lines += ['', '## Samme cases, parret', '', '| Split | Begge ramte | Kun A ramte | Kun B ramte | Ingen ramte |', '| --- | ---: | ---: | ---: | ---: |']
    for split in ('development','evaluation'):
        variants=[r for r in rows if r['split']==split and r['kind']=='variant']
        counts=[sum(condition(r) for r in variants) for condition in (
            lambda r:r['a']['top_is_answer'] and r['b']['top_is_answer'],
            lambda r:r['a']['top_is_answer'] and not r['b']['top_is_answer'],
            lambda r:not r['a']['top_is_answer'] and r['b']['top_is_answer'],
            lambda r:not r['a']['top_is_answer'] and not r['b']['top_is_answer'])]
        lines.append(f"| {split} | {' | '.join(map(str,counts))} |")
    lines += ['', 'Antallene viser præcist top-token mod det valgte facit, ikke kvaliteten af et fuldt svar. Ens samlede antal kan skjule skift i begge retninger.']
    controls=[r for r in rows if r['kind']=='control'];changes=sum(r['a']['top_token_id']!=r['b']['top_token_id'] for r in controls);maximum=max(abs(r['a']['answer_probability']-r['b']['answer_probability']) for r in controls)
    lines += ['',f'Identiske kontroller: {len(controls)}. Ændret top-token: {changes}. Maksimal absolut forskel i facitsandsynlighed: {maximum:.3g}.','','## Min vurdering','', '- Hvad observerede jeg, og stemmer det med hypotesen?', '- Var formuleringerne reelt sammenlignelige, og er facit korrekt?', '- Hvad viser kontrolcases, og hvor kan de ikke fange fejl?', '- Hvilken alternativ forklaring eller fejlkilde er plausibel?', '- Hvilket næste forsøg og hvilke andre cases ville kunne udfordre konklusionen?', '', 'Disse små cases og én model dokumenterer ikke generel sikkerhed. Egne splitetiketter beviser ikke uafhængighed eller fravær af kontaminering. Næste-token-måling er ikke et fuldt genereret svar.', '']
    return '\n'.join(lines)


def main():
    parser=argparse.ArgumentParser(description='Undersøg egne parrede prompts på en lille åben sprogmodel.')
    parser.add_argument('cases',type=Path);parser.add_argument('--model',choices=tuple(MODELS),default='pythia');parser.add_argument('--offline',action='store_true');parser.add_argument('--output-dir',type=Path);args=parser.parse_args()
    if args.output_dir is not None and args.output_dir.exists():parser.error(f'Outputmappen findes allerede: {args.output_dir}')
    model_name,revision=MODELS[args.model]
    try:
        raw=args.cases.read_bytes()
        if len(raw)>131072:raise ValueError('Casefilen må højst fylde 128 KB.')
        data=validate_cases(json.loads(raw.decode('utf-8')))
        torch.set_num_threads(1)
        tokenizer=AutoTokenizer.from_pretrained(model_name,revision=revision,local_files_only=args.offline,trust_remote_code=False)
        prepare(data,tokenizer)
        model=AutoModelForCausalLM.from_pretrained(model_name,revision=revision,local_files_only=args.offline,trust_remote_code=False,use_safetensors=True).eval()
        rows=evaluate(data,tokenizer,model)
    except (OSError,ValueError,UnicodeError,RuntimeError) as exc:raise SystemExit(f'Forsøget kunne ikke gennemføres: {exc}') from exc
    output=args.output_dir or Path('safety-research-runs')/datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S_%fZ')
    try:output.mkdir(parents=True,exist_ok=False)
    except FileExistsError:parser.error(f'Outputmappen findes allerede: {output}')
    result={'format':'learning-lab-safety-research-v1','model':model_name,'revision':revision,'source_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),'cases_sha256':hashlib.sha256(raw).hexdigest(),'torch_version':str(torch.__version__),'transformers_version':transformers.__version__,'hypothesis':data['hypothesis'],**({'threat_model':data['threat_model']} if 'threat_model' in data else {}),'rows':rows}
    (output/'safety_results.json').write_text(json.dumps(result,ensure_ascii=False,indent=2,allow_nan=False),encoding='utf-8')
    fields=['id','split','kind','answer_id','a_top_id','b_top_id','a_correct','b_correct','a_probability','b_probability','a_rank','b_rank']
    with (output/'safety_results.csv').open('w',encoding='utf-8',newline='') as f:
        writer=csv.DictWriter(f,fieldnames=fields);writer.writeheader()
        for row in rows:
            a,b=row['a'],row['b'];writer.writerow({'id':row['id'],'split':row['split'],'kind':row['kind'],'answer_id':row['answer_id'],'a_top_id':a['top_token_id'],'b_top_id':b['top_token_id'],'a_correct':a['top_is_answer'],'b_correct':b['top_is_answer'],'a_probability':a['answer_probability'],'b_probability':b['answer_probability'],'a_rank':a['answer_rank'],'b_rank':b['answer_rank']})
    (output/'report.md').write_text(report(result),encoding='utf-8')
    print(f"Målt {len(rows)} casepar. Gemt i {output}: safety_results.json, safety_results.csv og report.md.")

if __name__=='__main__':main()
