#!/usr/bin/env python3
"""Select one head on a discovery sequence and evaluate it on several held-out sequences."""
import argparse
import hashlib
import json
from pathlib import Path

import torch
from transformers import AutoModelForCausalLM
import induction_heads as induction


def validate_seeds(discover, tests):
    all_seeds = [discover, *tests]
    if not 2 <= len(tests) <= 10 or any(not 0 <= seed < 2**32 for seed in all_seeds) or len(set(all_seeds)) != len(all_seeds):
        raise ValueError('Vælg 2–10 forskellige test-seeds og et andet udvælgelsesseed, alle fra 0 til 2³²−1.')


def validate_control(control):
    if control is not None and (len(control) != 2 or any(type(n) is not int for n in control)
                                or not 0 <= control[0] < 6 or not 0 <= control[1] < 8):
        raise ValueError('Kontrolhead skal være et lag fra 0 til 5 og et head fra 0 til 7.')


def replicate(model, discover_seed, test_seeds, control=None):
    validate_seeds(discover_seed, test_seeds)
    validate_control(control)
    base = induction.make_result(model, discover_seed, test_seeds[0])
    if control is not None:
        control = list(control)
        if control == base['selected']:
            raise ValueError('Kontrolheadet er det samme som det valgte head. Vælg et andet kontrolhead.')
        if control != base['control']:
            measured = induction.measure(model, induction.sequence(test_seeds[0]), ablate=control)
            base['control'] = control
            base['test']['control_ablation_loss'] = measured['repeated_loss']
    layer, head = base['selected']
    more = []
    for seed in test_seeds[1:]:
        tokens = induction.sequence(seed)
        intact = induction.measure(model, tokens, attention=True)
        selected = induction.measure(model, tokens, ablate=base['selected'])
        control = induction.measure(model, tokens, ablate=base['control'])
        more.append({'seed': seed, 'token_ids': tokens.tolist(),
                     'attention': intact['scores'][layer][head],
                     'repeated_loss': intact['repeated_loss'],
                     'selected_ablation_loss': selected['repeated_loss'],
                     'control_ablation_loss': control['repeated_loss']})
    return {'format': 'learning-lab-induction-replication-v1', 'base': base,
            'script_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), 'more': more}


def main():
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument('--discover-seed', type=int, default=7)
    p.add_argument('--test-seeds', type=int, nargs='+', default=[17, 31, 41, 53, 67])
    p.add_argument('--control', type=int, nargs=2, metavar=('LAG', 'HEAD'),
                   help='Valgfrit kontrolhead: lag 0–5 og head 0–7.')
    p.add_argument('--output', type=Path, default=Path('induction-replication.json'))
    p.add_argument('--offline', action='store_true')
    args = p.parse_args()
    try:
        validate_seeds(args.discover_seed, args.test_seeds)
        validate_control(args.control)
    except ValueError as exc:
        p.error(str(exc))
    if args.output.exists():
        p.error('Outputfilen findes allerede. Vælg et andet navn.')
    torch.set_num_threads(1)
    model = AutoModelForCausalLM.from_pretrained(induction.MODEL, revision=induction.REVISION,
        local_files_only=args.offline, attn_implementation='eager').eval()
    try:
        result = replicate(model, args.discover_seed, args.test_seeds, args.control)
    except ValueError as exc:
        p.error(str(exc))
    with args.output.open('x', encoding='utf-8') as file:
        json.dump(result, file, ensure_ascii=False, indent=2, allow_nan=False)
        file.write('\n')
    print(f"Valgt head {result['base']['selected']}; {len(args.test_seeds)} testfølger; gemt: {args.output}")


if __name__ == '__main__':
    main()
