# Mask Conditioner for Medical Image Generation
# Encodes segmentation mask into conditioning embedding

import torch
import torch.nn as nn
from src.models.conditioner.base import BaseConditioner


class MaskEncoder(nn.Module):
    """
    Encode segmentation mask to a conditioning vector.
    Uses a simple CNN to extract spatial features, then global pooling.
    """
    def __init__(self, hidden_size, in_channels=1, img_size=256):
        super().__init__()
        self.hidden_size = hidden_size

        # Simple CNN encoder for mask
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 32, kernel_size=7, stride=2, padding=3),  # 128x128
            nn.GroupNorm(8, 32),
            nn.SiLU(),
            nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),  # 64x64
            nn.GroupNorm(8, 64),
            nn.SiLU(),
            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),  # 32x32
            nn.GroupNorm(8, 128),
            nn.SiLU(),
            nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1),  # 16x16
            nn.GroupNorm(8, 256),
            nn.SiLU(),
            nn.AdaptiveAvgPool2d((1, 1)),  # Global pooling
        )
        self.proj = nn.Sequential(
            nn.Linear(256, hidden_size),
            nn.SiLU(),
            nn.Linear(hidden_size, hidden_size),
        )

        self._init_weights()

    def _init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, std=0.02)
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)

    def forward(self, mask):
        """
        Args:
            mask: [N, C, H, W] in range [0, 1]
        Returns:
            mask_emb: [N, hidden_size]
        """
        feat = self.encoder(mask)  # [N, 256, 1, 1]
        feat = feat.flatten(1)     # [N, 256]
        return self.proj(feat)     # [N, hidden_size]


class MaskConditioner(BaseConditioner):
    """
    Conditioner that encodes segmentation masks into embeddings.

    For conditional generation: uses mask embedding
    For unconditional generation: uses zero embedding (null condition)
    """
    def __init__(self, hidden_size, in_channels=1, img_size=256, null_condition_p=0.1):
        super().__init__()
        self.mask_encoder = MaskEncoder(hidden_size, in_channels, img_size)
        self.hidden_size = hidden_size
        self.null_condition_p = null_condition_p

        # Learnable null condition embedding
        self.null_embedding = nn.Parameter(torch.zeros(hidden_size))
        nn.init.normal_(self.null_embedding, std=0.02)

    def _extract_mask(self, metadata):
        """
        Extract mask from metadata, handling both formats:
        - dict with batched tensors: {'mask': [N, C, H, W]}
        - tuple/list of dicts: ({'mask': [C, H, W]}, ...)
        """
        if isinstance(metadata, dict):
            return metadata.get('mask', None)
        elif isinstance(metadata, (list, tuple)):
            # Stack masks from list of dicts
            masks = [m.get('mask', None) for m in metadata if isinstance(m, dict)]
            if len(masks) > 0 and masks[0] is not None:
                return torch.stack(masks, dim=0)
        return None

    def _impl_condition(self, y, metadata):
        """
        Args:
            y: Not used (kept for interface compatibility)
            metadata: Dict or tuple/list of dicts containing 'mask'
        Returns:
            condition: [N, hidden_size] mask embedding
        """
        mask = self._extract_mask(metadata)
        if mask is None:
            raise ValueError("MaskConditioner requires mask in metadata")

        # Move mask to same device as encoder
        device = next(self.mask_encoder.parameters()).device
        mask = mask.to(device)

        # Encode mask
        condition = self.mask_encoder(mask)

        return condition

    def _impl_uncondition(self, y, metadata):
        """
        Returns null condition embedding for CFG.
        """
        mask = self._extract_mask(metadata)
        if mask is None:
            raise ValueError("MaskConditioner requires mask in metadata")

        batch_size = mask.shape[0]
        device = next(self.mask_encoder.parameters()).device

        # Return null embedding expanded to batch size
        uncondition = self.null_embedding.unsqueeze(0).expand(batch_size, -1)
        return uncondition.to(device)

    def forward_with_dropout(self, mask, training=True):
        """
        Forward with random null conditioning (CFG training).

        Args:
            mask: [N, C, H, W]
            training: Whether in training mode
        Returns:
            condition: [N, hidden_size]
        """
        batch_size = mask.shape[0]
        device = mask.device

        # Encode mask
        condition = self.mask_encoder(mask)

        if training and self.null_condition_p > 0:
            # Randomly replace some conditions with null embedding
            null_mask = torch.rand(batch_size, device=device) < self.null_condition_p
            null_emb = self.null_embedding.unsqueeze(0).expand(batch_size, -1)
            condition = torch.where(null_mask.unsqueeze(-1), null_emb, condition)

        return condition