from __future__ import annotations

import math

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

from .features import COCO_BONES, NUM_JOINTS


def coco_adjacency(device: torch.device | None = None) -> torch.Tensor:
    a = torch.eye(NUM_JOINTS, dtype=torch.float32, device=device)
    for i, j in COCO_BONES:
        a[i, j] = 1
        a[j, i] = 1
    deg = a.sum(-1, keepdim=True).clamp_min(1)
    return a / deg


class GraphTemporalBlock(nn.Module):
    def __init__(self, in_ch: int, out_ch: int, adaptive: bool = False, channel_refine: bool = False):
        super().__init__()
        self.register_buffer("base_adj", coco_adjacency())
        self.adaptive = adaptive
        self.channel_refine = channel_refine
        if adaptive:
            self.delta = nn.Parameter(torch.zeros(NUM_JOINTS, NUM_JOINTS))
        if channel_refine:
            self.channel_gate = nn.Parameter(torch.zeros(out_ch, NUM_JOINTS, NUM_JOINTS))
        self.spatial = nn.Linear(in_ch, out_ch)
        self.temporal = nn.Sequential(
            nn.Conv2d(out_ch, out_ch, kernel_size=(3, 1), padding=(1, 0)),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
        )
        self.res = nn.Linear(in_ch, out_ch) if in_ch != out_ch else nn.Identity()

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: B,T,V,C
        adj = self.base_adj
        if self.adaptive:
            adj = adj + torch.softmax(self.delta, dim=-1)
        h = torch.einsum("btvc,vw->btwc", x, adj)
        h = self.spatial(h)
        if self.channel_refine:
            ref = torch.softmax(self.channel_gate, dim=-1)
            h2 = torch.einsum("btvc,cvw->btwc", h, ref)
            h = h + h2
        h = h + self.res(x)
        h = h.permute(0, 3, 1, 2)
        h = self.temporal(h)
        return h.permute(0, 2, 3, 1)


class GraphEncoder(nn.Module):
    def __init__(self, in_ch: int, hidden: int, adaptive: bool = False, channel_refine: bool = False):
        super().__init__()
        self.net = nn.Sequential(
            GraphTemporalBlock(in_ch, hidden, adaptive, channel_refine),
            GraphTemporalBlock(hidden, hidden, adaptive, channel_refine),
            GraphTemporalBlock(hidden, hidden, adaptive, channel_refine),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        h = self.net(x)
        return h.mean(dim=(1, 2))


class LSTMClassifier(nn.Module):
    def __init__(self, hidden: int = 96, num_classes: int = 2, **_: object):
        super().__init__()
        self.lstm = nn.LSTM(NUM_JOINTS * 3, hidden, batch_first=True, bidirectional=True)
        self.head = nn.Sequential(nn.Dropout(0.25), nn.Linear(hidden * 2, num_classes))

    def forward(self, batch: dict[str, torch.Tensor]) -> torch.Tensor:
        x = batch["joint"].flatten(2)
        out, _ = self.lstm(x)
        return self.head(out[:, -1])


class STGCNClassifier(nn.Module):
    def __init__(self, hidden: int = 96, num_classes: int = 2, **_: object):
        super().__init__()
        self.enc = GraphEncoder(3, hidden)
        self.head = nn.Linear(hidden, num_classes)

    def forward(self, batch: dict[str, torch.Tensor]) -> torch.Tensor:
        return self.head(self.enc(batch["joint"]))


class AGCNClassifier(nn.Module):
    def __init__(self, hidden: int = 96, num_classes: int = 2, **_: object):
        super().__init__()
        self.joint = GraphEncoder(3, hidden, adaptive=True)
        self.bone = GraphEncoder(3, hidden, adaptive=True)
        self.head = nn.Linear(hidden * 2, num_classes)

    def forward(self, batch: dict[str, torch.Tensor]) -> torch.Tensor:
        h = torch.cat([self.joint(batch["joint"]), self.bone(batch["bone"])], dim=1)
        return self.head(h)


class CTRGCNClassifier(nn.Module):
    def __init__(self, hidden: int = 96, num_classes: int = 2, **_: object):
        super().__init__()
        self.joint = GraphEncoder(3, hidden, adaptive=True, channel_refine=True)
        self.bone = GraphEncoder(3, hidden, adaptive=True, channel_refine=True)
        self.head = nn.Linear(hidden * 2, num_classes)

    def forward(self, batch: dict[str, torch.Tensor]) -> torch.Tensor:
        h = torch.cat([self.joint(batch["joint"]), self.bone(batch["bone"])], dim=1)
        return self.head(h)


class TCNTEClassifier(nn.Module):
    def __init__(self, hidden: int = 96, num_classes: int = 2, **_: object):
        super().__init__()
        self.proj = nn.Linear(NUM_JOINTS * 3, hidden)
        self.tcn = nn.Sequential(
            nn.Conv1d(hidden, hidden, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv1d(hidden, hidden, 3, padding=2, dilation=2),
            nn.ReLU(inplace=True),
        )
        layer = nn.TransformerEncoderLayer(hidden, nhead=4, batch_first=True, dim_feedforward=hidden * 2)
        self.tx = nn.TransformerEncoder(layer, num_layers=2)
        self.head = nn.Linear(hidden, num_classes)

    def forward(self, batch: dict[str, torch.Tensor]) -> torch.Tensor:
        x = self.proj(batch["joint"].flatten(2))
        x = self.tcn(x.transpose(1, 2)).transpose(1, 2)
        x = self.tx(x)
        return self.head(x.mean(1))


class PoseC3DClassifier(nn.Module):
    def __init__(self, hidden: int = 96, num_classes: int = 2, **_: object):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv3d(1, 16, kernel_size=3, padding=1),
            nn.BatchNorm3d(16),
            nn.ReLU(inplace=True),
            nn.MaxPool3d((1, 2, 2)),
            nn.Conv3d(16, 32, kernel_size=3, padding=1),
            nn.BatchNorm3d(32),
            nn.ReLU(inplace=True),
            nn.AdaptiveAvgPool3d(1),
        )
        self.head = nn.Linear(32, num_classes)

    def forward(self, batch: dict[str, torch.Tensor]) -> torch.Tensor:
        heat = pose_heatmap(batch["joint"])
        h = self.net(heat).flatten(1)
        return self.head(h)


def pose_heatmap(joint: torch.Tensor, size: int = 32, sigma: float = 1.5) -> torch.Tensor:
    b, t, v, _ = joint.shape
    xy = (joint[..., :2].clamp(-1.5, 1.5) + 1.5) / 3.0 * (size - 1)
    conf = joint[..., 2].clamp(0, 1)
    yy, xx = torch.meshgrid(
        torch.arange(size, device=joint.device),
        torch.arange(size, device=joint.device),
        indexing="ij",
    )
    grid = torch.stack([xx, yy], dim=0).float()
    heat = []
    for k in range(v):
        mu = xy[:, :, k].view(b, t, 2, 1, 1)
        dist = ((grid.view(1, 1, 2, size, size) - mu) ** 2).sum(2)
        hm = torch.exp(-dist / (2 * sigma * sigma)) * conf[:, :, k].view(b, t, 1, 1)
        heat.append(hm)
    return torch.stack(heat, dim=0).amax(0).unsqueeze(1)


class DynamicsEncoder(nn.Module):
    def __init__(self, in_ch: int, hidden: int):
        super().__init__()
        self.proj = nn.Linear(NUM_JOINTS * in_ch, hidden)
        self.tcn = nn.Sequential(
            nn.Conv1d(hidden, hidden, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv1d(hidden, hidden, 3, padding=1),
            nn.ReLU(inplace=True),
        )
        self.att = nn.Linear(hidden, 1)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        h = self.proj(x.flatten(2))
        h = self.tcn(h.transpose(1, 2)).transpose(1, 2)
        w = torch.softmax(self.att(h), dim=1)
        return (h * w).sum(1)


class DynaFallGCN(nn.Module):
    def __init__(
        self,
        hidden: int = 96,
        num_classes: int = 2,
        use_bone: bool = True,
        use_dyn: bool = True,
        **_: object,
    ):
        super().__init__()
        self.use_bone = use_bone
        self.use_dyn = use_dyn
        self.joint = GraphEncoder(3, hidden, adaptive=True)
        if use_bone:
            self.bone = GraphEncoder(3, hidden, adaptive=True)
        if use_dyn:
            self.dyn = DynamicsEncoder(9, hidden)
        streams = 1 + int(use_bone) + int(use_dyn)
        self.head = nn.Sequential(
            nn.LayerNorm(hidden * streams),
            nn.Dropout(0.25),
            nn.Linear(hidden * streams, hidden),
            nn.ReLU(inplace=True),
            nn.Linear(hidden, num_classes),
        )

    def forward(self, batch: dict[str, torch.Tensor]) -> torch.Tensor:
        hs = [self.joint(batch["joint"])]
        if self.use_bone:
            hs.append(self.bone(batch["bone"]))
        if self.use_dyn:
            hs.append(self.dyn(batch["dyn"]))
        return self.head(torch.cat(hs, dim=1))


MODEL_REGISTRY = {
    "lstm": LSTMClassifier,
    "stgcn": STGCNClassifier,
    "agcn": AGCNClassifier,
    "ctrgcn": CTRGCNClassifier,
    "posec3d": PoseC3DClassifier,
    "tcnte": TCNTEClassifier,
    "dynafall": DynaFallGCN,
    "dynafall_joint": lambda **kw: DynaFallGCN(use_bone=False, use_dyn=False, **kw),
    "dynafall_joint_bone": lambda **kw: DynaFallGCN(use_bone=True, use_dyn=False, **kw),
    "dynafall_full_no_dropout": lambda **kw: DynaFallGCN(use_bone=True, use_dyn=True, **kw),
    "dynafall_random_dropout": lambda **kw: DynaFallGCN(use_bone=True, use_dyn=True, **kw),
}


def build_model(name: str, hidden: int = 96, num_classes: int = 2) -> nn.Module:
    if name not in MODEL_REGISTRY:
        raise KeyError(f"Unknown method {name}. Available: {sorted(MODEL_REGISTRY)}")
    return MODEL_REGISTRY[name](hidden=hidden, num_classes=num_classes)