import torch
import torch.nn as nn

from timm.models.layers import PatchEmbed, Mlp, DropPath
from timm.models.registry import register_model

class Attention(nn.Module):
    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
        super().__init__()
        self.num_heads = num_heads
        head_dim = dim // num_heads
        self.scale = qk_scale or head_dim ** -0.5

        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(dim, dim)
        self.proj_drop = nn.Dropout(proj_drop)

    def forward(self, x):
        B, N, C = x.shape
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
        q, k, v = qkv[0], qkv[1], qkv[2]   # make torchscript happy (cannot use tensor as tuple)

        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)

        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
        x = self.proj(x)
        x = self.proj_drop(x)
        return x

class Block(nn.Module):
    
    def __init__(self, dim, num_heads=8, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
        super().__init__()
        self.norm1 = norm_layer(dim)
        self.attn = Attention(
            dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
        self.norm2 = norm_layer(dim)
        mlp_hidden_dim = int(dim * mlp_ratio)
        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)

    def forward(self, x):
        x = x + self.drop_path(self.attn(self.norm1(x)))
        x = x + self.drop_path(self.mlp(self.norm2(x)))
        return x

class EEGTransformer(nn.Module):
    def __init__(self):
        super().__init__()
        self.dim = 4000
        self.decoder_depth = 1
        self.blocks = nn.Sequential(*[
            Block(
                dim= self.dim,
                drop= 0.2,
                attn_drop= 0.2,
            )
            for i in range(self.decoder_depth)])
        self.relu = nn.ReLU()
        # self.softmax = nn.Softmax()
        self.cls_token = nn.Parameter(torch.zeros(1, 1, self.dim)) # 1, 1, 8000

        # self.fc1 = nn.Linear(60, 512)
        self.fc1 = nn.Linear(self.dim, 512)

        self.fc2 = nn.Linear(512, 3)

        
        torch.nn.init.normal_(self.cls_token, std=.02)
        
    def forward(self, x):
        # x -> bz x 59 x 8000
        # print(x.shape)
        cls_token = self.cls_token.repeat(x.shape[0], 1, 1) # bz x 1 x 8000
        x = torch.cat((x, cls_token), 1) # bz x 60 x 8000
        x = self.blocks(x)

        # cls_token = x[:, -1, :].squeeze(1).unsqueeze(-1) # bz x 8000 x 1
        # attn_map = torch.bmm(x, cls_token).squeeze(-1) # bz x 60
        # attn_map = self.relu(self.fc1(attn_map))
        # attn_map = self.fc2(attn_map)
        # return attn_map

        cls_token = x[:, -1, :].squeeze(1)
        cls_token = self.relu(self.fc1(cls_token))
        cls_token = self.fc2(cls_token)
        return cls_token
    
@register_model
def eegt(**kwargs):
    model = EEGTransformer()
    return model