#!/usr/bin/env python3
"""Learn the Machine: train a tiny XOR classifier with real PyTorch on the CPU."""
import argparse
import csv
import hashlib
import json
import math
import platform
import sys
from datetime import datetime, timezone
from pathlib import Path

try:
    import torch
    from torch import nn
except ImportError as exc:
    raise SystemExit("PyTorch mangler. Se installationsvejledningen på Learn the Machine-siden.") from exc


def make_data(count, seed):
    """Draw independent synthetic inputs; label = signs differ (XOR)."""
    generator = torch.Generator(device="cpu").manual_seed(seed)
    x = 2 * torch.rand((count, 2), generator=generator) - 1
    y = ((x[:, 0] > 0) != (x[:, 1] > 0)).float().unsqueeze(1)
    return x, y


def dataset_sha256(data):
    """Hash tensor dtype, shape and raw CPU bytes in a fixed field order."""
    digest = hashlib.sha256(b'learning-lab-dataset-v1\0')
    for tensor in data:
        value = tensor.detach().cpu().contiguous()
        descriptor = json.dumps({'dtype': str(value.dtype), 'shape': list(value.shape)}, sort_keys=True, separators=(',', ':')).encode('ascii')
        digest.update(descriptor + b'\0')
        digest.update(bytes(value.view(torch.uint8).reshape(-1).tolist()))
    return digest.hexdigest()


def metrics(model, data, criterion):
    model.eval()
    x, y = data
    with torch.no_grad():
        logits = model(x)
        loss = criterion(logits, y).item()
        accuracy = ((logits >= 0).float() == y).float().mean().item()
    return loss, accuracy


def write_svg(rows, filename):
    """Export a standalone graph without plotting dependencies."""
    width, height, left, right, top, bottom = 760, 380, 70, 30, 35, 65
    plot_w, plot_h = width - left - right, height - top - bottom
    max_step = max(1, rows[-1]["step"])
    max_loss = max(0.01, max(max(row["train_loss"], row["val_loss"]) for row in rows)) * 1.05
    def point(step, loss):
        return f'{left + plot_w * step / max_step:.2f},{top + plot_h * (1-loss/max_loss):.2f}'
    train_points = ' '.join(point(r['step'], r['train_loss']) for r in rows)
    val_points = ' '.join(point(r['step'], r['val_loss']) for r in rows)
    svg = f'''<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}" role="img" aria-label="Trænings- og valideringstab over træningsskridt">
<rect width="100%" height="100%" fill="#fafbf7"/><g font-family="sans-serif" fill="#314b38" font-size="13"><text x="{left}" y="20" font-size="16">Træningstab og valideringstab (log loss)</text><text x="{left}" y="{height-18}">0</text><text x="{width-right-30}" y="{height-18}">{max_step}</text><text x="{width/2-20}" y="{height-18}">skridt</text><text x="8" y="{top+10}">{max_loss:.2f}</text><text x="27" y="{top+plot_h}">0</text><text x="{left+12}" y="{top+20}" fill="#42754d">● træning</text><text x="{left+100}" y="{top+20}" fill="#c27a50">● validering</text></g><path d="M {left} {top} V {top+plot_h} H {left+plot_w}" fill="none" stroke="#aab8a7"/><polyline points="{train_points}" fill="none" stroke="#42754d" stroke-width="3"/><polyline points="{val_points}" fill="none" stroke="#c27a50" stroke-width="3"/></svg>'''
    filename.write_text(svg, encoding='utf-8')


def main():
    parser = argparse.ArgumentParser(description="Træn og evaluér et lille neuralt netværk på CPU.")
    parser.add_argument('--steps', type=int, default=500, help='Antal gradientopdateringer (standard: 500)')
    parser.add_argument('--lr', type=float, default=0.15, help='Læringsrate (standard: 0.15)')
    parser.add_argument('--seed', type=int, default=7, help='Startvægt-seed (standard: 7)')
    parser.add_argument('--output-dir', type=Path, default=None, help='Ny mappe til dette forsøg; må ikke eksistere')
    parser.add_argument('--final-test', action='store_true', help='Mål på et separat syntetisk testsæt; gem til afsluttende evaluering')
    args = parser.parse_args()
    if not 1 <= args.steps <= 100000 or not math.isfinite(args.lr) or not 0 < args.lr <= 10 or not 0 <= args.seed < 2**32:
        parser.error('Vælg 1–100000 skridt, en endelig læringsrate mellem 0 og 10, og et seed mellem 0 og 2³²-1.')
    output = args.output_dir or Path('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}. Vælg en ny mappe for ikke at overskrive et tidligere forsøg.')

    source_sha256 = hashlib.sha256(Path(__file__).read_bytes()).hexdigest()
    torch.set_num_threads(1)
    torch.manual_seed(args.seed)
    # These split seeds differ from each other and remain fixed between experiments.
    train = make_data(256, 104729)
    validation = make_data(128, 104759)
    model = nn.Sequential(nn.Linear(2, 8), nn.Tanh(), nn.Linear(8, 1))
    criterion = nn.BCEWithLogitsLoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=args.lr)
    rows = []
    def record(step):
        train_loss, train_acc = metrics(model, train, criterion)
        val_loss, val_acc = metrics(model, validation, criterion)
        if not all(math.isfinite(x) for x in (train_loss, train_acc, val_loss, val_acc)):
            raise RuntimeError('Ikke-endelig måling: prøv en mindre læringsrate.')
        rows.append(dict(step=step, train_loss=train_loss, train_acc=train_acc, val_loss=val_loss, val_acc=val_acc))
        print(f'{step:5d} | tab: {train_loss:.4f} / {val_loss:.4f} | nøjagtighed: {train_acc:.1%} / {val_acc:.1%}')
    print('skridt | træningstab / valideringstab | træning / validering')
    record(0)
    for step in range(1, args.steps + 1):
        model.train()
        optimizer.zero_grad()
        logits = model(train[0])
        loss = criterion(logits, train[1])
        loss.backward()
        optimizer.step()
        if step % 50 == 0 or step == args.steps:
            record(step)
    with (output / 'metrics.csv').open('w', encoding='utf-8', newline='') as file:
        writer = csv.DictWriter(file, fieldnames=list(rows[0])); writer.writeheader(); writer.writerows(rows)
    torch.save(model.state_dict(), output / 'model.pt')
    model_sha256 = hashlib.sha256((output / 'model.pt').read_bytes()).hexdigest()
    positions = torch.tensor([i / 10 for i in range(-10, 11)], dtype=torch.float32)
    grid_inputs = torch.tensor([[float(x), float(y)] for y in positions for x in positions], dtype=torch.float32)
    model.eval()
    with torch.no_grad():
        grid_logits = model(grid_inputs).reshape(21, 21)
        grid_scores = torch.sigmoid(grid_logits).tolist()
        hidden = model[1](model[0](grid_inputs))
        identity_logits = model[2](hidden).reshape(21, 21)
        identity_error = (identity_logits - grid_logits).abs().max().item()
        train_hidden = model[1](model[0](train[0]))
        hidden_mean = train_hidden.mean(dim=0)
        interventions = []
        for neuron in range(8):
            masked = hidden.clone()
            masked[:, neuron] = 0
            ablated = model[2](masked).reshape(21, 21)
            mean_replaced = hidden.clone()
            mean_replaced[:, neuron] = hidden_mean[neuron]
            mean_logits = model[2](mean_replaced).reshape(21, 21)
            interventions.append({'neuron': neuron, 'logits': ablated.tolist(), 'scores': torch.sigmoid(ablated).tolist(),
                                  'mean_logits': mean_logits.tolist(), 'mean_scores': torch.sigmoid(mean_logits).tolist()})
    grid = {'format': 'learning-lab-xor-grid-v3', 'positions': positions.tolist(), 'scores': grid_scores, 'logits': grid_logits.tolist(),
            'identity_error': identity_error, 'mean_reference': {'split': 'train', 'count': int(train[0].shape[0]), 'values': hidden_mean.tolist()}, 'interventions': interventions,
            'seed': args.seed, 'steps': args.steps, 'model_sha256': model_sha256}
    (output / 'grid.json').write_text(json.dumps(grid, ensure_ascii=False, allow_nan=False), encoding='utf-8')
    write_svg(rows, output / 'loss.svg')
    metadata = {'seed': args.seed, 'steps': args.steps, 'learning_rate': args.lr, 'torch_version': torch.__version__, 'python_version': platform.python_version(), 'device': 'cpu', 'train_seed': 104729, 'validation_seed': 104759, 'final_validation': rows[-1], 'test_used': args.final_test}
    metadata.update({'model_sha256': model_sha256, 'source_sha256': source_sha256, 'train_data_sha256': dataset_sha256(train), 'validation_data_sha256': dataset_sha256(validation)})
    if args.final_test:
        test_loss, test_acc = metrics(model, make_data(256, 104761), criterion)
        metadata['test'] = {'loss': test_loss, 'accuracy': test_acc, 'seed': 104761}
        print(f'Slutevaluering: tab {test_loss:.4f}, nøjagtighed {test_acc:.1%}. Gentagen brug til modelvalg gør det til validering.')
    (output / 'metadata.json').write_text(json.dumps(metadata, indent=2, ensure_ascii=False), encoding='utf-8')
    print(f'Resultater gemt i {output}: metrics.csv, loss.svg, model.pt, grid.json og metadata.json')


if __name__ == '__main__':
    main()
