#!/usr/bin/env python3
"""Remove one SAE feature while preserving the reconstruction error."""
import argparse
import csv
import hashlib
import json
import math
from datetime import datetime, timezone
from pathlib import Path
import torch
from transformer import TinyTransformer, data, DIM
from sparse_autoencoder import TopKSAE, FEATURES, capture


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


def investigate(model, sae, feature):
    _, val=data();tokens,labels=val
    with torch.no_grad():
        residual,original=capture(model,tokens)
        reconstruction,features=sae(residual)
        error=residual-reconstruction
        identity=model.output(reconstruction+error)
        activity=features[:,feature:feature+1]
        direction=sae.decoder.weight[:,feature]
        magnitude=direction.norm()
        generator=torch.Generator(device='cpu').manual_seed(10000+feature)
        random=torch.randn(DIM,generator=generator)
        random=random/random.norm()*magnitude
        changed=model.output(residual-activity*direction)
        control=model.output(residual-activity*random)
        # The competitor is fixed from the original logits, before either intervention.
        competitors=original.clone();competitors.scatter_(1,labels[:,None],float('-inf'))
        competitor=competitors.argmax(-1)
        def margin(logits):return logits.gather(1,labels[:,None]).squeeze(1)-logits.gather(1,competitor[:,None]).squeeze(1)
        baseline_margin=margin(original);feature_delta=margin(changed)-baseline_margin;random_delta=margin(control)-baseline_margin
        active=activity[:,0]>0
        rows=[]
        for i in range(len(labels)):
            rows.append({'first':int(tokens[i,0]),'second':int(tokens[i,1]),'target':int(labels[i]),'competitor':int(competitor[i]),
                         'feature_activation':float(activity[i,0]),'original_prediction':int(original[i].argmax()),
                         'ablated_prediction':int(changed[i].argmax()),'control_prediction':int(control[i].argmax()),
                         'original_margin':float(baseline_margin[i]),'feature_delta':float(feature_delta[i]),'control_delta':float(random_delta[i])})
        def mean_mask(values,mask):return float(values[mask].mean()) if bool(mask.any()) else None
        summary={'count':len(labels),'active_count':int(active.sum()),'identity_max_error':float((identity-original).abs().max()),
                 'original_accuracy':float((original.argmax(-1)==labels).float().mean()),
                 'ablated_accuracy':float((changed.argmax(-1)==labels).float().mean()),
                 'control_accuracy':float((control.argmax(-1)==labels).float().mean()),
                 'changed_count':int((changed.argmax(-1)!=original.argmax(-1)).sum()),
                 'control_changed_count':int((control.argmax(-1)!=original.argmax(-1)).sum()),
                 'feature_delta_mean':float(feature_delta.mean()),'control_delta_mean':float(random_delta.mean()),
                 'feature_delta_active':mean_mask(feature_delta,active),'control_delta_active':mean_mask(random_delta,active),
                 'decoder_norm':float(magnitude),'control_norm':float(random.norm())}
    return summary,rows


def main():
    parser=argparse.ArgumentParser(description='Undersøg et SAE-feature med et kontrolleret indgreb.')
    parser.add_argument('--model',type=Path,required=True);parser.add_argument('--sae-dir',type=Path,required=True)
    parser.add_argument('--feature',type=int,required=True);parser.add_argument('--output-dir',type=Path);args=parser.parse_args()
    if not 0<=args.feature<FEATURES:parser.error(f'Feature skal være mellem 0 og {FEATURES-1}.')
    info=args.sae_dir/'sae.json';weights=args.sae_dir/'sae.pt'
    if not args.model.is_file() or not info.is_file() or not weights.is_file():parser.error('Kontrollér stierne til model.pt og mappen med sae.json og sae.pt.')
    try:
        report=json.loads(info.read_text(encoding='utf-8'))
        if report.get('format')!='learning-lab-sae-v1' or not isinstance(report.get('k'),int) or not 1<=report['k']<=16:raise ValueError('Ugyldig SAE-metadata.')
        if report.get('model_sha256')!=sha256(args.model):raise ValueError('Transformeren matcher ikke SAE-kørslen.')
        if not report.get('sae_sha256'):raise ValueError('Denne gamle SAE-fil har ikke vægt-hash. Træn SAE igen med den opdaterede kode.')
        if report['sae_sha256']!=sha256(weights):raise ValueError('SAE-vægte matcher ikke sae.json.')
    except (OSError,ValueError,json.JSONDecodeError) as exc:parser.error(str(exc))
    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();sae=TopKSAE(report['k'])
    try:
        model.load_state_dict(torch.load(args.model,map_location='cpu',weights_only=True))
        sae.load_state_dict(torch.load(weights,map_location='cpu',weights_only=True))
    except Exception as exc:parser.error(f'Kunne ikke indlæse vægte: {exc}')
    model.eval();sae.eval();summary,rows=investigate(model,sae,args.feature)
    if any(not math.isfinite(v) for r in rows for v in (r['feature_activation'],r['original_margin'],r['feature_delta'],r['control_delta'])):raise SystemExit('Mindst én måling er ikke endelig.')
    output=args.output_dir or Path('sae-intervention-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}')
    result={'format':'learning-lab-sae-intervention-v1','model_sha256':report['model_sha256'],'sae_sha256':report['sae_sha256'],
            'k':report['k'],'feature':args.feature,'split':'validation','random_seed':10000+args.feature,'summary':summary,'rows':rows}
    (output/'intervention.json').write_text(json.dumps(result,ensure_ascii=False,indent=2),encoding='utf-8')
    with (output/'examples.csv').open('w',encoding='utf-8',newline='') as f:
        writer=csv.DictWriter(f,fieldnames=list(rows[0]));writer.writeheader();writer.writerows(rows)
    print(f"Feature {args.feature} er aktiv i {summary['active_count']}/{summary['count']} valideringseksempler. Identitetsafvigelse: {summary['identity_max_error']:.2e}.")
    print(f"Nøjagtighed før / feature fjernet / tilfældig kontrol: {summary['original_accuracy']:.1%} / {summary['ablated_accuracy']:.1%} / {summary['control_accuracy']:.1%}. Gemt i {output}.")

if __name__=='__main__':main()
