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

"""
添加时间嵌入 + 引入图注意力网络（GAT）
"""

class DynamicGraphConstructor(nn.Module):
    def __init__(self, node_num, embed_dim):
        super().__init__()
        self.nodevec1 = nn.Parameter(torch.randn(node_num, embed_dim), requires_grad=True)
        self.nodevec2 = nn.Parameter(torch.randn(node_num, embed_dim), requires_grad=True)

    def forward(self):
        adj = torch.matmul(self.nodevec1, self.nodevec2.T)
        adj = F.relu(adj)
        adj = F.softmax(adj, dim=-1)
        return adj


# 原来的 GCN 块保留备用
class GraphConvBlock(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.theta = nn.Linear(input_dim, output_dim)
        self.residual = (input_dim == output_dim)
        if not self.residual:
            self.res_proj = nn.Linear(input_dim, output_dim)

    def forward(self, x, adj):
        res = x
        x = torch.matmul(adj, x)
        x = self.theta(x)
        x = x + (res if self.residual else self.res_proj(res))
        return F.relu(x)


# ★★ GAT 部分：从 LeronQ/GCN_predict-Pytorch 改写而来 ★★
class GraphAttentionLayer(nn.Module):
    def __init__(self, in_c, out_c):
        super().__init__()
        self.W = nn.Linear(in_c, out_c, bias=False)
        self.b = nn.Parameter(torch.Tensor(out_c))
        nn.init.xavier_uniform_(self.W.weight)
        nn.init.zeros_(self.b)

    def forward(self, h, adj):
        # h: [B, N, C_in], adj: [N, N]
        Wh = self.W(h)  # [B, N, C_out]
        # 计算注意力得分
        score = torch.bmm(Wh, Wh.transpose(1, 2)) * adj.unsqueeze(0)  # [B, N, N]
        score = score.masked_fill(score == 0, -1e16)
        alpha = F.softmax(score, dim=-1)  # [B, N, N]
        # 加权求和并加偏置
        out = torch.bmm(alpha, Wh) + self.b  # [B, N, C_out]
        return F.relu(out)

class GraphAttentionBlock(nn.Module):
    def __init__(self, input_dim, output_dim, n_heads=4):
        super().__init__()
        # 多头注意力
        self.heads = nn.ModuleList([GraphAttentionLayer(input_dim, output_dim) for _ in range(n_heads)])
        # 合并后再做一次线性映射
        self.out_att = GraphAttentionLayer(output_dim * n_heads, output_dim)
        self.act = nn.ReLU()

    def forward(self, x, adj):
        # x: [B, N, C], adj: [N, N]
        # 并行多头，然后拼接
        h_cat = torch.cat([head(x, adj) for head in self.heads], dim=-1)  # [B, N, output_dim * n_heads]
        h_out = self.out_att(h_cat, adj)  # [B, N, output_dim]
        return self.act(h_out)


class MANBA_Block(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.attn = nn.MultiheadAttention(embed_dim=input_dim, num_heads=4, batch_first=True)
        self.ffn = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, input_dim)
        )
        self.norm1 = nn.LayerNorm(input_dim)
        self.norm2 = nn.LayerNorm(input_dim)

    def forward(self, x):
        res = x
        x_attn, _ = self.attn(x, x, x)
        x = self.norm1(res + x_attn)
        res2 = x
        x_ffn = self.ffn(x)
        x = self.norm2(res2 + x_ffn)
        return x


class SandwichBlock(nn.Module):
    def __init__(self, num_nodes, embed_dim, hidden_dim):
        super().__init__()
        self.manba1 = MANBA_Block(hidden_dim, hidden_dim * 2)
        self.graph_constructor = DynamicGraphConstructor(num_nodes, embed_dim)
        # ★★ 替换为 GATBlock ★★
        self.gc = GraphAttentionBlock(hidden_dim, hidden_dim, n_heads=4)
        self.manba2 = MANBA_Block(hidden_dim, hidden_dim * 2)

    def forward(self, h):
        h1 = self.manba1(h)
        adj = self.graph_constructor()
        h2 = self.gc(h1, adj)
        h3 = self.manba2(h2)
        return h3


class MLP(nn.Module):
    def __init__(self, in_dim, hidden_dims, out_dim, activation=nn.ReLU):
        super().__init__()
        dims = [in_dim] + hidden_dims + [out_dim]
        layers = []
        for i in range(len(dims)-2):
            layers += [nn.Linear(dims[i], dims[i+1]), activation()]
        layers += [nn.Linear(dims[-2], dims[-1])]
        self.net = nn.Sequential(*layers)

    def forward(self, x):
        return self.net(x)


class EXP(nn.Module):
    def __init__(self, args):
        super().__init__()
        self.horizon     = args['horizon']
        self.output_dim  = args['output_dim']
        self.seq_len     = args.get('in_len', 12)
        self.hidden_dim  = args.get('hidden_dim', 64)
        self.num_nodes   = args['num_nodes']
        self.embed_dim   = args.get('embed_dim', 16)

        # ==== 新增：离散时间嵌入 ====
        self.time_slots = args.get('time_slots', 24 * 60 // args.get('time_slot', 5))
        self.time_embedding = nn.Embedding(self.time_slots, self.hidden_dim)
        self.day_embedding  = nn.Embedding(7, self.hidden_dim)

        # 输入投影（仅 flow）
        self.input_proj = MLP(
            in_dim      = self.seq_len,
            hidden_dims = [self.hidden_dim],
            out_dim     = self.hidden_dim
        )

        # 两个 SandwichBlock（已替换为 GAT）
        self.sandwich1 = SandwichBlock(self.num_nodes, self.embed_dim, self.hidden_dim)
        self.sandwich2 = SandwichBlock(self.num_nodes, self.embed_dim, self.hidden_dim)

        # 输出投影
        self.out_proj = MLP(
            in_dim      = self.hidden_dim,
            hidden_dims = [2 * self.hidden_dim],
            out_dim     = self.horizon * self.output_dim
        )

    def forward(self, x):
        """
        x: (B, T, N, D_total)
           D_total >= 3, x[...,0]=flow, x[...,1]=time_in_day, x[...,2]=day_in_week
        """
        x_flow = x[..., 0]  # (B, T, N)
        x_time = x[..., 1]  # (B, T, N)
        x_day  = x[..., 2]  # (B, T, N)

        B, T, N = x_flow.shape
        assert T == self.seq_len

        # 1) 投影流量历史
        x_flat = x_flow.permute(0, 2, 1).reshape(B * N, T)
        h0 = self.input_proj(x_flat).view(B, N, self.hidden_dim)

        # 2) 取最后一步的时间索引并嵌入
        t_idx = (x_time[:, -1, :,] * (self.time_slots - 1)).long()
        d_idx = x_day[:,  -1, :,].long()
        time_emb = self.time_embedding(t_idx)
        day_emb  = self.day_embedding(d_idx)

        # 3) 注入时间信息
        h0 = h0 + time_emb + day_emb

        # 4) Sandwich + 残差
        h1 = self.sandwich1(h0)
        h1 = h1 + h0
        h2 = self.sandwich2(h1)

        # 5) 输出
        out = self.out_proj(h2)
        out = out.view(B, N, self.horizon, self.output_dim).permute(0, 2, 1, 3)
        return out