"""CLIP encoder layer: pre-norm attention + MLP with residual connections (L3).

Standard transformer encoder layer used in CLIP text models.
"""

from __future__ import annotations

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig
from torch.utils.cpp_extension import load_inline

from ..L1.layer_norm import LayerNorm
from ..L2.clip_attention import CLIPAttention, _get_cuda_ext as _get_attention_ext
from ..L2.clip_mlp import CLIPMLP


_CUDA_EXT = None
_CPP_SRC = """
void quick_gelu_cuda(torch::Tensor input, torch::Tensor output);
"""
_CUDA_SRC = r"""
#include <torch/extension.h>
#include <ATen/cuda/CUDAContext.h>
#include <cuda.h>
#include <cuda_runtime.h>

__global__ void quick_gelu_kernel(
    const float4* __restrict__ input,
    float4* __restrict__ output
) {
    const int index = blockIdx.x * blockDim.x + threadIdx.x;
    if (index >= 77 * 3072 / 4)
        return;
    float4 x = input[index];
    x.x = x.x / (1.0f + expf(-1.702f * x.x));
    x.y = x.y / (1.0f + expf(-1.702f * x.y));
    x.z = x.z / (1.0f + expf(-1.702f * x.z));
    x.w = x.w / (1.0f + expf(-1.702f * x.w));
    output[index] = x;
}

void quick_gelu_cuda(torch::Tensor input, torch::Tensor output) {
    constexpr int count = 77 * 3072 / 4;
    quick_gelu_kernel<<<(count + 255) / 256, 256, 0,
        at::cuda::getCurrentCUDAStream()>>>(
            reinterpret_cast<const float4*>(input.data_ptr<float>()),
            reinterpret_cast<float4*>(output.data_ptr<float>()));
}
"""


def _get_cuda_ext():
    global _CUDA_EXT
    if _CUDA_EXT is None:
        _CUDA_EXT = load_inline(
            name="fk_clip_encoder_layer_v1",
            cpp_sources=_CPP_SRC,
            cuda_sources=_CUDA_SRC,
            functions=["quick_gelu_cuda"],
            extra_cuda_cflags=["-O3"],
            verbose=False,
        )
    return _CUDA_EXT


class CLIPEncoderLayer(nn.Module):
    def __init__(self, config: CLIPTextConfig):
        super().__init__()
        self.self_attn = CLIPAttention(config)
        self.layer_norm1 = LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
        self.mlp = CLIPMLP(config)
        self.layer_norm2 = LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
        self._softmax_cuda = None
        self._quick_gelu_cuda = None

    def forward(
        self, hidden_states: torch.Tensor, attention_mask: torch.Tensor | None = None,
    ) -> torch.Tensor:
        if (
            hidden_states.is_cuda
            and hidden_states.dtype == torch.float32
            and hidden_states.shape == (1, 77, 768)
            and attention_mask is not None
        ):
            residual = hidden_states
            hidden_states = F.layer_norm(
                hidden_states,
                (768,),
                self.layer_norm1.weight,
                self.layer_norm1.bias,
                self.layer_norm1.eps,
            )
            queries = F.linear(
                hidden_states,
                self.self_attn.q_proj.weight,
                self.self_attn.q_proj.bias,
            )
            keys = F.linear(
                hidden_states,
                self.self_attn.k_proj.weight,
                self.self_attn.k_proj.bias,
            )
            values = F.linear(
                hidden_states,
                self.self_attn.v_proj.weight,
                self.self_attn.v_proj.bias,
            )
            queries = queries.view(1, 77, 12, 64).transpose(1, 2)
            keys = keys.view(1, 77, 12, 64).transpose(1, 2)
            values = values.view(1, 77, 12, 64).transpose(1, 2)
            scores = torch.bmm(queries[0], keys[0].transpose(-1, -2))
            probabilities = torch.empty_like(scores)
            if self._softmax_cuda is None:
                self._softmax_cuda = (
                    _get_attention_ext().clip_masked_softmax_cuda
                )
                self._quick_gelu_cuda = _get_cuda_ext().quick_gelu_cuda
            self._softmax_cuda(scores, attention_mask, probabilities)
            attention_output = torch.bmm(probabilities, values[0])
            attention_output = attention_output.transpose(0, 1).contiguous()
            hidden_states = F.linear(
                attention_output.view(1, 77, 768),
                self.self_attn.out_proj.weight,
                self.self_attn.out_proj.bias,
            )
            hidden_states.add_(residual)
            residual = hidden_states
            hidden_states = F.layer_norm(
                hidden_states,
                (768,),
                self.layer_norm2.weight,
                self.layer_norm2.bias,
                self.layer_norm2.eps,
            )
            hidden_states = F.linear(
                hidden_states, self.mlp.fc1.weight, self.mlp.fc1.bias
            )
            self._quick_gelu_cuda(hidden_states, hidden_states)
            hidden_states = F.linear(
                hidden_states, self.mlp.fc2.weight, self.mlp.fc2.bias
            )
            return hidden_states.add_(residual)

        residual = hidden_states
        hidden_states = self.layer_norm1(hidden_states)
        hidden_states = self.self_attn(hidden_states, attention_mask=attention_mask)
        hidden_states = residual + hidden_states

        residual = hidden_states
        hidden_states = self.layer_norm2(hidden_states)
        hidden_states = self.mlp(hidden_states)
        hidden_states = residual + hidden_states
        return hidden_states