""" Tests for medleydb.mix
"""
import unittest
import os

from medleydb import multitrack
from medleydb import mix
from medleydb import AUDIO_PATH


OUTPUT_PATH = 'test_out.wav'


def clean_output():
    if os.path.exists(OUTPUT_PATH):
        os.remove(OUTPUT_PATH)


class TestMixMultitrack(unittest.TestCase):
    def setUp(self):
        self.mtrack = multitrack.MultiTrack('LizNelson_Rainfall')

    def test_defaults(self):
        clean_output()
        actual_fullpaths, actual_weights = mix.mix_multitrack(
            self.mtrack, OUTPUT_PATH
        )
        
        self.assertTrue(os.path.exists(OUTPUT_PATH))

        actual_basenames = [os.path.basename(f) for f in actual_fullpaths]
        expected_basenames = [
            'LizNelson_Rainfall_STEM_01.wav',
            'LizNelson_Rainfall_STEM_02.wav',
            'LizNelson_Rainfall_STEM_03.wav',
            'LizNelson_Rainfall_STEM_04.wav',
            'LizNelson_Rainfall_STEM_05.wav'
        ]
        expected_weights = [
            0.9138225670999782,
            0.88655832334783,
            0.7820245646673145,
            0.9709353677932278,
            0.7734022629465723
        ]
        self.assertEqual(expected_basenames, actual_basenames)
        self.assertEqual(expected_weights, actual_weights)

        clean_output()

    def test_less_stems(self):
        clean_output()
        actual_fullpaths, actual_weights = mix.mix_multitrack(
            self.mtrack, OUTPUT_PATH, stem_indices=[2, 4]
        )
        self.assertTrue(os.path.exists(OUTPUT_PATH))

        actual_basenames = [os.path.basename(f) for f in actual_fullpaths]
        expected_basenames = [
            'LizNelson_Rainfall_STEM_02.wav',
            'LizNelson_Rainfall_STEM_04.wav'
        ]
        expected_weights = [
            0.88655832334783,
            0.9709353677932278
        ]
        self.assertEqual(expected_basenames, actual_basenames)
        self.assertEqual(expected_weights, actual_weights)

        clean_output()

    def test_alt_weights(self):
        clean_output()
        actual_fullpaths, actual_weights = mix.mix_multitrack(
            self.mtrack, OUTPUT_PATH, alternate_weights={2: 2.0, 4: 0.5}
        )
        self.assertTrue(os.path.exists(OUTPUT_PATH))

        actual_basenames = [os.path.basename(f) for f in actual_fullpaths]
        expected_basenames = [
            'LizNelson_Rainfall_STEM_01.wav',
            'LizNelson_Rainfall_STEM_02.wav',
            'LizNelson_Rainfall_STEM_03.wav',
            'LizNelson_Rainfall_STEM_04.wav',
            'LizNelson_Rainfall_STEM_05.wav'
        ]
        expected_weights = [
            0.9138225670999782,
            2.0,
            0.7820245646673145,
            0.5,
            0.7734022629465723
        ]
        self.assertEqual(expected_basenames, actual_basenames)
        self.assertEqual(expected_weights, actual_weights)

        clean_output()

    def test_alt_files(self):
        clean_output()
        actual_fullpaths, actual_weights = mix.mix_multitrack(
            self.mtrack, OUTPUT_PATH,
            alternate_files={1: self.mtrack.mix_path}
        )
        self.assertTrue(os.path.exists(OUTPUT_PATH))

        actual_basenames = [os.path.basename(f) for f in actual_fullpaths]
        expected_basenames = [
            'LizNelson_Rainfall_MIX.wav',
            'LizNelson_Rainfall_STEM_02.wav',
            'LizNelson_Rainfall_STEM_03.wav',
            'LizNelson_Rainfall_STEM_04.wav',
            'LizNelson_Rainfall_STEM_05.wav'
        ]
        expected_weights = [
            0.9138225670999782,
            0.88655832334783,
            0.7820245646673145,
            0.9709353677932278,
            0.7734022629465723
        ]
        self.assertEqual(expected_basenames, actual_basenames)
        self.assertEqual(expected_weights, actual_weights)

        clean_output()


    def test_additional_files(self):
        clean_output()
        actual_fullpaths, actual_weights = mix.mix_multitrack(
            self.mtrack, OUTPUT_PATH,
            additional_files=[(self.mtrack.mix_path, 2.1)]
        )
        self.assertTrue(os.path.exists(OUTPUT_PATH))

        actual_basenames = [os.path.basename(f) for f in actual_fullpaths]
        expected_basenames = [
            'LizNelson_Rainfall_STEM_01.wav',
            'LizNelson_Rainfall_STEM_02.wav',
            'LizNelson_Rainfall_STEM_03.wav',
            'LizNelson_Rainfall_STEM_04.wav',
            'LizNelson_Rainfall_STEM_05.wav',
            'LizNelson_Rainfall_MIX.wav'
        ]
        expected_weights = [
            0.9138225670999782,
            0.88655832334783,
            0.7820245646673145,
            0.9709353677932278,
            0.7734022629465723,
            2.1
        ]
        self.assertEqual(expected_basenames, actual_basenames)
        self.assertEqual(expected_weights, actual_weights)

        clean_output()

    def test_one_stem_mix(self):
        clean_output()
        actual_fullpaths, actual_weights = mix.mix_multitrack(
            self.mtrack, OUTPUT_PATH, stem_indices=[2]
        )
        self.assertTrue(os.path.exists(OUTPUT_PATH))

        actual_basenames = [os.path.basename(f) for f in actual_fullpaths]
        expected_basenames = [
            'LizNelson_Rainfall_STEM_02.wav'
        ]
        expected_weights = [
            0.88655832334783
        ]
        self.assertEqual(expected_basenames, actual_basenames)
        self.assertEqual(expected_weights, actual_weights)

        clean_output()


class TestBuildMixArgs(unittest.TestCase):
    def setUp(self):
        self.mtrack = multitrack.MultiTrack('LizNelson_Rainfall')

    def test_defaults(self):
        actual_filepaths, actual_weights = mix._build_mix_args(
            self.mtrack, None, None, None, None
        )
        expected_filepaths = [
            os.path.join(AUDIO_PATH, 'LizNelson_Rainfall',
                         'LizNelson_Rainfall_STEMS',
                         'LizNelson_Rainfall_STEM_{}.wav'.format(i))
            for i in ['01', '02', '03', '04', '05']
        ]
        expected_weights = [
            0.9138225670999782,
            0.88655832334783,
            0.7820245646673145,
            0.9709353677932278,
            0.7734022629465723
        ]
        self.assertEqual(expected_filepaths, actual_filepaths)
        self.assertEqual(expected_weights, actual_weights)

    def test_defaults_no_mixing_coeffs(self):
        mtrack = multitrack.MultiTrack('AHa_TakeOnMe')
        for k in mtrack.stems.keys():
            mtrack.stems[k].mixing_coefficient = None
        actual_filepaths, actual_weights = mix._build_mix_args(
            mtrack, None, None, None, None
        )
        expected_filepaths = [
            os.path.join(AUDIO_PATH, 'AHa_TakeOnMe',
                         'AHa_TakeOnMe_STEMS',
                         'AHa_TakeOnMe_STEM_{}.wav'.format(i))
            for i in ['01', '02', '03', '04', '05', '06']
        ]
        expected_weights = [1, 1, 1, 1, 1, 1]
        self.assertEqual(expected_filepaths, actual_filepaths)
        self.assertEqual(expected_weights, actual_weights)


    def test_less_stems(self):
        actual_filepaths, actual_weights = mix._build_mix_args(
            self.mtrack, [2, 4], None, None, None
        )
        expected_filepaths = [
            os.path.join(AUDIO_PATH, 'LizNelson_Rainfall',
                         'LizNelson_Rainfall_STEMS',
                         'LizNelson_Rainfall_STEM_{}.wav'.format(i))
            for i in ['02', '04']
        ]
        expected_weights = [
            0.88655832334783, 0.9709353677932278
        ]
        self.assertEqual(expected_filepaths, actual_filepaths)
        self.assertEqual(expected_weights, actual_weights)

    def test_alt_weights(self):
        actual_filepaths, actual_weights = mix._build_mix_args(
            self.mtrack, None, {2: 2.0, 4: 0.5}, None, None
        )
        expected_filepaths = [
            os.path.join(AUDIO_PATH, 'LizNelson_Rainfall',
                         'LizNelson_Rainfall_STEMS',
                         'LizNelson_Rainfall_STEM_{}.wav'.format(i))
            for i in ['01', '02', '03', '04', '05']
        ]
        expected_weights = [
            0.9138225670999782,
            2.0,
            0.7820245646673145,
            0.5,
            0.7734022629465723
        ]
        self.assertEqual(expected_filepaths, actual_filepaths)
        self.assertEqual(expected_weights, actual_weights)

    def test_alt_files(self):
        actual_filepaths, actual_weights = mix._build_mix_args(
            self.mtrack, None, None, {1: self.mtrack.mix_path}, None
        )
        expected_filepaths = [
            os.path.join(
                AUDIO_PATH, 'LizNelson_Rainfall', 'LizNelson_Rainfall_MIX.wav'
            )
        ]
        expected_filepaths.extend([
            os.path.join(AUDIO_PATH, 'LizNelson_Rainfall',
                         'LizNelson_Rainfall_STEMS',
                         'LizNelson_Rainfall_STEM_{}.wav'.format(i))
            for i in ['02', '03', '04', '05']
        ])
        expected_weights = [
            0.9138225670999782,
            0.88655832334783,
            0.7820245646673145,
            0.9709353677932278,
            0.7734022629465723
        ]
        self.assertEqual(expected_filepaths, actual_filepaths)
        self.assertEqual(expected_weights, actual_weights)


    def test_additional_files(self):
        actual_filepaths, actual_weights = mix._build_mix_args(
            self.mtrack, None, None, None, [(self.mtrack.mix_path, 2.1)]
        )
        expected_filepaths = [
            os.path.join(AUDIO_PATH, 'LizNelson_Rainfall',
                         'LizNelson_Rainfall_STEMS',
                         'LizNelson_Rainfall_STEM_{}.wav'.format(i))
            for i in ['01', '02', '03', '04', '05']
        ]
        expected_filepaths.append(self.mtrack.mix_path)
        expected_weights = [
            0.9138225670999782,
            0.88655832334783,
            0.7820245646673145,
            0.9709353677932278,
            0.7734022629465723,
            2.1
        ]

        self.assertEqual(expected_filepaths, actual_filepaths)
        self.assertEqual(expected_weights, actual_weights)

    def test_one_stem_mix(self):
        actual_filepaths, actual_weights = mix._build_mix_args(
            self.mtrack, [2], None, None, None
        )
        expected_filepaths = [
            os.path.join(AUDIO_PATH, 'LizNelson_Rainfall',
                         'LizNelson_Rainfall_STEMS',
                         'LizNelson_Rainfall_STEM_{}.wav'.format(i))
            for i in ['02']
        ]
        expected_weights = [
            0.88655832334783
        ]
        self.assertEqual(expected_filepaths, actual_filepaths)
        self.assertEqual(expected_weights, actual_weights)


class TestMixMelodyStems(unittest.TestCase):
    def setUp(self):
        self.mtrack = multitrack.MultiTrack('Phoenix_ScotchMorris')

    def test_defaults(self):
        clean_output()
        actual_melody, actual_stem = mix.mix_melody_stems(
            self.mtrack, OUTPUT_PATH
        )
        expected_melody = [2, 3]
        expected_stem = [2, 3]
        self.assertEqual(expected_melody, actual_melody)
        self.assertEqual(expected_stem, actual_stem)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()

    def test_max_melody_stems1(self):
        clean_output()
        actual_melody, actual_stem = mix.mix_melody_stems(
            self.mtrack, OUTPUT_PATH, max_melody_stems=1
        )
        expected_melody = [2]
        expected_stem = [2]
        self.assertEqual(expected_melody, actual_melody)
        self.assertEqual(expected_stem, actual_stem)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()

    def test_max_melody_stems2(self):
        clean_output()
        actual_melody, actual_stem = mix.mix_melody_stems(
            self.mtrack, OUTPUT_PATH, max_melody_stems=3
        )
        expected_melody = [2, 3]
        expected_stem = [2, 3]
        self.assertEqual(expected_melody, actual_melody)
        self.assertEqual(expected_stem, actual_stem)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()

    def test_include_percussion(self):
        clean_output()
        actual_melody, actual_stem = mix.mix_melody_stems(
            self.mtrack, OUTPUT_PATH, include_percussion=True
        )
        expected_melody = [2, 3]
        expected_stem = [2, 3]
        self.assertEqual(expected_melody, actual_melody)
        self.assertEqual(expected_stem, actual_stem)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()

    def test_require_mono(self):
        clean_output()
        actual_melody, actual_stem = mix.mix_melody_stems(
            self.mtrack, OUTPUT_PATH, require_mono=True
        )
        expected_melody = [2, 3]
        expected_stem = [2, 3]
        self.assertEqual(expected_melody, actual_melody)
        self.assertEqual(expected_stem, actual_stem)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()


class TestMixMonoStems(unittest.TestCase):
    def setUp(self):
        self.mtrack = multitrack.MultiTrack('Phoenix_ScotchMorris')

    def test_defaults(self):
        clean_output()
        actual_mono, actual_stem = mix.mix_mono_stems(
            self.mtrack, OUTPUT_PATH
        )
        expected_melody = [2, 3]
        expected_stem = [2, 3]
        self.assertEqual(expected_melody, actual_mono)
        self.assertEqual(expected_stem, actual_stem)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()

    def test_include_percussion(self):
        clean_output()
        actual_mono, actual_stem = mix.mix_mono_stems(
            self.mtrack, OUTPUT_PATH, include_percussion=True
        )
        expected_melody = [2, 3]
        expected_stem = [2, 3]
        self.assertEqual(expected_melody, actual_mono)
        self.assertEqual(expected_stem, actual_stem)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()


class TestMixNoVocals(unittest.TestCase):
    def setUp(self):
        self.mtrack = multitrack.MultiTrack('LizNelson_Rainfall')

    def test_defaults(self):
        clean_output()
        actual_stem = mix.mix_no_vocals(
            self.mtrack, OUTPUT_PATH
        )
        expected_stem = [4, 5]
        self.assertEqual(expected_stem, actual_stem)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()


class TestRemixVocals(unittest.TestCase):
    def setUp(self):
        self.mtrack = multitrack.MultiTrack('LizNelson_Rainfall')

    def test_defaults(self):
        clean_output()
        alt_weights = mix.remix_vocals(
            self.mtrack, OUTPUT_PATH, 2.0
        )
        expected_weights = {
            1: 1.8276451341999564,
            2: 1.77311664669566,
            3: 1.564049129334629
        }
        self.assertEqual(expected_weights, alt_weights)
        self.assertTrue(os.path.exists(OUTPUT_PATH))
        clean_output()