import inspect
import torch.nn as nn

try:
    from mamba_ssm import Mamba
except ImportError as exc:
    raise ImportError(
        "mamba_ssm is required for SegMamba. Install it via the SegMamba repo (mamba/ setup.py install) "
        "or pip install mamba-ssm."
    ) from exc

from .unet import TwoConv


class MambaLayer(nn.Module):
    def __init__(self, dim, d_state=16, d_conv=4, expand=2, num_slices=None):
        super().__init__()
        self.dim = dim
        self.norm = nn.LayerNorm(dim)
        kwargs = {
            "d_model": dim,
            "d_state": d_state,
            "d_conv": d_conv,
            "expand": expand,
        }
        sig = inspect.signature(Mamba.__init__)
        if "bimamba_type" in sig.parameters:
            kwargs["bimamba_type"] = "v3"
        if num_slices is not None and "nslices" in sig.parameters:
            kwargs["nslices"] = num_slices
        self.mamba = Mamba(**kwargs)

    def forward(self, x):
        b, c = x.shape[:2]
        x_skip = x
        if c != self.dim:
            raise ValueError(f"Expected {self.dim} channels, got {c}")
        n_tokens = x.shape[2:].numel()
        img_dims = x.shape[2:]
        x_flat = x.reshape(b, c, n_tokens).transpose(-1, -2)
        x_norm = self.norm(x_flat)
        x_mamba = self.mamba(x_norm)
        out = x_mamba.transpose(-1, -2).reshape(b, c, *img_dims)
        return out + x_skip


class MlpChannel(nn.Module):
    def __init__(self, hidden_size, mlp_dim):
        super().__init__()
        self.fc1 = nn.Conv3d(hidden_size, mlp_dim, 1)
        self.act = nn.GELU()
        self.fc2 = nn.Conv3d(mlp_dim, hidden_size, 1)

    def forward(self, x):
        x = self.fc1(x)
        x = self.act(x)
        x = self.fc2(x)
        return x


class GSC(nn.Module):
    def __init__(self, in_channels):
        super().__init__()
        self.proj = nn.Conv3d(in_channels, in_channels, 3, 1, 1)
        self.norm = nn.InstanceNorm3d(in_channels)
        self.nonliner = nn.ReLU()

        self.proj2 = nn.Conv3d(in_channels, in_channels, 3, 1, 1)
        self.norm2 = nn.InstanceNorm3d(in_channels)
        self.nonliner2 = nn.ReLU()

        self.proj3 = nn.Conv3d(in_channels, in_channels, 1, 1, 0)
        self.norm3 = nn.InstanceNorm3d(in_channels)
        self.nonliner3 = nn.ReLU()

        self.proj4 = nn.Conv3d(in_channels, in_channels, 1, 1, 0)
        self.norm4 = nn.InstanceNorm3d(in_channels)
        self.nonliner4 = nn.ReLU()

    def forward(self, x):
        x_residual = x

        x1 = self.proj(x)
        x1 = self.norm(x1)
        x1 = self.nonliner(x1)

        x1 = self.proj2(x1)
        x1 = self.norm2(x1)
        x1 = self.nonliner2(x1)

        x2 = self.proj3(x)
        x2 = self.norm3(x2)
        x2 = self.nonliner3(x2)

        x = x1 + x2
        x = self.proj4(x)
        x = self.norm4(x)
        x = self.nonliner4(x)
        return x + x_residual


class MambaEncoder(nn.Module):
    def __init__(
        self,
        in_chans=1,
        depths=(2, 2, 2, 2),
        dims=(48, 96, 192, 384),
        drop_path_rate=0.0,
        layer_scale_init_value=1e-6,
        out_indices=(0, 1, 2, 3),
        img_size=128,
    ):
        super().__init__()
        self.downsample_layers = nn.ModuleList()
        stem = nn.Sequential(
            nn.Conv3d(in_chans, dims[0], kernel_size=7, stride=2, padding=3),
        )
        self.downsample_layers.append(stem)
        for i in range(3):
            downsample_layer = nn.Sequential(
                nn.InstanceNorm3d(dims[i]),
                nn.Conv3d(dims[i], dims[i + 1], kernel_size=2, stride=2),
            )
            self.downsample_layers.append(downsample_layer)

        self.stages = nn.ModuleList()
        self.gscs = nn.ModuleList()
        num_slices_list = [max(1, img_size // (2 ** (i + 1))) for i in range(4)]
        for i in range(4):
            gsc = GSC(dims[i])
            stage = nn.Sequential(
                *[MambaLayer(dim=dims[i], num_slices=num_slices_list[i]) for _ in range(depths[i])]
            )
            self.stages.append(stage)
            self.gscs.append(gsc)

        self.out_indices = out_indices

        self.mlps = nn.ModuleList()
        for i_layer in range(4):
            layer = nn.InstanceNorm3d(dims[i_layer])
            self.add_module(f"norm{i_layer}", layer)
            self.mlps.append(MlpChannel(dims[i_layer], 2 * dims[i_layer]))

    def forward_features(self, x):
        outs = []
        for i in range(4):
            x = self.downsample_layers[i](x)
            x = self.gscs[i](x)
            x = self.stages[i](x)
            if i in self.out_indices:
                norm_layer = getattr(self, f"norm{i}")
                x_out = norm_layer(x)
                x_out = self.mlps[i](x_out)
                outs.append(x_out)
        return tuple(outs)

    def forward(self, x):
        return self.forward_features(x)


class ImageEncoderSegMamba(nn.Module):
    def __init__(
        self,
        args,
        img_size=128,
        in_chans=1,
        embed_dim=384,
        depths=(2, 2, 2, 2),
        dims=(48, 96, 192, 384),
    ):
        super().__init__()
        self.args = args
        self.img_size = img_size
        self.backbone = MambaEncoder(
            in_chans=in_chans,
            depths=depths,
            dims=dims,
            img_size=img_size,
        )

        act = ("LeakyReLU", {"negative_slope": 0.1, "inplace": True})
        norm = ("instance", {"affine": True})
        self.stem = TwoConv(3, in_chans, 32, act, norm, True, 0.0)

        self.proj1 = self._proj_block(dims[0], 32)
        self.proj2 = self._proj_block(dims[1], 64)
        self.proj3 = self._proj_block(dims[2], 128)

        self.out_proj = None
        if dims[3] != embed_dim:
            self.out_proj = nn.Conv3d(dims[3], embed_dim, kernel_size=1, bias=False)
            self.out_norm = nn.InstanceNorm3d(embed_dim)

    def _proj_block(self, in_ch, out_ch):
        return nn.Sequential(
            nn.Conv3d(in_ch, out_ch, kernel_size=1, bias=False),
            nn.InstanceNorm3d(out_ch),
            nn.GELU(),
        )

    def forward(self, x):
        x0 = self.stem(x)
        x1, x2, x3, x4 = self.backbone(x)

        f1 = self.proj1(x1)
        f2 = self.proj2(x2)
        f3 = self.proj3(x3)

        if self.out_proj is not None:
            x4 = self.out_norm(self.out_proj(x4))

        feature_list = [x0, f1, f2, f3]
        return x4, feature_list