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

from .transformers import TransformerDecoder, TransformerDecoderLayer, TransformerEncoderLayer, TransformerEncoder, CrossAttnOnlyLayer, AlibiPostionEmbedding
import numpy as np
import statistics

class TTSDecoder(nn.Module):
    def __init__(self, hp):
        super().__init__()
        self.hp = hp
        self.encoder = TransformerEncoder(
            nn.ModuleList(
                [TransformerEncoderLayer(hp) for i in range(hp.enc_nlayers)]
            )
        )
        self.decoder = TransformerDecoder(
            nn.ModuleList(
                [TransformerDecoderLayer(hp, with_cross_attention=False) for i in range(hp.dec_nlayers)]
            )
        )

        self.layer_norm_phone = nn.LayerNorm(hp.hidden_size, eps=hp.layer_norm_eps)
        self.layer_norm_spkr = nn.LayerNorm(hp.hidden_size, eps=hp.layer_norm_eps)
        self.alibi = AlibiPostionEmbedding(hp.nheads, 10000)
        self.layer_norm = nn.LayerNorm(hp.hidden_size, eps=hp.layer_norm_eps)
        self.tgt_mask = (torch.tril(torch.ones(10000, 10000), diagonal=0) == 0)
        print("encoder: %.2fM" % (sum([param.nelement() for param in self.encoder.parameters()]) / 1e6))
        print("decoder: %.2fM" % (sum([param.nelement() for param in self.decoder.parameters()]) / 1e6))
        self.token_embedding = nn.Embedding(hp.n_codes+2, hp.hidden_size)
        self.head = nn.Linear(hp.hidden_size, hp.n_codes+2, bias=False)


    def forward(self, q, phone, spkr, q_mask, phone_mask):
        #Fused phone + speaker
        ex_phone_mask = torch.cat([torch.zeros((spkr.size(0), 1), device=spkr.device, dtype=torch.bool),
                                   phone_mask], 1) if phone_mask is not None else None
        spkr = self.layer_norm_spkr(spkr.unsqueeze(1))
        phone = self.layer_norm_phone(phone)
        phone = torch.cat([spkr, phone], 1)
        phone_alibi = self.alibi(phone)
        phone_alibi[:, 0] = 0
        phone_alibi[:, :, 0] = 0
        phone, enc_attn = self.encoder(phone, mask=None, attn_bias=phone_alibi, src_key_padding_mask=ex_phone_mask)
        phone = phone[:, 1:]

        #Run decoder
        q_mask = torch.cat([torch.zeros((spkr.size(0), 1), device=spkr.device, dtype=torch.bool),
                            q_mask], 1) if q_mask is not None else None
        q_input = q
        q = self.token_embedding(q[:, :,1])
        q = self.layer_norm(q)
        q = torch.cat([spkr, q], 1)
        tgt_len = q.size(1)
        tgt_mask = self.tgt_mask[: tgt_len, : tgt_len].to(q.device)
        audio_alibi = self.alibi(q)
        audio_alibi[:, 0] = 0
        audio_alibi[:, :, 0] = 0

        assert q.size(1) == phone.size(1)+2 #spkr  + EOS
        phone = torch.cat([torch.zeros(phone.size(0), 1, phone.size(2), device=phone.device), phone, torch.zeros(phone.size(0), 1, phone.size(2), device=phone.device)], 1)

        q = q + phone
        output, _, dec_attn, _ = self.decoder(q, memory=None,
                                              tgt_mask=tgt_mask,
                                              attn_bias=audio_alibi,
                                              tgt_key_padding_mask=q_mask,
                                              memory_key_padding_mask=None)
        audio_output = output[:, 1:]
        audio_output = self.head(audio_output)
        return {
            'logits': audio_output,
            'decoder_attention': dec_attn,
            'encoder_attention': enc_attn,
        }

    def encode_phone(self, phone, spkr, phone_mask):
        phone = self.layer_norm_phone(phone)
        phone = torch.cat([spkr, phone], 1)
        ex_phone_mask = torch.cat([torch.zeros((spkr.size(0), 1), device=spkr.device, dtype=torch.bool), phone_mask], 1)
        phone_alibi = self.alibi(phone)
        phone_alibi[:, 0] = 0
        phone_alibi[:, :, 0] = 0
        phone, enc_attn = self.encoder(phone, mask=None, attn_bias=phone_alibi, src_key_padding_mask=ex_phone_mask)
        phone = phone[:, 1:]
        phone = torch.cat([torch.zeros(phone.size(0), 1, phone.size(2), device=phone.device), phone, torch.zeros(phone.size(0), 1, phone.size(2), device=phone.device)], 1)

        return phone

    def inference_topkp_sampling_batch(self, phone, spkr, phone_mask, prior=None,tgt_phonemes=None,cfg_scale=1, **kwargs):
        batch_size = phone.size(0)
        spkr = self.layer_norm_spkr(spkr.unsqueeze(1))
        bos = torch.LongTensor([[self.hp.n_codes+1]], device=phone.device)
        inp = self.layer_norm(self.token_embedding(bos)) #1, 1, C
        inp = inp.expand(batch_size, -1, -1) #N, 1, C
        inp = torch.cat([spkr, inp], 1)
        prior_size = 0
        if prior is not None:
            prior = self.token_embedding(prior[:,:,1])
            prior = self.layer_norm(prior)
            prior_size = prior.size(1)
            inp = torch.cat([inp, prior], 1)
        phone = self.encode_phone(phone, spkr, phone_mask)
        tgt_mask = self.tgt_mask[:inp.size(1), :inp.size(1)].to(inp.device)
        inps = inp
        #Decode
        past_kvs1, past_kv_cross, past_kvs2, clusters = None, None, None, torch.empty([batch_size, 0], device=phone.device, dtype=torch.long)
        audio_alibi = self.alibi(inp)
        audio_alibi[:, 0] = 0
        audio_alibi[:, :, 0] = 0
        for i in tqdm(range(len(tgt_phonemes))):
            inps_dec = inps + phone[:,:inps.shape[1],:]
            cond, _, _, _ = self.decoder(inps_dec, memory=None, attn_bias=audio_alibi, tgt_mask=tgt_mask, past_kvs=None,
                                              memory_key_padding_mask=None)
            cond = cond[:, -1].unsqueeze(1) #N, 1, C
            logit = self.head(cond)[:, 0, :] #N, 1, n_codes
        
            #Block Start Token
            logit[:, self.hp.n_codes + 1] = -float("Inf")
            #Repetition penalty
            if self.hp.use_repetition_token and self.hp.repetition_penalty != 1.0:
                logit[:, self.hp.n_codes + 2] /= self.hp.repetition_penalty
            if self.hp.use_repetition_gating:
                logit[:, self.hp.n_codes + 2] = torch.min(torch.max(logit[:, :self.hp.n_codes]), logit[:, self.hp.n_codes + 2])
            #Top_p
            if self.hp.top_p < 1.0 and self.hp.top_p > 0.0:
                sorted_logits, sorted_idxs = torch.sort(logit, descending=True)
                cum_probs = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1)
                idx_to_remove = cum_probs > self.hp.top_p
                idx_to_remove[:, :self.hp.min_top_k] = False
                idx_to_remove = idx_to_remove.scatter(1, sorted_idxs, idx_to_remove)
                logit[idx_to_remove] = -float("Inf")
            #Sampling
            probs = torch.softmax(logit / self.hp.sampling_temperature, dim=-1)
            idx = torch.multinomial(probs, 1) #N, 1
            #If is repetition token
            if self.hp.use_repetition_token:
                if clusters.size(1) == 0: #First token, random choice
                    idx[idx==(self.hp.n_codes + 2)] = torch.randint(self.hp.n_codes, size=(1,), device=idx.device)
                else:
                    idx[idx==(self.hp.n_codes + 2)] = clusters[:, -1:, j][idx==(self.hp.n_codes + 2)]
            output = idx
            
            if torch.any(output == self.hp.n_codes):
                print("EOS")
                break

            #Update args
            tgt_mask = self.tgt_mask[:i+3+prior_size, :i+3+prior_size].to(phone.device)
            audio_alibi = self.alibi(tgt_mask)
            audio_alibi[:, :, 0] = 0

            inp = self.token_embedding(output)
            inp = self.layer_norm(inp)
            inps = torch.cat([inps, inp], 1)
            clusters = torch.cat([clusters, output], 1) #N, T

        print('clusters shape', clusters.shape, 'tgt_phonemes shape', tgt_phonemes.shape)
        clusters = torch.stack([tgt_phonemes.unsqueeze(0), clusters], 2)
        return clusters