from __future__ import annotations

import argparse
import contextlib
import importlib.util
import json
import math
import random
import time
from pathlib import Path
from typing import Any

import numpy as np
import torch
from transformers import AutoTokenizer, LlamaForCausalLM

from kawk50m.chat import KOREAN_CHAT_TEMPLATE
from kawk50m.checkpoint import (
    load_training_state,
    resolve_checkpoint,
    restore_rng_state,
    save_checkpoint,
)
from kawk50m.cli import configure_utf8_stdio
from kawk50m.config import build_llama_config, count_unique_parameters, load_yaml
from kawk50m.sft_dataset import SFTPackedDataset
from scripts.pretrain import cosine_scheduler, create_optimizer


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Assistant-only supervised fine-tuning for KAWK50M."
    )
    parser.add_argument("--config", default="configs/sft_ko_80m_5k_5090.yaml")
    parser.add_argument("--resume", help="Checkpoint path or 'latest'.")
    parser.add_argument("--init-from", help="Base checkpoint used for fresh SFT.")
    parser.add_argument("--no-compile", action="store_true")
    parser.add_argument("--allow-cpu", action="store_true")
    parser.add_argument("--stop-after-steps", type=int)
    return parser.parse_args()


def set_seed(seed: int) -> None:
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)


@torch.no_grad()
def evaluate_loss(
    model: Any,
    dataset: SFTPackedDataset,
    *,
    batches: int,
    batch_size: int,
    device: torch.device,
    use_bf16: bool,
) -> tuple[float, int]:
    model.eval()
    weighted_loss = 0.0
    supervised_tokens = 0
    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,
        )
        token_count = int((labels[:, 1:] != -100).sum().item())
        with torch.autocast(
            device_type=device.type,
            dtype=torch.bfloat16,
            enabled=use_bf16,
        ):
            loss = model(input_ids=inputs, labels=labels, use_cache=False).loss
        weighted_loss += float(loss.item()) * token_count
        supervised_tokens += token_count
    model.train()
    if supervised_tokens == 0:
        raise RuntimeError("SFT validation has no supervised assistant tokens")
    return weighted_loss / supervised_tokens, supervised_tokens


def checkpoint_model_dir(path: Path) -> Path:
    return path / "model" if (path / "model").is_dir() else path


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    full_config = load_yaml(args.config)
    data_config = full_config["data"]
    training = full_config["training"]

    if torch.cuda.is_available():
        device = torch.device("cuda")
    elif args.allow_cpu:
        device = torch.device("cpu")
    else:
        raise RuntimeError("CUDA is required; use --allow-cpu only for debugging")
    requested_precision = str(training.get("precision", "bf16")).casefold()
    if requested_precision not in {"bf16", "fp32"}:
        raise ValueError("precision must be bf16 or fp32")
    use_bf16 = requested_precision == "bf16" and device.type == "cuda"
    if use_bf16 and not torch.cuda.is_bf16_supported():
        raise RuntimeError("This GPU does not support BF16")

    seed = int(training.get("seed", 42))
    set_seed(seed)
    tokenizer = AutoTokenizer.from_pretrained(
        full_config["tokenizer_dir"], use_fast=False, legacy=True
    )
    tokenizer.chat_template = KOREAN_CHAT_TEMPLATE
    model_yaml = load_yaml(full_config["model_config"])
    model_config, expected_parameters = build_llama_config(
        model_yaml, tokenizer_vocab_size=len(tokenizer)
    )

    output_dir = Path(training["output_dir"])
    resume_path = (
        resolve_checkpoint(args.resume, output_dir) if args.resume else None
    )
    if resume_path is None:
        if (
            (output_dir / "latest_checkpoint.txt").exists()
            or (output_dir / "run_config.json").exists()
            or list(output_dir.glob("checkpoint-*"))
        ):
            raise FileExistsError(
                f"{output_dir} contains SFT artifacts; use --resume latest"
            )
    init_path = Path(args.init_from).resolve() if args.init_from else None
    if resume_path is None and init_path is None:
        raise ValueError("Fresh SFT requires --init-from")

    if resume_path is not None:
        raw_model = LlamaForCausalLM.from_pretrained(resume_path / "model")
    else:
        assert init_path is not None
        if not init_path.exists():
            raise FileNotFoundError(init_path)
        source_model = LlamaForCausalLM.from_pretrained(
            checkpoint_model_dir(init_path)
        )
        raw_model = LlamaForCausalLM(model_config)
        raw_model.load_state_dict(source_model.state_dict(), strict=True)
        del source_model

    for attribute in (
        "vocab_size",
        "hidden_size",
        "intermediate_size",
        "num_hidden_layers",
        "num_attention_heads",
        "num_key_value_heads",
        "max_position_embeddings",
    ):
        if getattr(raw_model.config, attribute) != getattr(model_config, attribute):
            raise ValueError(f"Checkpoint mismatch for {attribute}")
    parameter_count = count_unique_parameters(raw_model)
    if expected_parameters is not None and parameter_count != expected_parameters:
        raise RuntimeError(
            f"Expected {expected_parameters} parameters, got {parameter_count}"
        )
    raw_model.config.use_cache = False
    raw_model.to(device)

    sequence_length = int(data_config["sequence_length"])
    if sequence_length > model_config.max_position_embeddings:
        raise ValueError("SFT sequence length exceeds model context length")
    train_dataset = SFTPackedDataset(
        data_config["train_prefixes"], sequence_length
    )
    validation_dataset = SFTPackedDataset(
        data_config["validation_prefixes"], sequence_length
    )
    batch_size = int(training["per_device_batch_size"])
    gradient_accumulation = int(training["gradient_accumulation_steps"])
    if batch_size <= 0 or gradient_accumulation <= 0:
        raise ValueError("Batch size and gradient accumulation must be positive")
    sequences_per_step = batch_size * gradient_accumulation
    epochs = float(training.get("epochs", 1.0))
    if epochs <= 0:
        raise ValueError("training.epochs must be positive")
    configured_steps = training.get("max_steps")
    max_steps = (
        int(configured_steps)
        if configured_steps is not None
        else math.ceil(len(train_dataset) * epochs / sequences_per_step)
    )
    if max_steps <= 0:
        raise ValueError("SFT max_steps must be positive")
    if args.stop_after_steps is not None and args.stop_after_steps <= 0:
        raise ValueError("--stop-after-steps must be positive")

    compile_enabled = bool(training.get("torch_compile", True)) and not args.no_compile
    if (
        compile_enabled
        and device.type == "cuda"
        and importlib.util.find_spec("triton") is None
    ):
        print("torch.compile disabled because Triton is unavailable")
        compile_enabled = False
    train_model: Any = raw_model
    if compile_enabled:
        train_model = torch.compile(
            train_model, mode=str(training.get("compile_mode", "default"))
        )

    optimizer = create_optimizer(
        train_model.parameters(), training, use_fused=device.type == "cuda"
    )
    learning_rate = float(training["learning_rate"])
    minimum_learning_rate = float(training.get("min_learning_rate", 0.0))
    scheduler = cosine_scheduler(
        optimizer,
        max_steps=max_steps,
        warmup_ratio=float(training.get("warmup_ratio", 0.03)),
        min_lr_ratio=minimum_learning_rate / learning_rate,
    )
    start_step = 0
    if resume_path is not None:
        state = load_training_state(resume_path / "trainer_state.pt")
        optimizer.load_state_dict(state["optimizer"])
        scheduler.load_state_dict(state["scheduler"])
        restore_rng_state(state["rng"])
        start_step = int(state["step"])
        if start_step >= max_steps:
            raise ValueError("SFT checkpoint already reached max_steps")

    output_dir.mkdir(parents=True, exist_ok=True)
    tokens_per_step = sequence_length * sequences_per_step
    summary = {
        "parameters": parameter_count,
        "device": str(device),
        "sequence_length": sequence_length,
        "train_sequences": len(train_dataset),
        "validation_sequences": len(validation_dataset),
        "epochs": epochs,
        "sequences_per_optimizer_step": sequences_per_step,
        "tokens_per_optimizer_step": tokens_per_step,
        "max_steps": max_steps,
        "planned_capacity_tokens": max_steps * tokens_per_step,
        "start_step": start_step,
        "initialized_from": str(init_path) if init_path else None,
        "assistant_only_loss": True,
        "precision": "bf16" if use_bf16 else "fp32",
        "compile": compile_enabled,
    }
    print(json.dumps(summary, ensure_ascii=False, indent=2))
    run_config_path = output_dir / "run_config.json"
    if not run_config_path.exists():
        run_config_path.write_text(
            json.dumps(
                {"summary": summary, "config": full_config},
                ensure_ascii=False,
                indent=2,
            )
            + "\n",
            encoding="utf-8",
        )

    train_model.train()
    optimizer.zero_grad(set_to_none=True)
    step = start_step
    log_every = int(training.get("log_every", 10))
    eval_every = int(training.get("eval_every", 0))
    save_every = int(training.get("save_every", 0))
    max_grad_norm = float(training.get("max_grad_norm", 1.0))
    interval_start = time.perf_counter()
    interval_step = step
    run_stop_step = (
        min(max_steps, step + args.stop_after_steps)
        if args.stop_after_steps is not None
        else max_steps
    )

    while step < run_stop_step:
        accumulated_loss = torch.zeros((), device=device)
        supervised_this_step = 0
        for micro_index in range(gradient_accumulation):
            micro_step = step * gradient_accumulation + micro_index
            inputs, labels = train_dataset.training_batch(
                micro_step=micro_step,
                batch_size=batch_size,
                rank=0,
                world_size=1,
                seed=seed,
                device=device,
            )
            supervised_this_step += int((labels[:, 1:] != -100).sum().item())
            with contextlib.nullcontext():
                with torch.autocast(
                    device_type=device.type,
                    dtype=torch.bfloat16,
                    enabled=use_bf16,
                ):
                    loss = train_model(
                        input_ids=inputs,
                        labels=labels,
                        use_cache=False,
                    ).loss
                (loss / gradient_accumulation).backward()
            accumulated_loss += loss.detach()

        grad_norm = torch.nn.utils.clip_grad_norm_(
            train_model.parameters(), max_grad_norm
        )
        optimizer.step()
        scheduler.step()
        optimizer.zero_grad(set_to_none=True)
        step += 1
        accumulated_loss /= gradient_accumulation

        if log_every > 0 and (step % log_every == 0 or step == 1):
            if device.type == "cuda":
                torch.cuda.synchronize(device)
            elapsed = time.perf_counter() - interval_start
            processed_tokens = (step - interval_step) * tokens_per_step
            print(
                json.dumps(
                    {
                        "step": step,
                        "max_steps": max_steps,
                        "train_loss": round(float(accumulated_loss.item()), 6),
                        "learning_rate": scheduler.get_last_lr()[0],
                        "grad_norm": float(grad_norm),
                        "supervised_tokens_in_step": supervised_this_step,
                        "tokens_per_second": round(processed_tokens / max(elapsed, 1e-9)),
                    },
                    ensure_ascii=False,
                )
            )
            interval_start = time.perf_counter()
            interval_step = step

        if eval_every > 0 and step % eval_every == 0:
            validation_loss, supervised_tokens = evaluate_loss(
                train_model,
                validation_dataset,
                batches=int(training.get("eval_batches", 20)),
                batch_size=batch_size,
                device=device,
                use_bf16=use_bf16,
            )
            print(
                json.dumps(
                    {
                        "step": step,
                        "validation_loss": round(validation_loss, 6),
                        "validation_perplexity": round(
                            math.exp(min(validation_loss, 20.0)), 4
                        ),
                        "validation_supervised_tokens": supervised_tokens,
                    },
                    ensure_ascii=False,
                )
            )

        if save_every > 0 and step % save_every == 0:
            checkpoint_path = save_checkpoint(
                output_dir=output_dir,
                step=step,
                model=raw_model,
                tokenizer=tokenizer,
                optimizer=optimizer,
                scheduler=scheduler,
                training_config=full_config,
                world_size=1,
            )
            print(f"Saved checkpoint: {checkpoint_path}")

    stopped_early = step < max_steps
    if bool(training.get("save_final", True)) or stopped_early:
        checkpoint_path = save_checkpoint(
            output_dir=output_dir,
            step=step,
            model=raw_model,
            tokenizer=tokenizer,
            optimizer=optimizer,
            scheduler=scheduler,
            training_config=full_config,
            world_size=1,
        )
        label = "Stop checkpoint" if stopped_early else "Final checkpoint"
        print(f"{label}: {checkpoint_path}")


if __name__ == "__main__":
    main()