from __future__ import annotations

import argparse
import json
import math
from pathlib import Path
from typing import Any

import torch
import torch.nn.functional as F
from transformers import LlamaForCausalLM

from kawk50m.binary_dataset import PackedTokenDataset
from kawk50m.cli import configure_utf8_stdio


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Measure causal-LM loss by position on packed Korean text."
    )
    parser.add_argument("--checkpoint", required=True)
    parser.add_argument("--validation-bin", required=True)
    parser.add_argument("--sequence-length", type=int, default=5120)
    parser.add_argument("--bucket-size", type=int, default=1024)
    parser.add_argument("--batches", type=int, default=10)
    parser.add_argument("--batch-size", type=int, default=1)
    parser.add_argument("--cpu", action="store_true")
    return parser.parse_args()


@torch.no_grad()
def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    if args.sequence_length <= 1 or args.bucket_size <= 0:
        raise ValueError("sequence and bucket lengths must be positive")
    if args.batches <= 0 or args.batch_size <= 0:
        raise ValueError("batches and batch size must be positive")

    checkpoint = Path(args.checkpoint)
    model_dir = checkpoint / "model" if (checkpoint / "model").is_dir() else checkpoint
    device = torch.device(
        "cpu" if args.cpu or not torch.cuda.is_available() else "cuda"
    )
    use_bf16 = device.type == "cuda" and torch.cuda.is_bf16_supported()
    model = LlamaForCausalLM.from_pretrained(model_dir).to(device).eval()
    dataset = PackedTokenDataset(args.validation_bin, args.sequence_length)
    bucket_count = math.ceil((args.sequence_length - 1) / args.bucket_size)
    nll_sums = [0.0] * bucket_count
    token_counts = [0] * bucket_count

    for batch_index in range(args.batches):
        inputs, _ = dataset.evaluation_batch(
            batch_index=batch_index,
            batch_size=args.batch_size,
            rank=0,
            world_size=1,
            device=device,
        )
        with torch.autocast(
            device_type=device.type,
            dtype=torch.bfloat16,
            enabled=use_bf16,
        ):
            logits = model(input_ids=inputs, use_cache=False).logits
        per_token = F.cross_entropy(
            logits[:, :-1, :].float().reshape(-1, logits.shape[-1]),
            inputs[:, 1:].reshape(-1),
            reduction="none",
        ).view(inputs.shape[0], -1)
        for bucket_index in range(bucket_count):
            start = bucket_index * args.bucket_size
            stop = min(start + args.bucket_size, per_token.shape[1])
            if start >= stop:
                continue
            values = per_token[:, start:stop]
            nll_sums[bucket_index] += values.sum().item()
            token_counts[bucket_index] += values.numel()

    buckets: list[dict[str, Any]] = []
    for index, (nll, count) in enumerate(zip(nll_sums, token_counts, strict=True)):
        loss = nll / count
        buckets.append(
            {
                "start_position": index * args.bucket_size + 1,
                "end_position": min(
                    (index + 1) * args.bucket_size,
                    args.sequence_length - 1,
                ),
                "tokens": count,
                "loss": loss,
                "perplexity": math.exp(min(loss, 20.0)),
            }
        )
    total_nll = sum(nll_sums)
    total_tokens = sum(token_counts)
    result = {
        "checkpoint": str(checkpoint.resolve()),
        "validation_bin": str(Path(args.validation_bin).resolve()),
        "sequence_length": args.sequence_length,
        "bucket_size": args.bucket_size,
        "evaluated_tokens": total_tokens,
        "loss": total_nll / total_tokens,
        "perplexity": math.exp(min(total_nll / total_tokens, 20.0)),
        "buckets": buckets,
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()