import logging
from typing import Tuple, TypedDict

import torch
import torch.distributed as dist
from omegaconf import DictConfig, OmegaConf

from abbie.device_mesh_manager import DMM
from abbie.gargantua.causal_lm import GenericTransformerForCausalLM, make_model_optimizer
from abbie.models import load_pretrained_hf_model
from abbie.utils.metrics import GlobalMetrics
from abbie.utils.optimizer import MappedOptimizer, PseudoMappedOptimizer


class TrainingStats(TypedDict):
    step_nb: int
    total_tokens: int


def set_qwen_vl_utils_log_level(level=logging.ERROR):
    try:
        # Qwen2.5-VL has info logging
        from qwen_vl_utils.vision_process import logger

        logger.setLevel(level)
    except ImportError:
        pass


def init_wandb(config: DictConfig):
    experiment_config = OmegaConf.to_object(config)
    experiment_config.update({"trainer.world_size": dist.get_world_size()})

    GlobalMetrics.initialize(
        project_name=config.trainer.project_name,
        experiment_name=config.trainer.experiment_name,
        config=experiment_config,
    )


def load_model_and_optimizer(
    config: DictConfig,
    num_training_steps: int,
) -> Tuple[
    GenericTransformerForCausalLM,
    MappedOptimizer,
]:
    max_batch_size = config.data.micro_batch_size * config.data.chunks_per_step
    if config.data.is_continuous_batch:
        max_batch_size = config.data.chunks_per_step

    DMM.log_rank0(f"Loading model from {config.model.pretrained_path}")

    model = load_pretrained_hf_model(
        config.model.pretrained_path,
        max_batch_size=max_batch_size,
        max_seq_len=config.model.max_seq_len,
        aux_loss_coef=config.model.aux_loss_coef,
        z_loss_coef=config.model.z_loss_coef,
        recompute_norm=config.model.recompute_norm,
        recompute_attn_up_proj=config.model.recompute_attn_up_proj,
        recompute_attn=config.model.recompute_attn,
        recompute_attn_down_proj=config.model.recompute_attn_down_proj,
        recompute_mlp=config.model.recompute_mlp,
        recompute_mlp_act=config.model.recompute_mlp_act,
        recompute_dispatch=config.model.recompute_dispatch,
        recompute_visual=config.model.recompute_visual,
        activation_offloading=config.model.activation_offloading,
        visual_activation_offloading=config.model.visual_activation_offloading,
        token_dispatch_method=config.model.token_dispatch_method,
        pp_distributed_dataloading=config.model.pp_distributed_dataloading,
        decoder_first_pipeline_num_layers=config.model.decoder_first_pipeline_num_layers,
        decoder_last_pipeline_num_layers=config.model.decoder_last_pipeline_num_layers,
    )

    # Before making optimizer, freeze necessary params first
    if config.model.freeze_decoder_vocab:
        model.freeze_vocab()
    if config.model.freeze_decoder_but_last_n_layers is not None:
        model.freeze_all_layers_but_last_n(config.model.freeze_decoder_but_last_n_layers)

    if model.config.vision_config is not None:
        if config.model.freeze_visual_encoder:
            model.visual.freeze_encoder()
        if config.model.freeze_visual_aligner:
            model.visual.freeze_aligner()

    # Initializing model could have created some buffers (like for loading pretrained weights)
    torch.cuda.empty_cache()
    DMM.log_rank0(f"Model loaded mem_alloc={torch.cuda.max_memory_allocated() / (1 << 30):.1f}GB")

    total_params = 0
    total_trainable_params = 0
    for param in model.parameters():
        total_params += param.numel()
        if param.requires_grad:
            total_trainable_params += param.numel()
    DMM.log_all_ranks(f"trainable_params={total_trainable_params / 1e9:.3f}B total_params={total_params / 1e9:.3f}B")

    num_warmup_steps = int(num_training_steps * config.optim.lr_warmup_steps_ratio)

    if config.optim.disable_optimizer:
        optimizer = PseudoMappedOptimizer()
    else:
        optimizer = make_model_optimizer(
            model=model,
            num_training_steps=num_training_steps,
            num_warmup_steps=num_warmup_steps,
            lr=config.optim.lr,
            visual_lr=config.optim.visual_lr,
            betas=(config.optim.adam_beta1, config.optim.adam_beta2),
            weight_decay=config.optim.weight_decay,
            lr_schedule=config.optim.lr_schedule,
        )

    # Initializing optimizer could have created some buffers
    torch.cuda.empty_cache()
    DMM.log_rank0(f"Optimizers created mem_alloc={torch.cuda.max_memory_allocated() / (1 << 30):.1f}GB")

    return model, optimizer