from __future__ import annotations

import argparse
import importlib.util
import json
import time

import torch
from transformers import LlamaForCausalLM

from kawk50m.cli import configure_utf8_stdio
from kawk50m.config import build_llama_config, count_unique_parameters, load_yaml


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Benchmark synthetic BF16 pretraining throughput."
    )
    parser.add_argument("--config", default="configs/model_50m.yaml")
    parser.add_argument("--batch-size", type=int, default=8)
    parser.add_argument("--sequence-length", type=int, default=1024)
    parser.add_argument("--gradient-accumulation", type=int, default=16)
    parser.add_argument("--warmup-steps", type=int, default=1)
    parser.add_argument("--steps", type=int, default=3)
    parser.add_argument("--compile", action="store_true", dest="use_compile")
    parser.add_argument("--compile-mode", default="default")
    return parser.parse_args()


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    if not torch.cuda.is_available() or not torch.cuda.is_bf16_supported():
        raise RuntimeError("A CUDA GPU with BF16 support is required")
    if args.use_compile and importlib.util.find_spec("triton") is None:
        raise RuntimeError(
            "--compile requires a working Triton installation; none was found"
        )
    for name in (
        "batch_size",
        "sequence_length",
        "gradient_accumulation",
        "warmup_steps",
        "steps",
    ):
        if getattr(args, name) <= 0:
            raise ValueError(f"--{name.replace('_', '-')} must be positive")

    torch.set_float32_matmul_precision("high")
    torch.backends.cuda.matmul.allow_tf32 = True
    device = torch.device("cuda")
    model_config, expected = build_llama_config(load_yaml(args.config))
    if args.sequence_length > model_config.max_position_embeddings:
        raise ValueError("sequence length exceeds the configured context length")

    raw_model = LlamaForCausalLM(model_config).to(device)
    parameter_count = count_unique_parameters(raw_model)
    if expected is not None and parameter_count != expected:
        raise RuntimeError(
            f"Expected {expected} parameters but constructed {parameter_count}"
        )
    model = (
        torch.compile(raw_model, mode=args.compile_mode)
        if args.use_compile
        else raw_model
    )
    optimizer = torch.optim.AdamW(
        model.parameters(),
        lr=6.0e-4,
        betas=(0.9, 0.95),
        weight_decay=0.1,
        fused=True,
    )
    input_ids = torch.randint(
        0,
        model_config.vocab_size,
        (args.batch_size, args.sequence_length),
        device=device,
        dtype=torch.long,
    )

    def optimizer_step() -> float:
        optimizer.zero_grad(set_to_none=True)
        total_loss = 0.0
        for _ in range(args.gradient_accumulation):
            with torch.autocast("cuda", dtype=torch.bfloat16):
                loss = model(
                    input_ids=input_ids,
                    labels=input_ids,
                    use_cache=False,
                ).loss
            (loss / args.gradient_accumulation).backward()
            total_loss += loss.detach().item()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        return total_loss / args.gradient_accumulation

    for _ in range(args.warmup_steps):
        optimizer_step()
    torch.cuda.synchronize()
    torch.cuda.reset_peak_memory_stats()
    started = time.perf_counter()
    final_loss = 0.0
    for _ in range(args.steps):
        final_loss = optimizer_step()
    torch.cuda.synchronize()
    elapsed = time.perf_counter() - started

    tokens = (
        args.steps
        * args.gradient_accumulation
        * args.batch_size
        * args.sequence_length
    )
    tokens_per_second = tokens / elapsed
    result = {
        "gpu": torch.cuda.get_device_name(),
        "parameters": parameter_count,
        "precision": "bf16",
        "compiled": args.use_compile,
        "batch_size": args.batch_size,
        "sequence_length": args.sequence_length,
        "gradient_accumulation": args.gradient_accumulation,
        "timed_optimizer_steps": args.steps,
        "elapsed_seconds": elapsed,
        "tokens": tokens,
        "tokens_per_second": tokens_per_second,
        "seconds_per_optimizer_step": elapsed / args.steps,
        "peak_memory_gib": torch.cuda.max_memory_allocated() / 1024**3,
        "final_synthetic_loss": final_loss,
        "ideal_compute_only_hours": {
            "1B": 1_000_000_000 / tokens_per_second / 3600,
            "5B": 5_000_000_000 / tokens_per_second / 3600,
            "10B": 10_000_000_000 / tokens_per_second / 3600,
        },
        "note": "Synthetic compute-only result; disk I/O, eval, and checkpoints are excluded.",
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()