import math
import os
from random import shuffle

import numpy as np
import torch.nn.functional as F

from module import commons
from module.aligner import beta_binomial_prior_distribution
from module.mel_processing import spectrogram_torch
from text import cleaned_text_to_sequence
from text.symbols import v

import torch
from glob import glob

import torchaudio
from tqdm import tqdm

import utils
import logging

from data_conf import data_root
from module.models import SynthesizerTrn

logging.getLogger("numba").setLevel(logging.WARNING)


s2_config_path = "configs/vits.json"
s2_ckpt_dir = 'logs/vits'


def get_audio(hps, filename):
    audio, sampling_rate = utils.load_wav_to_torch(filename)
    if sampling_rate != hps.sampling_rate:
        raise ValueError("{} SR doesn't match target {} SR".format(
            sampling_rate, hps.sampling_rate))
    audio_norm = audio
    audio_norm = audio_norm.unsqueeze(0)
    spec = spectrogram_torch(audio_norm, hps.filter_length,
                                hps.sampling_rate, hps.hop_length, hps.win_length,
                                center=False)
    spec = torch.squeeze(spec, 0)
    return spec, audio_norm

def process_one(file_path, hps,net_g, phoneme_data, device):

    ssl_path = file_path.replace(".wav", ".ssl.pt")
    if 'zh' not in file_path:
        return
    try:
        phoneme = phoneme_data[file_path]
        phoneme = phoneme.split(' ')
        phoneme_ids = cleaned_text_to_sequence(phoneme)
    except Exception:
        return


    
    phonemes = [0] * (len(phoneme_ids) * 3)
    phonemes[1::3] = phoneme_ids
    phoneme_ids = phonemes
        


    text = torch.LongTensor(phoneme_ids)
    spec, wav = get_audio(hps.data, file_path)

    ssl = torch.load(ssl_path).float()
    ssl = F.interpolate(ssl, size=spec.shape[-1], mode="nearest")



    beta_binomial_scaling_factor = 1.0
    # Calculate attention prior
    attn_prior = beta_binomial_prior_distribution(
        spec.shape[-1],
        text.shape[-1],
        beta_binomial_scaling_factor,
    )

    x = text.unsqueeze(0).to(device)
    ssl = ssl.to(device)
    x_lengths = torch.LongTensor([len(phoneme_ids)]).to(device)
    spec_lengths = torch.LongTensor([spec.shape[-1]]).to(device)
    attn_prior = torch.FloatTensor(attn_prior).to(device).unsqueeze(0)
    spec = spec.to(device).unsqueeze(0)
    codes = net_g.get_codes(x, x_lengths,spec, spec_lengths, ssl, attn_prior)

    code_path = file_path.replace(".wav", ".latent.pt")
    assert code_path.endswith(".latent.pt")
    # if os.path.exists(code_path):
    #     print(f"Skip {file_path}")
    #     return
    torch.save(codes, code_path)

def process_batch(filenames):
    print("Loading models ...")
    device = torch.device(f"cuda:{0}")
    print(device)
    hps = utils.get_hparams_from_file(s2_config_path)
    net_g = SynthesizerTrn(
        hps.data.filter_length // 2 + 1,
        hps.train.segment_size // hps.data.hop_length,
        n_speakers=hps.data.n_speakers,
        **hps.model).to(device)
    model_path = utils.latest_checkpoint_path(s2_ckpt_dir, "G_*.pth")
    utils.load_checkpoint(model_path, net_g,
                          None, False)
    net_g.eval()
    phoneme_path = 'dump/phoneme.npy'
    phoneme_data = np.load(phoneme_path, allow_pickle=True).item()
    print("Loaded .")
    with torch.no_grad():
        for filename in tqdm(filenames):
            process_one(filename, hps, net_g, phoneme_data, device)


if __name__ == "__main__":
    print('only chinese and skip other languages!!!!!!!!')
    print('only chinese and skip other languages!!!!!!!!')
    print('only chinese and skip other languages!!!!!!!!')
    hps = utils.get_hparams_from_file(s2_config_path)
    training_files = [line.strip() for line in open(hps.data.training_files).readlines()]
    validation_files = [line.strip() for line in open(hps.data.validation_files).readlines()]
    filenames = training_files + validation_files
    # sort
    filenames.sort()
    process_batch(filenames)