import torch
import torch.nn as nn
import torch.nn.functional as F

class InputPreparer(nn.Module):
    def __init__(self):
        super().__init__()
        # smoothing and diff filters
        matrix_a = torch.tensor([[1., 2., 1.],
                                 [2., 4., 2.],
                                 [1., 2., 1.]], dtype=torch.float32) / 16.0
        self.register_buffer('filter_pattern_a', matrix_a.view(1, 1, 3, 3))

        matrix_b = torch.tensor([[-1., 0., 1.],[-2., 0., 2.],[-1., 0., 1.]], dtype=torch.float32).view(1, 1, 3, 3)
        matrix_c = torch.tensor([[-1., -2., -1.],
                                 [ 0.,  0.,  0.],
                                 [ 1.,  2.,  1.]], dtype=torch.float32).view(1, 1, 3, 3)
        self.register_buffer('filter_pattern_b', matrix_b)
        self.register_buffer('filter_pattern_c',matrix_c)

        self.gating_network = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(2,2, kernel_size=1),
            nn.Sigmoid()
        )
        self.mapping_conv = nn.Conv2d(2, 32, kernel_size=3, padding=1, bias=False)
        self.normalization = nn.BatchNorm2d(32)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        filtered_input = F.conv2d(x, self.filter_pattern_a, padding=1)
        response_b = F.conv2d(filtered_input, self.filter_pattern_b, padding=1)
        response_c = F.conv2d(filtered_input, self.filter_pattern_c, padding=1)
        combined_response = torch.sqrt(response_b**2 + response_c**2+1e-5)
        
        integrated_features = torch.cat([x, combined_response], dim=1)
        modulated_features = integrated_features * self.gating_network(integrated_features)
        return F.silu(self.normalization(self.mapping_conv(modulated_features)))


class MagnitudeScaler(nn.Module):
    def __init__(self, kernel_size=2, stride=2, padding=0):
        super().__init__()
        self.kernel_size = kernel_size
        self.stride = stride
        self.padding = padding

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        squared_values = torch.clamp(x, min=0.0)**2
        aggregated_values = F.avg_pool2d(squared_values, self.kernel_size, self.stride, self.padding)
        return torch.sqrt(aggregated_values + 1e-5)


class FeatureWeighting(nn.Module):
    def __init__(self, kernel_size: int = 7):
        super().__init__()
        self.spatial_weighting = nn.Conv2d(2, 1, kernel_size=kernel_size, padding=kernel_size // 2, bias=False)
        self.activation = nn.Sigmoid()

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        mean_projection = torch.mean(x, dim=1, keepdim=True)
        max_projection, _ = torch.max(x, dim=1, keepdim=True)
        combined_projection = torch.cat([mean_projection, max_projection], dim=1)
        return x * self.activation(self.spatial_weighting(combined_projection))


class ProcessingBlock(nn.Module):
    def __init__(self, in_c: int, out_c: int, drop: float = 0.1) -> None:
        super().__init__()
        self.core_conv = nn.Conv2d(in_c, out_c, kernel_size=3, padding=1, bias=False)
        self.core_norm = nn.BatchNorm2d(out_c)
        self.refinement = FeatureWeighting()
        self.nonlinearity = nn.SiLU()  
        self.regularization = nn.Dropout2d(p=drop)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        out = self.nonlinearity(self.core_norm(self.core_conv(x)))
        out = self.regularization(out)
        return self.refinement(out)


class HierarchicalNetwork(nn.Module):
    def __init__(self, out_dims: int = 11):
        super().__init__()
        self.pre_processor = InputPreparer()
        
        self.stage_a = ProcessingBlock(32, 64, drop=0.1)
        self.downsampler_a = MagnitudeScaler(kernel_size=2, stride=2)
        
        self.stage_b = ProcessingBlock(64, 128, drop=0.1)
        self.downsampler_b = MagnitudeScaler(kernel_size=2, stride=2)
        
        self.stage_c = ProcessingBlock(128, 256, drop=0.1)
        self.global_reducer_a = nn.AdaptiveAvgPool2d(1)
        self.global_reducer_b = nn.AdaptiveMaxPool2d(1)
        
        self.decision_network = nn.Sequential(
            nn.Linear(256 * 2, 128),
            nn.SiLU(),
            nn.Dropout(0.2),
            nn.Linear(128, out_dims)
        )
        self._reset_parameters()


    def _reset_parameters(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.ones_(m.weight)
                nn.init.zeros_(m.bias)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.zeros_(m.bias)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.pre_processor(x)
        x = self.downsampler_a(self.stage_a(x))
        x = self.downsampler_b(self.stage_b(x))
        x = self.stage_c(x)
        
        reduced_a = self.global_reducer_a(x).view(x.size(0), -1)
        reduced_b = self.global_reducer_b(x).view(x.size(0), -1)
        
        return self.decision_network(torch.cat([reduced_a, reduced_b], dim=1))