#!/usr/bin/env python3
"""Inspect next-character probabilities of a locally trained tiny text transformer."""
import argparse
import hashlib
import json
import math
from datetime import datetime, timezone
from pathlib import Path

import torch
from train_text import BLOCK, TextTransformer, sample, vocabulary


@torch.no_grad()
def forward_with_attention(model, tokens):
    # Capture Q/K/V from the actual forward pass; recompute its causal softmax.
    captured = []
    handle = model.qkv.register_forward_hook(lambda module, args, output: captured.append(output.detach()))
    try:
        logits = model(tokens)
    finally:
        handle.remove()
    q, k, _ = captured[0].chunk(3, dim=-1)
    length = tokens.shape[1]
    future = torch.ones(length, length, dtype=torch.bool, device=tokens.device).triu(1)
    weights = ((q @ k.transpose(-1, -2)) / math.sqrt(q.shape[-1])).masked_fill(future, float('-inf')).softmax(-1)
    return logits, weights


def load_checkpoint(run_dir):
    run_dir = Path(run_dir)
    metadata_path = run_dir / 'text-result.json'
    if metadata_path.stat().st_size > 1_000_000:
        raise ValueError('Resultatfilen er for stor.')
    metadata = json.loads(metadata_path.read_text(encoding='utf-8'))
    raw_vocab=metadata.get('vocab')
    if metadata.get('format') != 'learning-lab-text-transformer-v1' or not isinstance(raw_vocab,str) or not 2 <= len(raw_vocab) <= 256 or sorted(set(raw_vocab)) != list(raw_vocab) or any(0xD800 <= ord(c) <= 0xDFFF for c in raw_vocab) or metadata.get('block') != BLOCK:
        raise ValueError('Resultatfilen passer ikke til denne tegnmodel.')
    vocab=list(raw_vocab)
    model_path = run_dir / 'model.pt'
    if model_path.stat().st_size > 2_000_000:
        raise ValueError('Modelfilen er for stor til denne oevelse.')
    stored_hash = metadata.get('model_sha256')
    actual_hash = hashlib.sha256(model_path.read_bytes()).hexdigest()
    if stored_hash is not None and (not isinstance(stored_hash,str) or stored_hash != actual_hash):
        raise ValueError('Modelfilens hash matcher ikke resultatfilen. Kontrollér at filerne kommer fra samme kørsel.')
    model = TextTransformer(len(vocab))
    model.load_state_dict(torch.load(model_path, map_location='cpu', weights_only=True), strict=True)
    model.eval(); torch.set_num_threads(1)
    return model, vocab, metadata, model_path, metadata_path


def inspect_model(run_dir, prompt):
    if not prompt or len(prompt) > 500:
        raise ValueError('Prompten skal indeholde 1–500 tegn.')
    model, vocab, metadata, model_path, metadata_path = load_checkpoint(run_dir)
    unknown = sorted(set(prompt) - set(vocab))
    if unknown:
        raise ValueError('Ukendte tegn i prompten: ' + repr(''.join(unknown)) + '. Brug kun modellens tegnordforraad.')
    input_ids = torch.tensor([[vocab.index(c) for c in prompt[-BLOCK:]]], dtype=torch.long)
    logits, weights = forward_with_attention(model, input_ids)
    probs = logits[0, -1].softmax(-1).tolist()
    current_hash = hashlib.sha256(Path(__file__).with_name('train_text.py').read_bytes()).hexdigest()
    saved_hash = metadata.get('script_sha256')
    return {'format':'learning-lab-text-probe-v1', 'prompt':prompt, 'context':prompt[-BLOCK:],
            'block':BLOCK, 'vocab':''.join(vocab), 'probabilities':probs, 'attention':weights[0].tolist(),
            'continuation':sample(model,vocab,prompt,n=60),
            'model_sha256':hashlib.sha256(model_path.read_bytes()).hexdigest(),
            'result_sha256':hashlib.sha256(metadata_path.read_bytes()).hexdigest(),
            'script_match': None if saved_hash is None else saved_hash == current_hash,
            'checkpoint_match':None if 'model_sha256' not in metadata else True}


def main():
    parser=argparse.ArgumentParser(description='Undersoeg en traenet tekstmodel med en prompt.')
    parser.add_argument('--run-dir',type=Path,required=True)
    parser.add_argument('--prompt',default='en kat ')
    parser.add_argument('--output',type=Path)
    args=parser.parse_args()
    try: result=inspect_model(args.run_dir,args.prompt)
    except (OSError,ValueError,RuntimeError,json.JSONDecodeError) as exc: parser.error(str(exc))
    output=args.output or args.run_dir/('text-probe-'+datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S_%fZ')+'.json')
    try:
        with output.open('x',encoding='utf-8') as f: json.dump(result,f,ensure_ascii=False,indent=2)
    except FileExistsError: parser.error('Outputfilen findes allerede.')
    pairs=sorted(zip(result['vocab'],result['probabilities']),key=lambda item:-item[1])[:5]
    print('Naeste tegn:',[(repr(c),round(p,3)) for c,p in pairs]);print('Greedy:',result['continuation']);print('Gemt:',output)

if __name__=='__main__': main()
