#!/usr/bin/env python3
"""Measure one head on identical target tokens with and without repeated context."""
import argparse
import hashlib
import json
from pathlib import Path

import torch
import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
import induction_heads as induction
import induction_joint_text as joint_text


def validate_head(head):
    if not isinstance(head, (list, tuple)) or len(head) != 2 or any(type(x) is not int for x in head) or not 0 <= head[0] < 6 or not 0 <= head[1] < 8:
        raise ValueError('Vælg et lag fra 0 til 5 og et head fra 0 til 7.')


def experiment(model, tokenizer, head, texts, control=(0, 0)):
    validate_head(head)
    validate_head(control)
    if list(head) == list(control):
        raise ValueError('Kontrolhead skal være forskelligt fra det valgte head.')
    joint_text.validate_texts(texts)
    rows = []
    for text in texts:
        ids = tokenizer(text, return_tensors='pt', add_special_tokens=False)['input_ids']
        length = ids.shape[-1]
        if not 3 <= length <= 128:
            raise ValueError('Hver tekst skal give 3–128 tokens med Pythias tokenizer.')
        repeated = torch.cat((ids, ids), dim=-1)
        single_base = joint_text.measure(model, ids, [])
        single_zero = joint_text.measure(model, ids, [head])
        single_control = joint_text.measure(model, ids, [control])
        repeated_base = joint_text.measure(model, repeated, [])[length:]
        repeated_zero = joint_text.measure(model, repeated, [head])[length:]
        repeated_control = joint_text.measure(model, repeated, [control])[length:]
        if any(len(values) != length - 1 for values in (single_base, single_zero, single_control, repeated_base, repeated_zero, repeated_control)):
            raise ValueError('De to sammenligninger dækker ikke samme antal mål.')
        rows.append({'text': text, 'token_ids': ids[0].tolist(), 'single_baseline': single_base,
                     'single_ablation': single_zero, 'single_control': single_control, 'repeated_baseline': repeated_base,
                     'repeated_ablation': repeated_zero, 'repeated_control': repeated_control})
    return {'format': 'learning-lab-repeated-text-v2', 'model': induction.MODEL, 'revision': induction.REVISION,
            'head': list(head), 'control': list(control), 'torch_version': str(torch.__version__), 'transformers_version': transformers.__version__,
            'script_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
            'measure_sha256': hashlib.sha256(Path(joint_text.__file__).read_bytes()).hexdigest(),
            'sequence_sha256': hashlib.sha256(Path(induction.__file__).read_bytes()).hexdigest(), 'rows': rows}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--head', type=int, nargs=2, default=[3, 6], metavar=('LAG', 'HEAD'))
    parser.add_argument('--control', type=int, nargs=2, default=[0, 0], metavar=('LAG', 'HEAD'))
    parser.add_argument('--texts', type=Path, help='UTF-8 JSON-liste med 2–10 korte tekster')
    parser.add_argument('--output', type=Path, default=Path('repeated-text.json'))
    parser.add_argument('--offline', action='store_true')
    args = parser.parse_args()
    try:
        texts = json.loads(args.texts.read_text(encoding='utf-8')) if args.texts else joint_text.TEXTS
        validate_head(args.head)
        validate_head(args.control)
        if args.head == args.control:
            raise ValueError('Kontrolhead skal være forskelligt fra det valgte head.')
        joint_text.validate_texts(texts)
    except (ValueError, OSError) as exc:
        parser.error(str(exc))
    if args.output.exists():
        parser.error('Outputfilen findes allerede. Vælg et andet navn.')
    torch.set_num_threads(1)
    tokenizer = AutoTokenizer.from_pretrained(induction.MODEL, revision=induction.REVISION, local_files_only=args.offline, trust_remote_code=False)
    model = AutoModelForCausalLM.from_pretrained(induction.MODEL, revision=induction.REVISION, local_files_only=args.offline, attn_implementation='eager').eval()
    try:
        result = experiment(model, tokenizer, args.head, texts, args.control)
    except ValueError as exc:
        parser.error(str(exc))
    with args.output.open('x', encoding='utf-8') as out:
        json.dump(result, out, ensure_ascii=False, indent=2, allow_nan=False)
        out.write('\n')
    print(f"Målte head {args.head} på {len(texts)} tekster; gemt: {args.output}")


if __name__ == '__main__':
    main()
