from __future__ import annotations

import torch
import torch.nn as nn
import triton
import triton.language as tl

from ..L1.rms_norm import RMSNorm
from ..L2.kimi_delta_attention import KimiDeltaAttention
from ..L2.kimi_mla_attention import KimiMLAAttention
from ..L2.kimi_moe import KimiMoE
from ..L2.llama_mlp import LlamaMLP


@triton.jit
def _clone_rms_norm_kernel(
    x_ptr,
    weight_ptr,
    out_ptr,
    residual_ptr,
    n_cols: tl.constexpr,
    eps: tl.constexpr,
    BLOCK_N: tl.constexpr,
):
    row = tl.program_id(0)
    cols = tl.arange(0, BLOCK_N)
    mask = cols < n_cols
    offsets = row * n_cols + cols

    x = tl.load(x_ptr + offsets, mask=mask, other=0.0)
    tl.store(residual_ptr + offsets, x, mask=mask)
    x_f32 = x.to(tl.float32)
    variance = tl.sum(x_f32 * x_f32, axis=0) / n_cols
    rstd = tl.rsqrt(variance + eps)
    weight = tl.load(weight_ptr + cols, mask=mask, other=0.0).to(tl.float32)
    tl.store(out_ptr + offsets, x_f32 * rstd * weight, mask=mask)


class KimiLinearDecoderLayer(nn.Module):
    def __init__(self, config, layer_idx: int, quant_config: dict | None = None):
        super().__init__()
        self.layer_idx = layer_idx
        self.is_kda = config.is_kda_layer(layer_idx)

        if self.is_kda:
            self.self_attn = KimiDeltaAttention(
                config,
                layer_idx=layer_idx,
                quant_config=quant_config,
            )
        else:
            self.self_attn = KimiMLAAttention(
                config,
                quant_config=quant_config,
            )

        if config.is_moe_layer(layer_idx):
            self.block_sparse_moe = KimiMoE(config, quant_config=quant_config)
            self.mlp = self.block_sparse_moe
        else:
            self.mlp = LlamaMLP(config, quant_config=quant_config)

        self.input_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
        self.post_attention_layernorm = RMSNorm(
            config.hidden_size, eps=config.rms_norm_eps,
        )

    def forward(self, hidden_states, residual, state_manager=None):
        if (
            residual is None
            and hidden_states.is_cuda
            and hidden_states.dtype == torch.bfloat16
            and hidden_states.is_contiguous()
            and hidden_states.shape[-1] == 2304
        ):
            residual = torch.empty_like(hidden_states)
            normalized = torch.empty_like(hidden_states)
            _clone_rms_norm_kernel[(hidden_states.numel() // 2304,)](
                hidden_states,
                self.input_layernorm.weight,
                normalized,
                residual,
                n_cols=2304,
                eps=self.input_layernorm.eps,
                BLOCK_N=4096,
                num_warps=8,
            )
            hidden_states = normalized
        elif residual is None:
            residual = hidden_states.clone()
            hidden_states = self.input_layernorm(hidden_states)
        else:
            hidden_states, residual = self.input_layernorm(hidden_states, residual)

        hidden_states = self.self_attn(
            hidden_states, state_manager=state_manager,
        )
        hidden_states, residual = self.post_attention_layernorm(
            hidden_states, residual,
        )
        hidden_states = self.mlp(hidden_states)
        return hidden_states, residual