"""HalfEdge GNN model definition (moved from brep_two_pass/scripts/03_infer_halfedge.py)."""
from __future__ import annotations
from typing import Optional

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import (
    HeteroConv, SAGEConv, JumpingKnowledge, BatchNorm,
    global_mean_pool, global_max_pool,
)
from torch_geometric.data import HeteroData


def resolve_reject_label(labels, requested: Optional[str]) -> Optional[str]:
    if requested:
        return requested
    lower_to_name = {name.lower(): name for name in labels}
    for candidate in ("random", "unknown", "other", "misc"):
        if candidate in lower_to_name:
            return lower_to_name[candidate]
    for name in labels:
        lower = name.lower()
        if "random" in lower or "unknown" in lower:
            return name
    return None


class HalfEdgeGNN(nn.Module):
    def __init__(
        self,
        coedge_in: int, face_in: int, edge_in: int, global_in: int,
        hidden=256, layers=6, dropout=0.2, num_classes=3,
        jk_mode="cat", gating_dim=None,
    ):
        super().__init__()
        self.convs = nn.ModuleList(); self.bns = nn.ModuleList()
        self.encoders = nn.ModuleDict({
            "coedge": nn.Sequential(nn.Linear(coedge_in, hidden), nn.ReLU(), nn.Dropout(dropout)),
            "face":   nn.Sequential(nn.Linear(face_in,   hidden), nn.ReLU(), nn.Dropout(dropout)),
            "edge":   nn.Sequential(nn.Linear(edge_in,   hidden), nn.ReLU(), nn.Dropout(dropout)),
        })
        for _ in range(layers):
            conv = HeteroConv({
                ('coedge','next','coedge'):     SAGEConv((hidden, hidden), hidden),
                ('coedge','prev','coedge'):     SAGEConv((hidden, hidden), hidden),
                ('coedge','mate','coedge'):     SAGEConv((hidden, hidden), hidden),
                ('coedge','to_face','face'):    SAGEConv((hidden, hidden), hidden),
                ('face','to_coedge','coedge'):  SAGEConv((hidden, hidden), hidden),
                ('coedge','to_edge','edge'):    SAGEConv((hidden, hidden), hidden),
                ('edge','to_coedge','coedge'):  SAGEConv((hidden, hidden), hidden),
                ('face','to_edge','edge'):      SAGEConv((hidden, hidden), hidden),
                ('edge','to_face','face'):      SAGEConv((hidden, hidden), hidden),
            }, aggr='sum')
            self.convs.append(conv)
            self.bns.append(nn.ModuleDict({
                "coedge": BatchNorm(hidden),
                "face":   BatchNorm(hidden),
                "edge":   BatchNorm(hidden),
            }))
        self.jk = JumpingKnowledge(mode=jk_mode)
        self.jk_out = hidden * layers if jk_mode == "cat" else hidden
        if gating_dim is None:
            gating_dim = hidden
        self.gating_dim = gating_dim
        self.pool_in = self.jk_out * 2
        self.proj = nn.Identity() if self.pool_in == gating_dim else nn.Linear(self.pool_in, gating_dim)

        self.global_mlp = nn.Sequential(
            nn.Linear(global_in, gating_dim),
            nn.ReLU(), nn.Dropout(0.3),
            nn.Linear(gating_dim, 2 * gating_dim),
        )
        self.head = nn.Sequential(
            nn.Linear(gating_dim, hidden),
            nn.ReLU(), nn.Dropout(dropout),
            nn.Linear(hidden, num_classes),
        )

    def forward(self, data: HeteroData):
        x = {
            "coedge": self.encoders["coedge"](data["coedge"].x),
            "face":   self.encoders["face"](data["face"].x),
            "edge":   self.encoders["edge"](data["edge"].x),
        }
        outs = []
        for conv, bn in zip(self.convs, self.bns):
            x_new = conv(x, data.edge_index_dict)
            x = {k: F.relu(bn[k](x_new[k]) + x[k]) for k in x}
            outs.append(x["coedge"])
        xj = self.jk(outs)
        batch = data['coedge'].batch
        g_mean = global_mean_pool(xj, batch)
        g_max  = global_max_pool(xj, batch)
        g = torch.cat([g_mean, g_max], dim=-1)
        g0 = self.proj(g)
        global_x = data["global"].x
        if global_x.dim() == 1:
            global_x = global_x.view(1, -1)
        if global_x.size(0) != g0.size(0):
            raise RuntimeError(f"Global feature batch mismatch: {global_x.size(0)} vs {g0.size(0)}")
        gb = self.global_mlp(global_x)
        gamma, beta = gb.chunk(2, dim=-1)
        gamma = torch.sigmoid(gamma)
        g_mod = g0 * gamma + beta
        return self.head(g_mod)