from typing import Dict
import torch
from ddsp.core import tf_float32
import tensorflow as tf
import ddsp
import numpy as np
from torch import tensor
from melody_synth.complex_torch_synth import SinSawSynth, DoubleSawSynth, TriangleSawSynth, SinTriangleSynth
from torchsynth.config import SynthConfig

if torch.cuda.is_available():
    device = "cuda"
else:
    device = "cpu"


class MelodyGenerator:
    """This is the only external interface of the melody_synth package."""

    def __init__(self,
                 sample_rate: int,
                 n_note_samples: int,
                 n_melody_samples: int):
        self.sample_rate = sample_rate
        self.n_note_samples = n_note_samples
        self.n_melody_samples = n_melody_samples
        synthconfig = SynthConfig(
            batch_size=1, reproducible=False, sample_rate=sample_rate,
            buffer_size_seconds=np.float64(n_note_samples) / np.float64(sample_rate)
        )
        self.Saw_Square_Voice = DoubleSawSynth(synthconfig)
        self.SinSawVoice = SinSawSynth(synthconfig)
        self.SinTriVoice = SinTriangleSynth(synthconfig)
        self.TriSawVoice = TriangleSawSynth(synthconfig)

    def get_melody(self, params: Dict[str, float], midi) -> [tf.Tensor]:
        """Generates a random melody audio.

        Parameters
        ----------
        params: Dict[str, float]
            Dictionary of specifications (see Readme).
        midi: List[float, float, float]
            Melody midi (see Readme).

        Returns
        -------
        onsets: List[tf.Tensor]
            Audio.
        """

        osc1_amp = np.float(params.get("osc1_amp", 0))
        osc2_amp = np.float(params.get("osc2_amp", 0))
        attack = np.float(params.get("attack", 0))
        decay = np.float(params.get("decay", 0))
        sustain = np.float(params.get("sustain", 0))
        release = np.float(params.get("release", 0))
        cutoff_freq = params.get("cutoff_freq", 4000)

        syn_parameters = {
            ("adsr", "attack"): tensor([attack]),  # [0.0, 2.0]
            ("adsr", "decay"): tensor([decay]),  # [0.0, 2.0]
            ("adsr", "sustain"): tensor([sustain]),  # [0.0, 2.0]
            ("adsr", "release"): tensor([release]),  # [0.0, 2.0]
            ("adsr", "alpha"): tensor([3]),  # [0.1, 6.0]

            # Mixer parameter
            ("mixer", "vco_1"): tensor([osc1_amp]),  # [0, 1]
            ("mixer", "vco_2"): tensor([osc2_amp]),  # [0, 1]

            # Constant parameters:
            ("vco_1", "mod_depth"): tensor([0.0]),  # [-96, 96]
            ("vco_1", "tuning"): tensor([0.0]),  # [-24.0, 24]
            ("vco_2", "mod_depth"): tensor([0.0]),  # [-96, 96]
            ("vco_2", "tuning"): tensor([0.0]),  # [-24.0, 24]
        }

        osc_types = params.get("osc_types", 0)
        if osc_types == 0:
            synth = self.SinSawVoice
            syn_parameters[("vco_2", "shape")] = tensor([1])
        elif osc_types == 1:
            synth = self.SinSawVoice
            syn_parameters[("vco_2", "shape")] = tensor([0])
        elif osc_types == 2:
            synth = self.Saw_Square_Voice
            syn_parameters[("vco_1", "shape")] = tensor([1])
            syn_parameters[("vco_2", "shape")] = tensor([0])
        elif osc_types == 3:
            synth = self.SinTriVoice
        elif osc_types == 4:
            synth = self.TriSawVoice
            syn_parameters[("vco_2", "shape")] = tensor([1])
        else:
            synth = self.TriSawVoice
            syn_parameters[("vco_2", "shape")] = tensor([0])

        track = np.zeros(self.n_melody_samples)
        for i in range(len(midi)):
            (location, pitch, duration) = midi[i]
            syn_parameters[("keyboard", "midi_f0")] = tensor([pitch])
            syn_parameters[("keyboard", "duration")] = tensor([duration])
            synth.set_parameters(syn_parameters)

            audio_out, parameters, is_train = synth()
            single_note = audio_out[0]

            single_note = np.hstack(
                [np.zeros(int(location * self.sample_rate)), single_note, np.zeros(self.n_melody_samples)])[
                          :self.n_melody_samples]
            track = track + single_note

        no_cutoff = False
        if no_cutoff:
            return track
        cutoff_freq = tf_float32(cutoff_freq)
        impulse_response = ddsp.core.sinc_impulse_response(cutoff_freq,
                                                           2048,
                                                           self.sample_rate)
        track = tf_float32(track)
        return ddsp.core.fft_convolve(track[tf.newaxis, :], impulse_response)[0, :]