from module import commons
import torch
import torch.nn as nn
import torch.optim as optim
from .maskgit import NARPredictor
import pytorch_lightning.core.module as pl
import matplotlib.pyplot as plt


plt.switch_backend('agg')

class Wav2TTS(pl.LightningModule):
    def __init__(self, hp):
        super().__init__()
        self.model = NARPredictor(codebook_size=hp.vocab_size)
        self.lr = hp.lr

    def configure_optimizers(self):
        print('train with lr ', self.lr)
        optimizer = optim.AdamW([*self.parameters()], lr=self.lr, betas=(0.9, 0.95), weight_decay=0.1)
        return optimizer

    def training_step(self, batch, batch_idx):
        acc, loss = self.step(batch)
        self.log("train/loss", loss, on_step=True, prog_bar=True)
        # self.log("train/quantize_loss", quantize_loss, on_step=True, prog_bar=True)
        self.log("train/acc", acc, on_step=True, prog_bar=True)
        return loss

    def validation_step(self, batch, batch_idx):
        acc, loss = self.step(batch)
        self.log("val/loss", loss, on_step=False, prog_bar=False)
        self.log("val/acc", acc, on_step=False, prog_bar=False)

    def step(self, batch):
        # speaker_embedding = self.spk_proj(batch['spk_emb'])
        # speaker_embedding, commitment_loss, codebook_loss, indices, z_e = self.spk_vq(speaker_embedding.unsqueeze(-1))
        # quantize_loss = codebook_loss + 0.25*commitment_loss
        # speaker_embedding = speaker_embedding.squeeze(-1)
        # speaker_embedding = self.spk_emb(batch['spk_emb'])
        # Deal with phone segments
        phone_features = batch['phone']
        lengths = batch['length']
        bert_feature = batch['bert_feature']
        speaker_embedding = batch['spk_emb']
        target = batch['quantization']
        mask = torch.unsqueeze(commons.sequence_mask(lengths, target.size(-1)), 1).to(speaker_embedding.dtype)

        output = self.model(phone_features,mask, bert_feature, speaker_embedding, target )
        loss = output['loss']
        acc = output['acc']
        return acc, loss

    @torch.inference_mode()
    @torch.no_grad()
    def inference(self, phonemes,  bert_feature, spk_emb, prompt=None):
        output = self.model.inference(phonemes, bert_feature, spk_emb)
        return output