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 AutoTokenizer, LlamaForCausalLM

from kawk50m.cli import configure_utf8_stdio
from kawk50m.io import discover_paths, iter_documents


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description=(
            "Evaluate a checkpoint on raw text with tokenizer-independent "
            "UTF-8 byte-normalized negative log-likelihood."
        )
    )
    parser.add_argument(
        "--checkpoint",
        required=True,
        help="Checkpoint directory containing model/ and tokenizer/.",
    )
    parser.add_argument(
        "--input",
        nargs="+",
        required=True,
        help="Validation JSONL/TXT files or glob patterns.",
    )
    parser.add_argument(
        "--tokenizer-dir",
        default=None,
        help="Override the tokenizer stored inside the checkpoint.",
    )
    parser.add_argument("--max-documents", type=int, default=1_000)
    parser.add_argument("--max-characters-per-document", type=int, default=20_000)
    parser.add_argument("--context-length", type=int, default=None)
    parser.add_argument("--cpu", action="store_true")
    return parser.parse_args()


@torch.no_grad()
def document_nll(
    model: Any,
    tokenizer: Any,
    text: str,
    *,
    context_length: int,
    device: torch.device,
    use_bf16: bool,
) -> tuple[float, int]:
    token_ids = tokenizer.encode(text, add_special_tokens=False)
    if not token_ids:
        return 0.0, 0
    prefix_id = tokenizer.bos_token_id
    if prefix_id is None:
        prefix_id = tokenizer.eos_token_id
    if prefix_id is None:
        raise ValueError("Tokenizer must define bos_token_id or eos_token_id")

    stream = [prefix_id, *token_ids]
    total_nll = 0.0
    predicted_tokens = 0
    for start in range(0, len(stream) - 1, context_length):
        stop = min(start + context_length, len(stream) - 1)
        input_ids = torch.tensor(
            stream[start:stop], dtype=torch.long, device=device
        ).unsqueeze(0)
        targets = torch.tensor(
            stream[start + 1 : stop + 1], dtype=torch.long, device=device
        )
        with torch.autocast(
            device_type=device.type,
            dtype=torch.bfloat16,
            enabled=use_bf16,
        ):
            logits = model(input_ids=input_ids, use_cache=False).logits[0]
        total_nll += F.cross_entropy(
            logits.float(), targets, reduction="sum"
        ).item()
        predicted_tokens += targets.numel()
    return total_nll, predicted_tokens


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    if args.max_documents <= 0:
        raise ValueError("--max-documents must be positive")
    if args.max_characters_per_document <= 0:
        raise ValueError("--max-characters-per-document must be positive")

    checkpoint = Path(args.checkpoint)
    model_dir = checkpoint / "model" if (checkpoint / "model").is_dir() else checkpoint
    tokenizer_dir = Path(args.tokenizer_dir) if args.tokenizer_dir else (
        checkpoint / "tokenizer"
        if (checkpoint / "tokenizer").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()
    tokenizer = AutoTokenizer.from_pretrained(
        tokenizer_dir, use_fast=False, legacy=True
    )
    tokenizer.model_max_length = int(1e30)
    model = LlamaForCausalLM.from_pretrained(model_dir).to(device).eval()
    context_length = args.context_length or int(
        model.config.max_position_embeddings
    )
    if context_length <= 0:
        raise ValueError("--context-length must be positive")
    context_length = min(context_length, int(model.config.max_position_embeddings))

    paths = discover_paths(args.input)
    if not paths:
        raise FileNotFoundError("No evaluation inputs were found")

    total_nll = 0.0
    total_tokens = 0
    total_characters = 0
    total_utf8_bytes = 0
    documents = 0
    for document in iter_documents(paths):
        text = document["text"][: args.max_characters_per_document]
        if not text:
            continue
        nll, tokens = document_nll(
            model,
            tokenizer,
            text,
            context_length=context_length,
            device=device,
            use_bf16=use_bf16,
        )
        total_nll += nll
        total_tokens += tokens
        total_characters += len(text)
        total_utf8_bytes += len(text.encode("utf-8"))
        documents += 1
        if documents >= args.max_documents:
            break

    if documents == 0 or total_tokens == 0 or total_utf8_bytes == 0:
        raise RuntimeError("Evaluation set contained no usable text")
    result = {
        "checkpoint": str(checkpoint.resolve()),
        "tokenizer": str(tokenizer_dir.resolve()),
        "inputs": [str(path) for path in paths],
        "documents": documents,
        "characters": total_characters,
        "utf8_bytes": total_utf8_bytes,
        "predicted_tokens": total_tokens,
        "context_length": context_length,
        "token_nll": total_nll / total_tokens,
        "token_perplexity": math.exp(min(total_nll / total_tokens, 20.0)),
        "nats_per_character": total_nll / total_characters,
        "bits_per_utf8_byte": total_nll / total_utf8_bytes / math.log(2.0),
        "note": (
            "Compare bits_per_utf8_byte only when checkpoints are evaluated "
            "on the exact same ordered raw-text documents."
        ),
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()