#!/usr/bin/env python3
"""Generate short continuations for the same paired cases; no automatic safety judgement."""
import argparse
import hashlib
import json
from datetime import datetime, timezone
from pathlib import Path

import torch
import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
import safety_research as base

INSTRUCT_MODEL='HuggingFaceTB/SmolLM2-135M-Instruct'
INSTRUCT_REVISION='12fd25f77366fa6b3b4b768ec3050bf629380bac'
MODELS={**base.MODELS,'smollm2-instruct':(INSTRUCT_MODEL,INSTRUCT_REVISION)}


def generate_cases(data, tokenizer, model, max_new_tokens, chat=False):
    if not isinstance(max_new_tokens, int) or not 1 <= max_new_tokens <= 64:
        raise ValueError('Vælg mellem 1 og 64 nye tokens.')
    rows = []
    cases=base.validate_cases(data)['cases'] if chat else [case for case, _ in base.prepare(data, tokenizer)]
    for case in cases:
        outputs = []
        for key in ('prompt_a', 'prompt_b'):
            formatted = tokenizer.apply_chat_template([{'role':'user','content':case[key]}], tokenize=False, add_generation_prompt=True) if chat else case[key]
            encoded = tokenizer(formatted, return_tensors='pt', add_special_tokens=False)
            length = int(encoded['input_ids'].shape[-1])
            if not 1 <= length <= 512: raise ValueError(f"{case['id']}: modelinput skal være 1–512 tokens.")
            with torch.inference_mode():
                generated = model.generate(**encoded, do_sample=False, num_beams=1,
                    max_new_tokens=max_new_tokens, pad_token_id=tokenizer.eos_token_id)
            new_ids = generated[0, length:].tolist()
            outputs.append({'formatted_input':formatted, 'input_tokens':length, 'text': tokenizer.decode(new_ids, skip_special_tokens=True),
                            'generated_tokens': len(new_ids), 'first_token_id':new_ids[0] if new_ids else None, 'token_ids':new_ids,
                            'stopped_on_eos': bool(new_ids and new_ids[-1] == tokenizer.eos_token_id)})
        rows.append({'id':case['id'], 'split':case['split'], 'kind':case['kind'],
                     'prompt_a':case['prompt_a'], 'prompt_b':case['prompt_b'],
                     'answer':case['answer'], 'a':outputs[0], 'b':outputs[1]})
    return rows


def main():
    parser = argparse.ArgumentParser(description='Generér korte fortsættelser for parrede cases.')
    parser.add_argument('cases', type=Path)
    parser.add_argument('--model', choices=tuple(MODELS), default='pythia')
    parser.add_argument('--max-new-tokens', type=int, default=16)
    parser.add_argument('--offline', action='store_true')
    parser.add_argument('--output-dir', type=Path)
    args = parser.parse_args()
    if not 1 <= args.max_new_tokens <= 64: parser.error('Vælg mellem 1 og 64 nye tokens.')
    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]
    chat = args.model == 'smollm2-instruct'
    try:
        raw = args.cases.read_bytes()
        if len(raw) > 131072: raise ValueError('Casefilen må højst fylde 128 KB.')
        data = base.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)
        if not chat: base.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 = generate_cases(data, tokenizer, model, args.max_new_tokens, chat=chat)
    except (OSError, ValueError, UnicodeError, RuntimeError) as exc:
        raise SystemExit(f'Genereringen kunne ikke gennemføres: {exc}') from exc
    output = args.output_dir or Path('safety-generation-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-generation-v1','model':model_name,'revision':revision,
              'cases_sha256':hashlib.sha256(raw).hexdigest(),
              'source_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
              'evaluation_source_sha256':hashlib.sha256(Path(base.__file__).read_bytes()).hexdigest(),
              'torch_version':str(torch.__version__),'transformers_version':transformers.__version__,
              'max_new_tokens':args.max_new_tokens,'decoding':'greedy','input_format':'chat' if chat else 'raw','rows':rows}
    (output/'generation_results.json').write_text(json.dumps(result, ensure_ascii=False, indent=2, allow_nan=False), encoding='utf-8')
    print(f'Genereret {len(rows)} casepar. Åbn {output}/generation_results.json i Learning Lab.')

if __name__ == '__main__': main()
