from __future__ import annotations

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

import torch
from transformers import AutoTokenizer, LlamaForCausalLM

from kawk50m.chat import KOREAN_CHAT_TEMPLATE, format_generation_prompt
from kawk50m.cli import configure_utf8_stdio
from kawk50m.sft_dataset import SFTPackedDataset
from scripts.sft import evaluate_loss


DEFAULT_PROMPTS = [
    "대한민국의 수도는 어디인가요? 한 문장으로 답해주세요.",
    "비가 오는 날 외출할 때 준비할 물건 세 가지를 알려주세요.",
    "다음 문장을 자연스럽게 고쳐주세요: 나는 어제 학교에 갑니다.",
    "한국어로 자기소개를 두 문장으로 해주세요.",
    "사용자가 위험한 요청을 하면 어떻게 대응해야 하나요?",
]
HANGUL_RE = re.compile(r"[가-힣]")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Evaluate assistant-only loss and Korean instruction responses."
    )
    parser.add_argument("--checkpoint", required=True)
    parser.add_argument("--tokenizer-dir")
    parser.add_argument("--validation-prefix", action="append", required=True)
    parser.add_argument("--sequence-length", type=int, default=5120)
    parser.add_argument("--batch-size", type=int, default=4)
    parser.add_argument("--eval-batches", type=int, default=20)
    parser.add_argument("--max-new-tokens", type=int, default=160)
    parser.add_argument("--temperature", type=float, default=0.3)
    parser.add_argument("--top-k", type=int, default=40)
    parser.add_argument("--top-p", type=float, default=0.9)
    parser.add_argument("--repetition-penalty", type=float, default=1.12)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--prompt", action="append")
    parser.add_argument("--cpu", action="store_true")
    return parser.parse_args()


def response_metrics(text: str) -> dict[str, float | int]:
    visible = [character for character in text if not character.isspace()]
    words = text.split()
    return {
        "characters": len(text),
        "hangul_visible_ratio": len(HANGUL_RE.findall(text)) / max(len(visible), 1),
        "unique_word_ratio": len(set(words)) / max(len(words), 1),
    }


@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, Any]]:
    model.eval()
    rows: list[dict[str, Any]] = []
    for prompt in prompts:
        rendered = format_generation_prompt(prompt)
        encoded = tokenizer(
            rendered,
            return_tensors="pt",
            add_special_tokens=True,
        )
        input_ids = encoded["input_ids"].to(device)
        available = model.config.max_position_embeddings - input_ids.shape[1]
        generation_kwargs: dict[str, Any] = {
            "input_ids": input_ids,
            "max_new_tokens": min(max_new_tokens, max(available, 1)),
            "do_sample": temperature > 0,
            "repetition_penalty": repetition_penalty,
            "pad_token_id": tokenizer.pad_token_id,
            "eos_token_id": tokenizer.eos_token_id,
        }
        if temperature > 0:
            generation_kwargs.update(
                temperature=temperature,
                top_k=top_k,
                top_p=top_p,
            )
        generated = model.generate(**generation_kwargs)
        response_ids = generated[0, input_ids.shape[1] :]
        response = tokenizer.decode(
            response_ids,
            skip_special_tokens=True,
            clean_up_tokenization_spaces=False,
        ).strip()
        rows.append(
            {
                "prompt": prompt,
                "response": response,
                "metrics": response_metrics(response),
            }
        )
    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
    )
    device = (
        torch.device("cpu")
        if args.cpu or not torch.cuda.is_available()
        else torch.device("cuda")
    )
    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
    )
    tokenizer.chat_template = KOREAN_CHAT_TEMPLATE
    model = LlamaForCausalLM.from_pretrained(model_dir).to(device)
    dataset = SFTPackedDataset(args.validation_prefix, args.sequence_length)
    loss, supervised_tokens = evaluate_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_supervised_tokens": supervised_tokens,
        "assistant_only_loss": True,
        "samples": samples,
        "note": "Korean instruction evaluation; responses are sampled, not facts checked.",
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()