#!/usr/bin/env python3
"""Åbne kontroller og en lille træningskørsel med elevens PyTorch-funktion."""
import argparse
import hashlib
import json
import math
from pathlib import Path
import sys

import torch

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


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(weight, bias):
    model = torch.nn.Linear(1, 1, dtype=torch.float64)
    with torch.no_grad():
        model.weight.fill_(weight)
        model.bias.fill_(bias)
    return model


def check():
    cases = [([-2., 0., 1.], [1., -1., 2.], 0.7, -0.2, 0.05),
             ([0.5, 2.], [-1., 3.], -0.4, 0.8, 0.1)]
    for xs, ys, weight, bias, rate in cases:
        model = make_model(weight, bias)
        optimizer = torch.optim.SGD(model.parameters(), lr=rate)
        x = torch.tensor(xs, dtype=torch.float64).reshape(-1, 1)
        y = torch.tensor(ys, dtype=torch.float64).reshape(-1, 1)
        # A stale gradient reveals missing clearing; formula is independent of autograd.
        for parameter in model.parameters():
            parameter.grad = torch.full_like(parameter, 3.0)
        errors = [weight * a + bias - b for a, b in zip(xs, ys)]
        expected_loss = sum(e * e for e in errors) / len(errors)
        expected_weight = weight - rate * sum(2 * e * a for e, a in zip(errors, xs)) / len(errors)
        expected_bias = bias - rate * sum(2 * e for e in errors) / len(errors)
        try:
            observed = scalar(train_step(model, optimizer, x, y))
            got_weight, got_bias = model.weight.item(), model.bias.item()
            if not all(math.isclose(a, b, rel_tol=1e-7, abs_tol=1e-7) for a, b in
                       ((observed, expected_loss), (got_weight, expected_weight), (got_bias, expected_bias))):
                raise ValueError(f'Forventet tab {expected_loss:.5f}, vægt {expected_weight:.5f}, bias {expected_bias:.5f}; fik {observed:.5f}, {got_weight:.5f}, {got_bias:.5f}.')
        except Exception as exc:
            print(f'PRØV IGEN · {type(exc).__name__}: {exc}')
            print('Tjek rækkefølgen, at gamle gradienter ryddes, og at du returnerer tabet før opdateringen.')
            return False
    print('BESTÅET · to åbne kontroller. De beviser ikke, at funktionen virker i alle situationer.')
    return True


def train():
    model = make_model(-0.75, 0.2)
    optimizer = torch.optim.SGD(model.parameters(), lr=0.08)
    x = torch.tensor([[-2.], [-1.], [0.], [1.], [2.]], dtype=torch.float64)
    y = 2 * x + 1
    vx = torch.tensor([[-1.5], [0.5], [3.]], dtype=torch.float64)
    vy = 2 * vx + 1
    rows = []
    for step in range(81):
        with torch.no_grad():
            train_loss = torch.mean((model(x) - y) ** 2).item()
            validation_loss = torch.mean((model(vx) - vy) ** 2).item()
            weight, bias = model.weight.item(), model.bias.item()
        if not all(math.isfinite(v) for v in (train_loss, validation_loss, weight, bias)):
            raise ValueError('Modellen eller tabet er ikke endeligt.')
        if step % 10 == 0:
            rows.append({'step': step, 'train_loss': train_loss, 'validation_loss': validation_loss,
                         'weight': weight, 'bias': bias})
        if step < 80:
            scalar(train_step(model, optimizer, x, y))
    return rows


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output', type=Path, default=Path('pytorch-step-result.json'))
    args = parser.parse_args()
    if args.output.exists():
        parser.error('Resultatfilen findes allerede; vælg et nyt navn med --output.')
    if not check():
        return 1
    try:
        rows = train()
        result = {'format': 'learning-lab-pytorch-step-v1', 'torch_version': str(torch.__version__),
                  'exercise_sha256': hashlib.sha256(Path(__file__).resolve().with_name('mit_pytorch_skridt.py').read_bytes()).hexdigest(),
                  '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
    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('Data er små og syntetiske; de to kontroller er ikke en fuldstændig kodegennemgang.')
    return 0


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