#!/usr/bin/env python3
"""Åbne kontroller og træning af en lille næste-tegn-model med elevens kode."""
import argparse
import hashlib
import json
import math
from pathlib import Path
import sys

import torch
import torch.nn.functional as F

try:
    from mit_naeste_token import train_step
except Exception as exc:
    raise SystemExit(f'Kunne ikke læse mit_naeste_token.py: {type(exc).__name__}: {exc}') from exc

VOCAB = [' ', 'a', 'k', 'n', 't']
TRAIN = ['kat kan kat kan', 'kan kat kan kat']
VALIDATION = ['kat kan']


def scalar(value):
    if isinstance(value, torch.Tensor):
        if value.numel() != 1:
            raise ValueError('Returnér ét tal for tabet før opdateringen.')
        value = value.detach().item()
    if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
        raise ValueError('Returnér ét endeligt tal for tabet før opdateringen.')
    return float(value)


def make_model(initial):
    model = torch.nn.Embedding(len(VOCAB), len(VOCAB), dtype=torch.float64)
    with torch.no_grad():
        model.weight.copy_(initial)
    return model


def check():
    cases = [([2, 2, 1, 3], [1, 2, 3, 0], .13), ([4, 0, 4], [0, 2, 1], .07)]
    initial = torch.arange(25, dtype=torch.float64).reshape(5, 5) * .03 - .3
    for xs, ys, rate in cases:
        model = make_model(initial)
        optimizer = torch.optim.SGD(model.parameters(), lr=rate)
        model.weight.grad = torch.full_like(model.weight, .75)
        # Independent scalar softmax and gradient, including repeated contexts.
        expected = initial.tolist()
        gradient = [[0.] * len(VOCAB) for _ in VOCAB]
        losses = []
        for context, target in zip(xs, ys):
            logits = initial[context].tolist()
            exps = [math.exp(z - max(logits)) for z in logits]
            probs = [v / sum(exps) for v in exps]
            losses.append(-math.log(probs[target]))
            for index, p in enumerate(probs):
                gradient[context][index] += (p - (index == target)) / len(xs)
        for context in range(len(VOCAB)):
            for target in range(len(VOCAB)):
                expected[context][target] -= rate * gradient[context][target]
        try:
            observed = scalar(train_step(model, optimizer, torch.tensor(xs), torch.tensor(ys)))
            expected_loss = sum(losses) / len(losses)
            if not math.isclose(observed, expected_loss, rel_tol=1e-7, abs_tol=1e-7):
                with torch.no_grad():
                    after_loss = F.cross_entropy(model(torch.tensor(xs)), torch.tensor(ys)).item()
                if not math.isclose(after_loss, expected_loss, rel_tol=1e-7, abs_tol=1e-7) and math.isclose(observed, after_loss, rel_tol=1e-7, abs_tol=1e-7):
                    raise ValueError(f'Du returnerede tabet efter opdateringen ({observed:.6f}); returnér tabet før ({expected_loss:.6f}).')
                raise ValueError(f'Tabet før opdateringen var {observed:.6f}, men forventet gennemsnitlig cross-entropy er {expected_loss:.6f}. Brug rå logits og facit-ID’er.')
            expected_weights = torch.tensor(expected, dtype=torch.float64)
            actual_weights = model.weight.detach()
            if not torch.allclose(actual_weights, expected_weights, rtol=1e-7, atol=1e-7):
                if torch.equal(actual_weights, initial):
                    raise ValueError('Vægtene blev ikke opdateret. Kontrollér backward() og optimizer.step().')
                if torch.allclose(actual_weights, expected_weights - rate * .75, rtol=1e-7, atol=1e-7):
                    raise ValueError('Opdateringen indeholder de gamle gradienter fra kontrollen. Ryd dem før backward().')
                difference = (actual_weights - expected_weights).abs().max().item()
                raise ValueError(f'Opdateringen matcher ikke den analytiske gradient; største vægtafvigelse er {difference:.6g}.')
        except Exception as exc:
            print(f'PRØV IGEN · {type(exc).__name__}: {exc}')
            print('Tjek gamle gradienter, rå logits, facit-ID’er og at tabet returneres før opdateringen.')
            return False
    print('BESTÅET · to åbne kontroller. De beviser ikke, at koden virker i alle situationer.')
    return True


def pairs(documents):
    lookup = {char: index for index, char in enumerate(VOCAB)}
    xs, ys = [], []
    for text in documents:
        ids = [lookup[char] for char in text]
        xs.extend(ids[:-1])
        ys.extend(ids[1:])
    return torch.tensor(xs, dtype=torch.long), torch.tensor(ys, dtype=torch.long)


def train():
    model = make_model(torch.zeros((5, 5), dtype=torch.float64))
    optimizer = torch.optim.SGD(model.parameters(), lr=4.)
    x, y = pairs(TRAIN)
    vx, vy = pairs(VALIDATION)
    counts = torch.bincount(x * len(VOCAB) + y, minlength=len(VOCAB)**2).reshape(len(VOCAB), len(VOCAB)).tolist()
    rows = []
    for step in range(81):
        with torch.no_grad():
            train_loss = F.cross_entropy(model(x), y).item()
            validation_loss = F.cross_entropy(model(vx), vy).item()
            context_probs = model(torch.arange(len(VOCAB))).softmax(dim=-1).tolist()
            probs = context_probs[VOCAB.index('k')]
        if not all(math.isfinite(v) for v in (train_loss, validation_loss, *probs)):
            raise ValueError('Modellen eller tabet er ikke endeligt.')
        if step % 10 == 0:
            rows.append({'step': step, 'train_loss': train_loss, 'validation_loss': validation_loss,
                         'probabilities': probs, 'context_probabilities': context_probs})
        if step < 80:
            scalar(train_step(model, optimizer, x, y))
    return rows, counts


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output', type=Path, default=Path('naeste-token-result.json'))
    args = parser.parse_args()
    if args.output.exists():
        parser.error('Resultatfilen findes allerede; vælg et nyt navn med --output.')
    torch.set_num_threads(1)
    if not check():
        return 1
    try:
        rows, counts = train()
        result = {'format': 'learning-lab-pytorch-next-token-v1', 'torch_version': str(torch.__version__),
                  'exercise_sha256': hashlib.sha256(Path(__file__).resolve().with_name('mit_naeste_token.py').read_bytes()).hexdigest(),
                  'vocab': VOCAB, 'context': 'k', 'target': 'a', 'train_counts': counts, 'rows': rows}
        serialized = json.dumps(result, ensure_ascii=False, indent=2, allow_nan=False) + '\n'
    except Exception as exc:
        print(f'TRÆNING STOPPET · {type(exc).__name__}: {exc}. Ingen ny resultatfil blev skrevet.')
        return 1
    try:
        with args.output.open('x', encoding='utf-8') as file:
            file.write(serialized)
    except OSError as exc:
        print(f'KUNNE IKKE GEMME · {exc}. En delvis fil kan findes; eksisterende filer overskrives ikke.')
        return 1
    a = VOCAB.index('a')
    print(f"P(a | k): {rows[0]['probabilities'][a]:.2%} → {rows[-1]['probabilities'][a]:.2%}")
    print(f"Træningstab: {rows[0]['train_loss']:.4g} → {rows[-1]['train_loss']:.4g}")
    print(f"Valideringstab: {rows[0]['validation_loss']:.4g} → {rows[-1]['validation_loss']:.4g}")
    print(f'Gemt: {args.output}. Åbn filen i Learn the Machine.')
    print('Valideringsteksten deler alle tegnpar med træningen og er ikke en bred test af generalisering.')
    return 0


if __name__ == '__main__':
    sys.exit(main())
