#!/usr/bin/env python3
"""Train a tiny character-level causal transformer on original toy sentences."""
import argparse
import hashlib
import json
import math
from datetime import datetime, timezone
from pathlib import Path

try:
    import torch
    from torch import nn
    from torch.nn import functional as F
except ImportError as exc:
    raise SystemExit('PyTorch mangler. Følg Python & PyTorch-vejledningen i Learning Lab.') from exc

# Disjoint documents, intentionally written in a repetitive miniature style.
TRAIN = [
    'en kat ser en mus. en mus ser en kat. en kat sover i solen.',
    'en hund ser en kat. en kat ser en hund. en hund sover i solen.',
    'en mus finder et hus. en kat finder en mus. en hund finder en bold.',
    'en model ser data. en model laerer af data. en model giver et svar.',
    'en kat gaar i haven. en hund gaar i haven. en mus er i huset.',
    'en forsker ser data. en forsker tester en model. en model giver svar.',
    'en hund leger med en bold. en kat leger med en mus. solen er varm.',
    'en mus sover i huset. en kat sover i haven. en hund sover her.',
]
VALIDATION = [
    'en forsker finder en kat. en model ser en hund. en mus gaar her.',
    'en hund finder en mus. en kat leger i solen. en model tester data.',
]
BLOCK = 24
DIM = 32
PROMPT = 'en model '


def vocabulary(train_documents=TRAIN):
    return sorted(set(''.join(train_documents)))


def data_overlap(train_documents, validation_documents):
    """Count exact 12-character validation windows found in any training document."""
    width = 12
    seen = {doc[i:i + width] for doc in train_documents for i in range(max(0, len(doc) - width + 1))}
    per_document = []
    for doc in validation_documents:
        total = max(0, len(doc) - width + 1)
        matched = sum(doc[i:i + width] in seen for i in range(total))
        per_document.append({'matched': matched, 'windows': total})
    return {'width': width, 'documents': per_document}


def validate_data(train_documents, validation_documents, prompt):
    for label, docs in (('train', train_documents), ('validation', validation_documents)):
        if not isinstance(docs, list) or not 1 <= len(docs) <= 20:
            raise ValueError(f'{label} skal vaere en liste med 1–20 tekster.')
        if any(not isinstance(doc, str) or len(doc) <= BLOCK or len(doc) > 2000 or any(0xD800 <= ord(c) <= 0xDFFF for c in doc) for doc in docs):
            raise ValueError(f'Hver {label}-tekst skal have 25–2000 gyldige tegn.')
    if sum(map(len, train_documents + validation_documents)) > 12000:
        raise ValueError('De samlede tekster maa hoejst have 12000 tegn.')
    if set(train_documents) & set(validation_documents):
        raise ValueError('En hel tekst maa ikke vaere identisk i traening og validering.')
    vocab = vocabulary(train_documents)
    if not 2 <= len(vocab) <= 256:
        raise ValueError('Traeningsteksterne skal indeholde 2–256 forskellige tegn.')
    unknown = sorted(set(''.join(validation_documents)) - set(vocab))
    if unknown:
        raise ValueError('Valideringen har ukendte tegn: ' + repr(''.join(unknown)))
    if not isinstance(prompt, str) or not 1 <= len(prompt) <= 500 or not set(prompt).issubset(vocab):
        raise ValueError('Prompten skal have 1–500 tegn fra traeningens ordforraad. Brug --prompt til at vaelge en anden.')
    return vocab


def read_data(path):
    if path.stat().st_size > 100000:
        raise ValueError('Datafilen maa hoejst vaere 100 KB.')
    obj = json.loads(path.read_text(encoding='utf-8'))
    if not isinstance(obj, dict) or not {'train','validation'}.issubset(obj) or not set(obj).issubset({'train','validation','prompt'}):
        raise ValueError('Datafilen skal indeholde listerne train og validation og eventuelt prompt.')
    return obj['train'], obj['validation'], obj.get('prompt')


def windows(documents, vocab):
    ids = {c:i for i,c in enumerate(vocab)}
    result = []
    for doc in documents:
        if not set(doc).issubset(ids):
            raise ValueError('Valideringen indeholder tegn uden for traeningens ordforraad.')
        seq = [ids[c] for c in doc]
        for i in range(len(seq) - BLOCK):
            result.append(seq[i:i + BLOCK + 1])
    if not result:
        raise ValueError('Ingen tekstvinduer.')
    return torch.tensor(result, dtype=torch.long)


class TextTransformer(nn.Module):
    def __init__(self, vocab_size, output_vocab=None):
        super().__init__()
        self.token = nn.Embedding(vocab_size, DIM)
        self.position = nn.Embedding(BLOCK, DIM)
        self.qkv = nn.Linear(DIM, 3 * DIM, bias=False)
        self.project = nn.Linear(DIM, DIM)
        self.ln1 = nn.LayerNorm(DIM)
        self.ln2 = nn.LayerNorm(DIM)
        self.mlp = nn.Sequential(nn.Linear(DIM, 2 * DIM), nn.GELU(), nn.Linear(2 * DIM, DIM))
        self.output = nn.Linear(DIM, vocab_size if output_vocab is None else output_vocab)

    def forward(self, tokens):
        length = tokens.shape[1]
        x = self.token(tokens) + self.position(torch.arange(length, device=tokens.device))
        q, k, v = self.qkv(self.ln1(x)).chunk(3, dim=-1)
        scores = q @ k.transpose(-1, -2) / math.sqrt(DIM)
        mask = torch.ones(length, length, dtype=torch.bool, device=tokens.device).triu(1)
        x = x + self.project(scores.masked_fill(mask, float('-inf')).softmax(-1) @ v)
        x = x + self.mlp(self.ln2(x))
        return self.output(x)


@torch.no_grad()
def evaluate(model, data):
    model.eval()
    total, count = 0.0, 0
    for batch in data.split(64):
        logits = model(batch[:, :-1])
        n = batch[:, 1:].numel()
        total += F.cross_entropy(logits.reshape(-1, logits.shape[-1]), batch[:, 1:].reshape(-1), reduction='sum').item()
        count += n
    return total / count


@torch.no_grad()
def validation_loss_by_position(model, data):
    """Mean cross-entropy at each position across every validation window."""
    model.eval()
    totals = torch.zeros(BLOCK, dtype=torch.float64)
    count = 0
    for batch in data.split(64):
        logits = model(batch[:, :-1])
        losses = F.cross_entropy(logits.transpose(1, 2), batch[:, 1:], reduction='none')
        totals += losses.double().sum(dim=0)
        count += len(batch)
    return (totals / count).tolist()


@torch.no_grad()
def compare_validation_contexts(model, data):
    """Same final target per window; compare trailing contexts against one character."""
    model.eval()
    totals = torch.zeros(BLOCK, dtype=torch.float64)
    better = [0] * BLOCK
    worse = [0] * BLOCK
    count = 0
    for batch in data.split(64):
        target = batch[:, -1]
        reference = None
        for length in range(1, BLOCK + 1):
            logits = model(batch[:, BLOCK-length:BLOCK])[:, -1, :]
            loss = F.cross_entropy(logits, target, reduction='none')
            if reference is None:
                reference = loss
            totals[length-1] += loss.double().sum().item()
            better[length-1] += int((loss < reference - 1e-6).sum().item())
            worse[length-1] += int((loss > reference + 1e-6).sum().item())
        count += len(batch)
    return [{'length': i+1, 'mean_loss': (totals[i]/count).item(),
             'better': better[i], 'worse': worse[i], 'same': count-better[i]-worse[i]}
            for i in range(BLOCK)]


@torch.no_grad()
def paired_context_examples(model, data, vocab):
    """Inspect first and extreme paired differences, selected after measurement."""
    model.eval()
    deltas = []
    for batch in data.split(64):
        target = batch[:, -1]
        short = F.cross_entropy(model(batch[:, BLOCK-1:BLOCK])[:, -1, :], target, reduction='none')
        long = F.cross_entropy(model(batch[:, :BLOCK])[:, -1, :], target, reduction='none')
        deltas.extend((long-short).tolist())
    indexes = [0, min(range(len(deltas)), key=deltas.__getitem__), max(range(len(deltas)), key=deltas.__getitem__)]
    result = []
    for role, index in zip(('first', 'minimum', 'maximum'), indexes):
        window = data[index:index+1]
        measurements = []
        for length in range(1, BLOCK+1):
            logits = model(window[:, BLOCK-length:BLOCK])[:, -1, :]
            loss = F.cross_entropy(logits, window[:, -1]).item()
            measurements.append({'loss': loss, 'prediction': vocab[int(logits.argmax(dim=-1).item())]})
        result.append({'role': role, 'window_index': index,
                       'text': ''.join(vocab[int(i)] for i in window[0]), 'measurements': measurements})
    return result


@torch.no_grad()
def sample(model, vocab, prompt=PROMPT, n=60):
    model.eval()
    lookup = {c:i for i,c in enumerate(vocab)}
    ids = [lookup[c] for c in prompt]
    for _ in range(n):
        x = torch.tensor([ids[-BLOCK:]], dtype=torch.long)
        ids.append(int(model(x)[0, -1].argmax()))
    return ''.join(vocab[i] for i in ids)


@torch.no_grad()
def next_probabilities(model, vocab, prompt):
    """Distribution for one fixed prompt, measured at the current checkpoint."""
    model.eval()
    lookup = {c: i for i, c in enumerate(vocab)}
    ids = torch.tensor([[lookup[c] for c in prompt[-BLOCK:]]], dtype=torch.long)
    return model(ids)[0, -1].softmax(dim=-1).tolist()


def following_counts(documents, vocab, context):
    """Count exact raw-text occurrences followed by a character, including overlaps."""
    lookup = {c: i for i, c in enumerate(vocab)}
    counts = [0] * len(vocab)
    for doc in documents:
        for i in range(len(doc) - len(context)):
            if doc.startswith(context, i):
                counts[lookup[doc[i + len(context)]]] += 1
    return counts


def run(steps, seed, lr=0.003, train_documents=TRAIN, validation_documents=VALIDATION, prompt=PROMPT, compare_context=False):
    torch.set_num_threads(1); torch.manual_seed(seed)
    vocab = validate_data(train_documents, validation_documents, prompt); train = windows(train_documents, vocab); val = windows(validation_documents, vocab)
    model = TextTransformer(len(vocab)); optim = torch.optim.AdamW(model.parameters(), lr=lr)
    generator = torch.Generator().manual_seed(seed + 1)
    # Keep each document's windows together; the aggregate weights documents by window count.
    val_parts = []
    offset = 0
    for doc in validation_documents:
        count = len(doc) - BLOCK
        val_parts.append(val[offset:offset + count])
        offset += count
    before_by_document = [evaluate(model, part) for part in val_parts]
    before = sample(model, vocab, prompt); history = []
    for step in range(steps + 1):
        if step % 20 == 0 or step == steps:
            row = {'step': step, 'train_loss': evaluate(model, train), 'validation_loss': evaluate(model, val),
                   'next_probs': next_probabilities(model, vocab, prompt)}
            history.append(row)
            print(f"{step:4d} | traening {row['train_loss']:.3f} | validering {row['validation_loss']:.3f}", flush=True)
        if step == steps: break
        model.train(); batch = train[torch.randint(len(train), (32,), generator=generator)]
        logits = model(batch[:, :-1]); loss = F.cross_entropy(logits.reshape(-1, len(vocab)), batch[:, 1:].reshape(-1))
        optim.zero_grad(); loss.backward(); optim.step()
    paired_contexts = compare_validation_contexts(model, val) if compare_context else None
    return {'format':'learning-lab-text-transformer-v1', 'steps':steps, 'seed':seed,
            'torch_version':str(torch.__version__), 'lr':lr,
            'data_sha256':hashlib.sha256(json.dumps({'train':train_documents,'validation':validation_documents},ensure_ascii=False,sort_keys=True).encode('utf-8')).hexdigest(),
            'script_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), 'vocab': ''.join(vocab), 'block':BLOCK,
            'train_documents':len(train_documents), 'validation_documents':len(validation_documents),
            'data_overlap':data_overlap(train_documents, validation_documents),
            'validation_document_losses':[{'windows':len(part), 'before':initial, 'after':evaluate(model, part)} for part,initial in zip(val_parts,before_by_document)],
            'prompt_follow_counts': {'train':following_counts(train_documents,vocab,prompt[-BLOCK:]),
                                     'validation':following_counts(validation_documents,vocab,prompt[-BLOCK:])},
            'train_windows':len(train), 'validation_windows':len(val), 'history':history,
            'validation_loss_by_position':validation_loss_by_position(model, val),
            **({'paired_contexts': paired_contexts, 'paired_examples': paired_context_examples(model, val, vocab)} if paired_contexts is not None else {}),
            'prompt':prompt, 'before':before, 'after':sample(model, vocab, prompt)}, model


def main():
    parser=argparse.ArgumentParser(description='Traen en lille transformer paa tegn i smaa teksteksempler.')
    parser.add_argument('--steps',type=int,default=200);parser.add_argument('--seed',type=int,default=7);parser.add_argument('--lr',type=float,default=0.003);parser.add_argument('--data',type=Path);parser.add_argument('--prompt');parser.add_argument('--output-dir',type=Path)
    parser.add_argument('--compare-context', action='store_true', help='Maal samme valideringsfacit med forskellige kontekstlaengder efter traening.')
    args=parser.parse_args()
    if not 1<=args.steps<=2000 or not 0<=args.seed<2**32-1 or not math.isfinite(args.lr) or not 0<args.lr<=0.05:
        parser.error('Vaelg 1–2000 skridt, seed fra 0 til 2³²−2 og laeringsrate over 0 og hoejst 0.05.')
    try:
        train_documents,validation_documents,data_prompt=read_data(args.data) if args.data else (TRAIN,VALIDATION,None)
        prompt=args.prompt if args.prompt is not None else data_prompt if data_prompt is not None else PROMPT
        validate_data(train_documents,validation_documents,prompt)
    except (OSError,UnicodeError,ValueError,json.JSONDecodeError) as exc: parser.error(str(exc))
    output=args.output_dir or Path('text-transformer-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,model=run(args.steps,args.seed,args.lr,train_documents,validation_documents,prompt,compare_context=args.compare_context)
    model_path=output/'model.pt'
    torch.save(model.state_dict(),model_path)
    result['model_sha256']=hashlib.sha256(model_path.read_bytes()).hexdigest()
    (output/'text-result.json').write_text(json.dumps(result,ensure_ascii=False,indent=2),encoding='utf-8')
    print('Foer:',result['before']);print('Efter:',result['after']);print('Gemt i',output)
    print('Resultatfil til Learning Lab:',output/'text-result.json')

if __name__=='__main__':
    main()
