from __future__ import annotations

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

import torch
from transformers import AutoTokenizer, LlamaForCausalLM

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


DEFAULT_PROMPTS = [
    "대한민국의 수도는",
    "오늘 아침에 일어나서",
    "인공지능 언어 모델은",
    "비가 내리는 날에는",
]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Measure validation loss and generate Korean continuations."
    )
    parser.add_argument(
        "--checkpoint",
        required=True,
        help="A checkpoint directory containing model/ and tokenizer/.",
    )
    parser.add_argument(
        "--validation-bin", default="data/tokenized/validation.bin"
    )
    parser.add_argument(
        "--tokenizer-dir",
        default=None,
        help="Override the tokenizer stored inside the checkpoint.",
    )
    parser.add_argument("--sequence-length", type=int, default=1024)
    parser.add_argument("--batch-size", type=int, default=8)
    parser.add_argument("--eval-batches", type=int, default=50)
    parser.add_argument("--max-new-tokens", type=int, default=80)
    parser.add_argument("--temperature", type=float, default=0.8)
    parser.add_argument("--top-k", type=int, default=0)
    parser.add_argument("--top-p", type=float, default=0.95)
    parser.add_argument("--repetition-penalty", type=float, default=1.05)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--prompt", action="append", default=None)
    parser.add_argument("--cpu", action="store_true")
    return parser.parse_args()


@torch.no_grad()
def validation_loss(
    model: Any,
    dataset: PackedTokenDataset,
    *,
    batches: int,
    batch_size: int,
    device: torch.device,
    use_bf16: bool,
) -> float:
    total = 0.0
    model.eval()
    for batch_index in range(batches):
        inputs, labels = dataset.evaluation_batch(
            batch_index=batch_index,
            batch_size=batch_size,
            rank=0,
            world_size=1,
            device=device,
        )
        with torch.autocast(
            device_type=device.type,
            dtype=torch.bfloat16,
            enabled=use_bf16,
        ):
            total += model(input_ids=inputs, labels=labels).loss.item()
    return total / batches


@torch.no_grad()
def generate_samples(
    model: Any,
    tokenizer: Any,
    prompts: list[str],
    *,
    device: torch.device,
    max_new_tokens: int,
    temperature: float,
    top_k: int,
    top_p: float,
    repetition_penalty: float,
) -> list[dict[str, str]]:
    rows = []
    do_sample = temperature > 0
    for prompt in prompts:
        encoded = tokenizer(prompt, return_tensors="pt", add_special_tokens=True)
        input_ids = encoded["input_ids"].to(device)
        available = model.config.max_position_embeddings - input_ids.shape[1]
        new_token_limit = min(max_new_tokens, max(available, 1))
        generation_kwargs: dict[str, Any] = {
            "input_ids": input_ids,
            "max_new_tokens": new_token_limit,
            "do_sample": do_sample,
            "repetition_penalty": repetition_penalty,
            "pad_token_id": tokenizer.pad_token_id,
            "eos_token_id": tokenizer.eos_token_id,
        }
        if do_sample:
            generation_kwargs.update(
                temperature=temperature,
                top_k=top_k,
                top_p=top_p,
            )
        generated = model.generate(**generation_kwargs)
        continuation_ids = generated[0, input_ids.shape[1] :]
        continuation = tokenizer.decode(
            continuation_ids,
            skip_special_tokens=True,
            clean_up_tokenization_spaces=False,
        )
        rows.append(
            {
                "prompt": prompt,
                "continuation": continuation,
                "full_text": prompt + continuation,
            }
        )
    return rows


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    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
    )
    if args.cpu:
        device = torch.device("cpu")
    elif torch.cuda.is_available():
        device = torch.device("cuda")
    else:
        device = torch.device("cpu")
    use_bf16 = device.type == "cuda" and torch.cuda.is_bf16_supported()
    torch.manual_seed(args.seed)
    if device.type == "cuda":
        torch.cuda.manual_seed_all(args.seed)

    tokenizer = AutoTokenizer.from_pretrained(
        tokenizer_dir, use_fast=False, legacy=True
    )
    model = LlamaForCausalLM.from_pretrained(model_dir)
    model.to(device)
    dataset = PackedTokenDataset(args.validation_bin, args.sequence_length)
    loss = validation_loss(
        model,
        dataset,
        batches=args.eval_batches,
        batch_size=args.batch_size,
        device=device,
        use_bf16=use_bf16,
    )
    samples = generate_samples(
        model,
        tokenizer,
        args.prompt or DEFAULT_PROMPTS,
        device=device,
        max_new_tokens=args.max_new_tokens,
        temperature=args.temperature,
        top_k=args.top_k,
        top_p=args.top_p,
        repetition_penalty=args.repetition_penalty,
    )
    result = {
        "checkpoint": str(checkpoint.resolve()),
        "tokenizer": str(tokenizer_dir.resolve()),
        "validation_loss": loss,
        "validation_perplexity": math.exp(min(loss, 20.0)),
        "evaluated_tokens": (
            args.eval_batches * args.batch_size * args.sequence_length
        ),
        "samples": samples,
        "note": "This is a base-model continuation evaluation, not instruction QA.",
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()