#!/usr/bin/env python3
"""Compare two toy SAEs on a fixed transformer, using separate example splits."""
import argparse
import hashlib
import json
import math
from pathlib import Path

import torch
from transformer import TinyTransformer, data
from sparse_autoencoder import FEATURES, TopKSAE, capture


def digest(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def correlation(a, b):
    a, b = a.double(), b.double()
    a, b = a - a.mean(), b - b.mean()
    denom = torch.linalg.vector_norm(a) * torch.linalg.vector_norm(b)
    if denom.item() <= 1e-12:
        return None
    return max(-1., min(1., float(torch.dot(a, b) / denom)))


def load_sae(directory, model_hash):
    report_path, weight_path = directory/'sae.json', directory/'sae.pt'
    if report_path.stat().st_size > 65536:
        raise ValueError('SAE-metadata er større end 64 KB.')
    report = json.loads(report_path.read_text(encoding='utf-8'))
    if not isinstance(report, dict) or report.get('format') != 'learning-lab-sae-v1' or type(report.get('k')) is not int or not 1 <= report['k'] <= 16 or type(report.get('steps')) is not int or not 1 <= report['steps'] <= 5000 or type(report.get('seed')) is not int or not 0 <= report['seed'] < 2**32:
        raise ValueError('Ugyldig SAE-metadata.')
    if report.get('model_sha256') != model_hash or report.get('sae_sha256') != digest(weight_path):
        raise ValueError('SAE-filerne matcher ikke hinanden og den valgte model.')
    sae = TopKSAE(report['k'])
    sae.load_state_dict(torch.load(weight_path, map_location='cpu', weights_only=True), strict=True)
    sae.eval()
    return sae, report


def compare(train_a, train_b, val_a, val_b):
    """For each A feature select the largest signed Pearson r on training examples."""
    if any(x.ndim != 2 or x.shape[1] != FEATURES or not torch.isfinite(x).all() for x in (train_a, train_b, val_a, val_b)) or train_a.shape != train_b.shape or val_a.shape != val_b.shape:
        raise ValueError('Ugyldige featureaktiveringer.')
    rows=[]
    for i in range(FEATURES):
        candidates=[(c, j) for j in range(FEATURES) if (c := correlation(train_a[:,i], train_b[:,j])) is not None]
        if not candidates:
            rows.append({'a':i,'b':None,'train_r':None,'validation_r':None})
            continue
        # First feature index wins exact ties; this is not a one-to-one assignment.
        score,j=max(candidates, key=lambda item:(item[0],-item[1]))
        rows.append({'a':i,'b':j,'train_r':score,'validation_r':correlation(val_a[:,i],val_b[:,j]),'validation_a':val_a[:,i].tolist(),'validation_b':val_b[:,j].tolist()})
    return rows


def main():
    p=argparse.ArgumentParser(description='Sammenlign to SAE-kørsler på samme lille transformer.')
    p.add_argument('--model',type=Path,required=True);p.add_argument('--sae-a',type=Path,required=True);p.add_argument('--sae-b',type=Path,required=True);p.add_argument('--output',type=Path,required=True)
    args=p.parse_args()
    if args.output.exists():p.error('Outputfilen findes allerede; vælg et nyt navn.')
    try:
        model_hash=digest(args.model)
        torch.set_num_threads(1)
        model=TinyTransformer();model.load_state_dict(torch.load(args.model,map_location='cpu',weights_only=True),strict=True);model.eval()
        sae_a,meta_a=load_sae(args.sae_a,model_hash);sae_b,meta_b=load_sae(args.sae_b,model_hash)
        if meta_a['k'] != meta_b['k'] or meta_a['steps'] != meta_b['steps'] or meta_a['seed'] == meta_b['seed']:
            raise ValueError('Brug samme k og antal skridt, men forskellige SAE-seeds.')
        train,val=data();train_acts,_=capture(model,train[0]);val_acts,_=capture(model,val[0])
        with torch.no_grad():
            _,train_a=sae_a(train_acts);_,train_b=sae_b(train_acts);_,val_a=sae_a(val_acts);_,val_b=sae_b(val_acts)
        rows=compare(train_a,train_b,val_a,val_b)
        result={'format':'learning-lab-sae-consistency-v1','model_sha256':model_hash,'sae_a_sha256':digest(args.sae_a/'sae.pt'),'sae_b_sha256':digest(args.sae_b/'sae.pt'),'script_sha256':digest(Path(__file__)),'seed_a':meta_a['seed'],'seed_b':meta_b['seed'],'k':meta_a['k'],'steps':meta_a['steps'],'train_count':len(train_acts),'validation_count':len(val_acts),'validation_pairs':val[0][:,:2].tolist(),'torch_version':str(torch.__version__),'rows':rows}
        with args.output.open('x',encoding='utf-8') as f:json.dump(result,f,ensure_ascii=False,indent=2,allow_nan=False);f.write('\n')
    except (OSError,ValueError,RuntimeError,TypeError,KeyError,json.JSONDecodeError) as exc:
        p.exit(1,f'Kunne ikke sammenligne: {exc}\n')
    matched=sum(row['b'] is not None for row in rows);held=sum(row['validation_r'] is not None for row in rows)
    print(f'{matched} af {FEATURES} features i A kunne matches; {held} har defineret valideringskorrelation. Gemt: {args.output}')
    return 0


if __name__=='__main__':
    raise SystemExit(main())
