#!/usr/bin/env python3
"""Train a small Top-K SAE on held-constant TinyTransformer final residual activations."""
import argparse
import hashlib
import json
import math
from datetime import datetime, timezone
from pathlib import Path

import torch
from torch import nn
from torch.nn import functional as F
from transformer import TinyTransformer, DIM, data

FEATURES = 48


class TopKSAE(nn.Module):
    def __init__(self, k):
        super().__init__()
        self.encoder = nn.Linear(DIM, FEATURES)
        self.decoder = nn.Linear(FEATURES, DIM)
        self.k = k

    def forward(self, x):
        positive = F.relu(self.encoder(x))
        values, indices = torch.topk(positive, self.k, dim=-1)
        features = torch.zeros_like(positive).scatter(-1, indices, values)
        return self.decoder(features), features


def capture(model, tokens):
    activations = []
    def hook(_module, args):
        activations.append(args[0].detach().clone())
    handle = model.output.register_forward_pre_hook(hook)
    try:
        with torch.no_grad(): logits, _ = model(tokens)
    finally:
        handle.remove()
    if len(activations) != 1:
        raise RuntimeError('Forventede ét input til outputlaget.')
    return activations[0], logits.detach()


def metrics(model, sae, train_acts, acts, original_logits, labels):
    with torch.no_grad():
        reconstruction, features = sae(acts)
        reconstructed_logits = model.output(reconstruction)
        identity_logits = model.output(acts)
        mse = F.mse_loss(reconstruction, acts).item()
        baseline = F.mse_loss(train_acts.mean(0).expand_as(acts), acts).item()
        original_accuracy = (original_logits.argmax(-1) == labels).float().mean().item()
        restored_accuracy = (reconstructed_logits.argmax(-1) == labels).float().mean().item()
        agreement = (reconstructed_logits.argmax(-1) == original_logits.argmax(-1)).float().mean().item()
        return {'mse':mse,'mean_baseline_mse':baseline,'active_mean':(features>0).float().sum(-1).mean().item(),
                'inactive_features':int(((features>0).sum(0)==0).sum()),'original_accuracy':original_accuracy,
                'reconstructed_accuracy':restored_accuracy,'agreement':agreement,
                'identity_max_error':(identity_logits-original_logits).abs().max().item()}


def run(model, k, steps, seed):
    torch.manual_seed(seed)
    train, val = data()
    train_acts, train_logits = capture(model, train[0])
    val_acts, val_logits = capture(model, val[0])
    sae = TopKSAE(k)
    optim = torch.optim.Adam(sae.parameters(), lr=.005)
    for _ in range(steps):
        optim.zero_grad(); reconstructed, _ = sae(train_acts)
        loss = F.mse_loss(reconstructed, train_acts)
        loss.backward(); optim.step()
    sae.eval()
    with torch.no_grad():
        _, train_features = sae(train_acts)
        _, val_features = sae(val_acts)
        features=[]
        for i in range(FEATURES):
            values=train_features[:,i]; order=torch.argsort(values,descending=True)
            top=[{'first':int(train[0][j,0]),'second':int(train[0][j,1]),'activation':float(values[j])} for j in order[:3] if values[j]>0]
            features.append({'index':i,'train_frequency':float((values>0).float().mean()),'validation_frequency':float((val_features[:,i]>0).float().mean()),'top_train':top})
    report={'format':'learning-lab-sae-v1','k':k,'feature_count':FEATURES,'dimension':DIM,'steps':steps,'seed':seed,
            'train_count':len(train_acts),'validation_count':len(val_acts),'torch_version':str(torch.__version__),
            'train':metrics(model,sae,train_acts,train_acts,train_logits,train[1]),
            'validation':metrics(model,sae,train_acts,val_acts,val_logits,val[1]),'features':features}
    return sae, report


def main():
    parser=argparse.ArgumentParser(description='Træn en lille Top-K sparse autoencoder på en fast transformer.')
    parser.add_argument('--model',type=Path,required=True);parser.add_argument('--k',type=int,default=4)
    parser.add_argument('--steps',type=int,default=800);parser.add_argument('--seed',type=int,default=7);parser.add_argument('--output-dir',type=Path)
    args=parser.parse_args()
    if not args.model.is_file():parser.error(f'Modelfilen findes ikke: {args.model}')
    if not 1<=args.k<=16 or not 1<=args.steps<=5000 or not 0<=args.seed<2**32:parser.error('Vælg k 1–16, 1–5000 skridt og et seed fra 0 til 2³²−1.')
    if args.output_dir and args.output_dir.exists():parser.error(f'Outputmappen findes allerede: {args.output_dir}')
    torch.set_num_threads(1);model=TinyTransformer()
    try:model.load_state_dict(torch.load(args.model,map_location='cpu',weights_only=True))
    except Exception as exc:parser.error(f'Kunne ikke indlæse modelvægtene: {exc}')
    model.eval();model.requires_grad_(False)
    sae,report=run(model,args.k,args.steps,args.seed)
    if any(not math.isfinite(float(value)) for split in ('train','validation') for value in report[split].values()):raise SystemExit('Mindst én måling er ikke endelig.')
    report['model_sha256']=hashlib.sha256(args.model.read_bytes()).hexdigest()
    output=args.output_dir or Path('sae-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}')
    torch.save(sae.state_dict(),output/'sae.pt')
    report['sae_sha256']=hashlib.sha256((output/'sae.pt').read_bytes()).hexdigest()
    (output/'sae.json').write_text(json.dumps(report,ensure_ascii=False,indent=2),encoding='utf-8')
    print(f"Validering: rekonstruktions-MSE {report['validation']['mse']:.4f}, middelværdi-baseline {report['validation']['mean_baseline_mse']:.4f}, gennemsnitligt aktive features {report['validation']['active_mean']:.2f}.")
    print(f"Nøjagtighed før/efter rekonstruktion: {report['validation']['original_accuracy']:.1%} / {report['validation']['reconstructed_accuracy']:.1%}. Gemt i {output}.")


if __name__=='__main__':main()
