import torch
from torch import nn, Tensor, einsum, IntTensor, FloatTensor, BoolTensor
from torch.nn import Module
import torch.nn.functional as F
import random
from beartype import beartype
from beartype.typing import Tuple, Optional, List, Union

from einops.layers.torch import Rearrange
from einops import rearrange, repeat, reduce, pack, unpack

from modules.audio2motion.cfm.utils import exists, identity, default, divisible_by, is_odd, coin_flip, pack_one, unpack_one
from modules.audio2motion.cfm.utils import prob_mask_like, reduce_masks_with_and, interpolate_1d, curtail_or_pad, mask_from_start_end_indices, mask_from_frac_lengths
from modules.audio2motion.cfm.module import ConvPositionEmbed, LearnedSinusoidalPosEmb, Transformer
from torch.cuda.amp import autocast

class InContextTransformerAudio2Motion(Module):
    def __init__(
        self,
        *,
        dim_in = 64, # expression code
        dim_audio_in = 1024,
        dim = 1024,
        depth = 24,
        dim_head = 64,
        heads = 16,
        ff_mult = 4,
        ff_dropout = 0.,
        time_hidden_dim = None,
        conv_pos_embed_kernel_size = 31,
        conv_pos_embed_groups = None,
        attn_dropout = 0,
        attn_flash = False,
        attn_qk_norm = True,
        use_gateloop_layers = False,
        num_register_tokens = 16,
        frac_lengths_mask: Tuple[float, float] = (0.7, 1.),
    ):
        super().__init__()
        dim_in = default(dim_in, dim)

        time_hidden_dim = default(time_hidden_dim, dim * 4)

        self.proj_in = nn.Identity()
        self.sinu_pos_emb = nn.Sequential(
            LearnedSinusoidalPosEmb(dim),
            nn.Linear(dim, time_hidden_dim),
            nn.SiLU()
        )

        self.dim_audio_in = dim_audio_in
        if self.dim_audio_in != dim_in:
            self.to_cond_emb = nn.Linear(self.dim_audio_in, dim_in)
        else:
            self.to_cond_emb = nn.Identity()

        # self.p_drop_prob = p_drop_prob
        self.frac_lengths_mask = frac_lengths_mask

        self.to_embed = nn.Linear(dim_in * 2 + dim_in, dim)

        self.null_cond = nn.Parameter(torch.zeros(dim_in))

        self.conv_embed = ConvPositionEmbed(
            dim = dim,
            kernel_size = conv_pos_embed_kernel_size,
            groups = conv_pos_embed_groups
        )

        self.transformer = Transformer(
            dim = dim,
            depth = depth,
            dim_head = dim_head,
            heads = heads,
            ff_mult = ff_mult,
            ff_dropout = ff_dropout,
            attn_dropout= attn_dropout,
            attn_flash = attn_flash,
            attn_qk_norm = attn_qk_norm,
            num_register_tokens = num_register_tokens,
            adaptive_rmsnorm = True,
            adaptive_rmsnorm_cond_dim_in = time_hidden_dim,
            use_gateloop_layers = use_gateloop_layers
        )

        dim_out = dim_in # expression code
        self.to_pred = nn.Linear(dim, dim_out, bias = False)

    @property
    def device(self):
        return next(self.parameters()).device

    @torch.inference_mode()
    def forward_with_cond_scale(
        self,
        *args,
        cond_scale = 1.,
        **kwargs
    ):
        # classifier-free gudiance
        logits = self.forward(*args, cond_drop_prob = 0., **kwargs)

        if cond_scale == 1.:
            return logits

        null_logits = self.forward(*args, cond_drop_prob = 1., **kwargs)
        return null_logits + (logits - null_logits) * cond_scale

    def forward(
        self,
        x, # noised y0 of landmark
        *,
        times, # random in 0~1
        cond_audio, # driving audio
        self_attn_mask = None, # x_mask, since the length of samples in a batch are different
        cond_drop_prob = 0.1,
        target = None, # GT landmark, if None, infer mode
        cond = None, # reference landmark
        cond_mask = None, # mask that denotes frames to be predict as True
        ret=None
    ):
        if ret is None:
            ret = {}
        # project in, in case codebook dim is not equal to model dimensions
        # x 和 cond 是相同shape的，不同的是，x是target加噪声的结果，而cond是对target做mask后得到的reference。
        x = self.proj_in(x) 

        if exists(cond):
            cond = self.proj_in(cond)

        cond = default(cond, x) # x和cond的区别，见上面的分析

        # shapes
        batch, seq_len, cond_dim = cond.shape
        assert cond_dim == x.shape[-1]

        # auto manage shape of times, for odeint times

        if times.ndim == 0:
            times = repeat(times, '-> b', b = cond.shape[0])

        if times.ndim == 1 and times.shape[0] == 1:
            times = repeat(times, '1 -> b', b = cond.shape[0])

        # construct conditioning mask if not given
        if self.training:
            # 被mask住的就是要predict的部分
            if not exists(cond_mask):
                if coin_flip(): # 0.5 概率
                    frac_lengths = torch.zeros((batch,), device = self.device).float().uniform_(*self.frac_lengths_mask) # 0.7,1.0
                    # 这样得到的mask是连续的一个fraction
                    cond_mask = mask_from_frac_lengths(seq_len, frac_lengths)
                else:
                    # 这样得到的mask是散成豆花的
                    p_drop_prob_ = self.frac_lengths_mask[0] + random.random()*(self.frac_lengths_mask[1]-self.frac_lengths_mask[0])
                    cond_mask = prob_mask_like((batch, seq_len), p_drop_prob_, self.device)
                    # cond_mask = prob_mask_like((batch, seq_len), self.p_drop_prob, self.device)
        else:
            if not exists(cond_mask):
                # cond就是sample
                # 没有cond mask,代表没有reference audio, 所以直接mask住所有
                cond_mask = torch.ones((batch, seq_len), device = cond.device, dtype = torch.bool) 
        cond_mask_with_pad_dim = rearrange(cond_mask, '... -> ... 1') # 这个mask的意思是，True代表需要predict，False代表是reference

        # as described in section 3.2
        x = x * cond_mask_with_pad_dim # 这个是y0，源于noise，需要预测的部分保留为noise，不需要预测的reference部分被变成0
        cond = cond * ~cond_mask_with_pad_dim # 这个是reference音频, 所以标志出来需要pred的部分都变成0了

        # used by forward_with_cond_scale to achieve classifier free guidance
        # cond_drop_prob==1.0 denotes unconditional result
        if cond_drop_prob > 0.:
            cond_drop_mask = prob_mask_like(cond.shape[:1], cond_drop_prob, self.device) # 这个mask是散成豆花的

            # 随机对reference landmark 做dropout
            cond = torch.where(
                rearrange(cond_drop_mask, '... -> ... 1 1'), # cond
                self.null_cond, # fill true
                cond # fill false
            )

        # phoneme or semantic conditioning embedding
        cond_audio_emb = self.to_cond_emb(cond_audio)
        cond_audio_emb_length = cond_audio_emb.shape[-2]
        if cond_audio_emb_length != seq_len:
            cond_audio_emb = rearrange(cond_audio_emb, 'b n d -> b d n')
            cond_audio_emb = interpolate_1d(cond_audio_emb, seq_len)
            cond_audio_emb = rearrange(cond_audio_emb, 'b d n -> b n d')
            if exists(self_attn_mask):
                self_attn_mask = interpolate_1d(self_attn_mask, seq_len)

        # concat source signal, driving audio, and reference landmark
        # and project
        to_concat = [*filter(exists, (x, cond_audio_emb, cond))]
        embed = torch.cat(to_concat, dim = -1)

        x = self.to_embed(embed)

        x = self.conv_embed(x) + x

        time_emb = self.sinu_pos_emb(times)

        # attend

        x = self.transformer(
            x,
            mask = self_attn_mask,
            adaptive_rmsnorm_cond = time_emb
        )

        x = self.to_pred(x)
        # if no target passed in, just return logits
        ret['pred'] = x

        if not exists(target):
            # 不提供target，默认是infer模式，直接输出sample
            return x
        else:
            # 提供target，默认training模式，输出loss
            loss_mask = reduce_masks_with_and(cond_mask, self_attn_mask)
            if not exists(loss_mask):
                return F.mse_loss(x, target)
            ret['loss_mask'] = loss_mask
            loss = F.mse_loss(x, target, reduction = 'none')

            loss = reduce(loss, 'b n d -> b n', 'mean')
            loss = loss.masked_fill(~loss_mask, 0.)

            # masked mean

            num = reduce(loss, 'b n -> b', 'sum')
            den = loss_mask.sum(dim = -1).clamp(min = 1e-5)
            loss = num / den
            loss = loss.mean()
            ret['mse'] = loss
            return loss


if __name__ == '__main__':
    # Create an instance of the VoiceBox model
    model = InContextTransformerAudio2Motion()

    # Generate a random input tensor using torch.randn
    input_tensor = torch.randn(2, 125, 64)  # Assuming input shape is (batch_size, dim_in)
    time_tensor = torch.rand(2)  # Assuming input shape is (batch_size, dim_in)
    audio_tensor = torch.rand(2, 125, 1024)  # Assuming input shape is (batch_size, dim_in)

    # Pass the input tensor through the VoiceBox model
    output = model.forward_with_cond_scale(input_tensor, times=time_tensor, cond_audio=audio_tensor, cond=input_tensor)

    # Print the shape of the output tensor
    print(output.shape)