from __future__ import annotations

import torch
from torch import nn

from .clinical_encoder import ClinicalEncoder
from .ct_encoder import CTEncoder
from .fusion import SelectivePETFusion
from .pet_encoder import PETEncoder
from .support_net import SupportNet
from .survival_head import DiscreteTimeSurvivalHead


class CohortAwareCTModel(nn.Module):
    """End-to-end model matching the paper's first-stage reproducible modules."""

    def __init__(
        self,
        in_channels: int = 1,
        feature_dim: int = 256,
        clinical_dim: int = 0,
        survival_bins: int = 0,
        use_pet: bool = True,
        use_support: bool = True,
        clinical_use_missingness: bool = True,
        gate_mode: str = "selective",
    ) -> None:
        super().__init__()
        self.use_pet = use_pet
        self.use_support = use_support
        self.support_net = SupportNet(in_channels=in_channels)
        self.ct_encoder = CTEncoder(in_channels=in_channels + 1, feature_dim=feature_dim)
        self.pet_encoder = PETEncoder(in_channels=1, feature_dim=feature_dim) if use_pet else None
        self.clinical_encoder = ClinicalEncoder(
            clinical_dim=clinical_dim,
            feature_dim=feature_dim,
            use_missingness=clinical_use_missingness,
        )
        self.fusion = SelectivePETFusion(feature_dim=feature_dim, gate_mode=gate_mode)
        self.survival_head = (
            DiscreteTimeSurvivalHead(in_dim=feature_dim * 3, num_bins=survival_bins)
            if survival_bins > 0
            else None
        )

    def forward(self, batch: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]:
        ct = batch["ct"].float()
        support_logits = self.support_net(ct)
        support_prob = torch.sigmoid(support_logits) if self.use_support else torch.zeros_like(support_logits)
        ct_feat = self.ct_encoder(torch.cat([ct, support_prob], dim=1))

        clinical_feat = self.clinical_encoder(batch.get("clinical"), batch.get("clinical_missing"))
        pet_feat = None
        if self.use_pet and self.pet_encoder is not None and "pet" in batch:
            pet_feat = self.pet_encoder(batch["pet"].float())

        out = self.fusion(
            ct_feat=ct_feat,
            clinical_feat=clinical_feat,
            pet_feat=pet_feat,
            has_pet=batch.get("has_pet") if self.use_pet else torch.zeros(ct_feat.shape[0], device=ct_feat.device),
        )
        out["support_logits"] = support_logits
        out["support_prob"] = support_prob
        out["lesion_prob"] = torch.sigmoid(out["fused_logit"])
        if self.survival_head is not None:
            out["hazard_logits"] = self.survival_head(out["fused_features"])
        return out