"""Decoder layer: attention + MLP with RMSNorm residual connections.

Unified across Llama, Qwen2, and Qwen3 architectures:
  - bias:    Qwen2 uses bias=True on QKV projection.
  - qk_norm: Qwen3 applies per-head RMSNorm to Q and K before RoPE.
"""

from __future__ import annotations

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

from ....infra.cuda_ext import lazy_op
from ..L1.rms_norm import RMSNorm
from ..L2.attention import LlamaAttention
from ..L2.llama_mlp import LlamaMLP


_C = lazy_op("candidate_llama_decoder", "llama_decoder.cu")


@triton.jit
def _rms_norm_kernel(
    x_ptr,
    weight_ptr,
    out_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).to(tl.float32)
    variance = tl.sum(x * x, axis=0) / n_cols
    normalized = (x * tl.rsqrt(variance + eps)).to(tl.bfloat16)
    weight = tl.load(weight_ptr + cols, mask=mask, other=0.0)
    tl.store(out_ptr + offsets, normalized * weight, mask=mask)


@triton.jit
def _fused_add_rms_norm_kernel(
    x_ptr,
    residual_ptr,
    weight_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).to(tl.float32)
    residual = tl.load(
        residual_ptr + offsets, mask=mask, other=0.0,
    ).to(tl.float32)
    summed = (x + residual).to(tl.bfloat16)
    tl.store(residual_ptr + offsets, summed, mask=mask)

    summed_f32 = summed.to(tl.float32)
    variance = tl.sum(summed_f32 * summed_f32, axis=0) / n_cols
    normalized = (
        summed_f32 * tl.rsqrt(variance + eps)
    ).to(tl.bfloat16)
    weight = tl.load(weight_ptr + cols, mask=mask, other=0.0)
    tl.store(x_ptr + offsets, normalized * weight, mask=mask)


class LlamaDecoderLayer(nn.Module):
    def __init__(self, config, rotary_emb: nn.Module | None = None,
                 bias: bool = False, qk_norm: bool = False,
                 quant_config: dict | None = None):
        super().__init__()
        self.self_attn = LlamaAttention(
            config.hidden_size, config.num_attention_heads,
            config.num_key_value_heads, config.head_dim,
            rotary_emb=rotary_emb,
            bias=bias, qk_norm=qk_norm,
            rms_norm_eps=config.rms_norm_eps,
            quant_config=quant_config,
        )
        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)

    @staticmethod
    def _norm(layer, hidden_states, residual=None):
        n_cols = hidden_states.shape[-1]
        n_rows = hidden_states.numel() // n_cols
        block_n = triton.next_power_of_2(n_cols)
        if residual is None:
            out = torch.empty_like(hidden_states)
            _rms_norm_kernel[(n_rows,)](
                hidden_states, layer.weight, out, n_cols, layer.eps,
                BLOCK_N=block_n, num_warps=8,
            )
            return out

        if (
            hidden_states.is_cuda
            and hidden_states.dtype == torch.bfloat16
            and hidden_states.is_contiguous()
            and residual.is_contiguous()
            and n_cols == 4096
        ):
            _C.fused_add_rms_norm_bf16(
                hidden_states, residual, layer.weight, layer.eps
            )
            return hidden_states, residual

        _fused_add_rms_norm_kernel[(n_rows,)](
            hidden_states, residual, layer.weight, n_cols, layer.eps,
            BLOCK_N=block_n, num_warps=8,
        )
        return hidden_states, residual

    def _mlp(self, hidden_states):
        gate_up = self.mlp.gate_up_proj
        down = self.mlp.down_proj
        if (
            hidden_states.is_cuda
            and hidden_states.dtype == torch.bfloat16
            and not gate_up.use_fp8
            and not down.use_fp8
            and down.tp_size == 1
        ):
            projected = torch._C._nn.linear(
                hidden_states, gate_up.weight, gate_up.bias
            )
            activated = torch.empty(
                (*projected.shape[:-1], projected.shape[-1] // 2),
                dtype=projected.dtype,
                device=projected.device,
            )
            _C.silu_and_mul_bf16(projected, activated)
            return torch._C._nn.linear(
                activated, down.weight, down.bias
            )
        return self.mlp(hidden_states)

    def forward(self, positions, hidden_states, residual):
        if residual is None:
            hidden_states, residual = (
                self._norm(self.input_layernorm, hidden_states), hidden_states
            )
        else:
            hidden_states, residual = self._norm(
                self.input_layernorm, hidden_states, residual
            )
        hidden_states = self.self_attn(positions, hidden_states)
        hidden_states, residual = self._norm(
            self.post_attention_layernorm, hidden_states, residual
        )
        hidden_states = self._mlp(hidden_states)
        return hidden_states, residual