import unittest
import os
import yaml
from medleydb import multitrack
from medleydb import AUDIO_PATH
from medleydb import MIXING_COEFFICIENTS


class TestMultitrack(unittest.TestCase):
    def setUp(self):
        self.mtrack = multitrack.MultiTrack("NightPanther_Fire")
        self.mtrack2 = multitrack.MultiTrack("Phoenix_ScotchMorris")
        self.stem = self.mtrack.stems[8]
        self.raw = self.mtrack.raw_audio[8][1]

    def test_dataset_version_v1(self):
        actual = self.mtrack.dataset_version
        expected = 'V1'
        self.assertEqual(expected, actual)

    def test_dataset_version_v2(self):
        mtrack = multitrack.MultiTrack("FennelCartwright_DearTessie")
        actual = mtrack.dataset_version
        expected = 'V2'
        self.assertEqual(expected, actual)

    def test_dataset_version_extra(self):
        mtrack = multitrack.MultiTrack("AHa_TakeOnMe")
        actual = mtrack.dataset_version
        expected = 'EXTRA'
        self.assertEqual(expected, actual)

    def test_invalid_trackid(self):
        with self.assertRaises(IOError):
            multitrack.MultiTrack("RickAstley_NeverGonnaGiveYouUp")

    def test_audio_path(self):
        actual = self.mtrack.audio_path
        expected = os.path.join(AUDIO_PATH, "NightPanther_Fire")
        self.assertEqual(actual, expected)

    def test_artist(self):
        actual = self.mtrack.artist
        expected = "NightPanther"
        self.assertEqual(actual, expected)

    def test_title(self):
        actual = self.mtrack.title
        expected = "Fire"
        self.assertEqual(actual, expected)

    def test_trackid(self):
        actual = self.mtrack.track_id
        expected = "NightPanther_Fire"
        self.assertEqual(actual, expected)

    def test_stem_length(self):
        actual = len(self.mtrack.stems)
        expected = 12
        self.assertEqual(actual, expected)

    def test_stem_type(self):
        actual = type(self.stem)
        expected = multitrack.Track
        self.assertEqual(actual, expected)

    def test_stem_component(self):
        actual = self.stem.component
        expected = ''
        self.assertEqual(actual, expected)

    def test_stem_duration(self):
        actual = self.stem.duration
        expected = None
        self.assertEqual(actual, expected)

    def test_stem_fname(self):
        actual = os.path.basename(self.stem.audio_path)
        expected = "NightPanther_Fire_STEM_08.wav"
        self.assertEqual(actual, expected)

    def test_stem_instrument(self):
        actual = self.stem.instrument
        expected = ["auxiliary percussion"]
        self.assertEqual(actual, expected)

    def test_stem_f0_type(self):
        actual = self.stem.f0_type
        expected = ["u"]
        self.assertEqual(actual, expected)

    def test_stem_mixpath(self):
        actual = os.path.basename(self.stem.mix_path)
        expected = "NightPanther_Fire_MIX.wav"
        self.assertEqual(actual, expected)

    def test_stem_pitch_annot_none(self):
        actual = self.stem.pitch_annotation
        expected = None
        self.assertEqual(actual, expected)

    def test_stem_pitch_pyin_none(self):
        actual = self.stem.pitch_estimate_pyin
        expected = None
        self.assertEqual(actual, expected)

    def test_stem_pitch_annot_exists(self):
        actual = self.mtrack.stems[7].pitch_annotation
        expected_len = 18268
        self.assertEqual(len(actual), expected_len)

    def test_stem_pitch_pyin_exists(self):
        actual = self.mtrack.stems[7].pitch_estimate_pyin
        expected_len = 25175
        self.assertEqual(len(actual), expected_len)

    def test_stem_raw_idx(self):
        actual = self.stem.raw_idx
        expected = None
        self.assertEqual(actual, expected)

    def test_stem_stem_idx(self):
        actual = self.stem.stem_idx
        expected = 8
        self.assertEqual(actual, expected)

    def test_raw_length1(self):
        actual = len(self.mtrack.raw_audio)
        expected = 12
        self.assertEqual(actual, expected)

    def test_raw_length2(self):
        actual = len(multitrack.get_dict_leaves(self.mtrack.raw_audio))
        expected = 55
        self.assertEqual(actual, expected)

    def test_raw_type(self):
        actual = type(self.raw)
        expected = multitrack.Track
        self.assertEqual(actual, expected)

    def test_raw_component(self):
        actual = self.raw.component
        expected = ''
        self.assertEqual(actual, expected)

    def test_raw_duration(self):
        actual = self.raw.duration
        expected = None
        self.assertEqual(actual, expected)

    def test_raw_fname(self):
        actual = os.path.basename(self.raw.audio_path)
        expected = "NightPanther_Fire_RAW_08_01.wav"
        self.assertEqual(actual, expected)

    def test_raw_instrument(self):
        actual = self.raw.instrument
        expected = ["cymbal"]
        self.assertEqual(actual, expected)

    def test_raw_f0type(self):
        actual = self.raw.f0_type
        expected = ["u"]
        self.assertEqual(actual, expected)

    def test_raw_mixpath(self):
        actual = os.path.basename(self.raw.mix_path)
        expected = "NightPanther_Fire_MIX.wav"
        self.assertEqual(actual, expected)

    def test_raw_pitch_annotation(self):
        actual = self.raw.pitch_annotation
        expected = None
        self.assertEqual(actual, expected)

    def test_raw_raw_idx(self):
        actual = self.raw.raw_idx
        expected = 1
        self.assertEqual(actual, expected)

    def test_raw_stem_idx(self):
        actual = self.raw.stem_idx
        expected = 8
        self.assertEqual(actual, expected)

    def test_stem_instruments(self):
        actual = self.mtrack.stem_instruments
        expected = [
            'auxiliary percussion',
            'brass section',
            'drum machine',
            'drum set',
            'electric bass',
            'male singer',
            'string section',
            'synthesizer',
            'synthesizer',
            'synthesizer',
            'vocalists',
            'vocalists',
        ]
        print(actual)
        self.assertEqual(actual, expected)

    def test_raw_instruments_length(self):
        actual = len(self.mtrack.raw_instruments)
        expected = 55
        self.assertEqual(actual, expected)

    def test_raw_instruments(self):
        actual = self.mtrack.raw_instruments[0:5]
        expected = [
            'brass section',
            'brass section',
            'brass section',
            'brass section',
            'cello'
        ]
        self.assertEqual(actual, expected)

    def test_has_melody(self):
        actual = self.mtrack.has_melody
        expected = True
        self.assertEqual(actual, expected)

    def test_predominant_stem_type(self):
        actual = type(self.mtrack.predominant_stem)
        expected = multitrack.Track
        self.assertEqual(actual, expected)

    def test_predominant_stem_component(self):
        actual = self.mtrack.predominant_stem.component
        expected = 'melody'
        self.assertEqual(actual, expected)

    def test_predominant_stem_stem_idx(self):
        actual = self.mtrack.predominant_stem.stem_idx
        expected = 7
        self.assertEqual(actual, expected)

    def test_melody_annotations(self):
        actual_mel1 = self.mtrack.melody1_annotation
        actual_mel2 = self.mtrack.melody2_annotation
        actual_mel3 = self.mtrack.melody3_annotation

        self.assertEqual(len(actual_mel1), 36692)
        self.assertEqual(len(actual_mel2), 36692)
        self.assertEqual(len(actual_mel3), 36692)

        self.assertEqual(len(actual_mel1[0]), 2)
        self.assertEqual(len(actual_mel2[0]), 2)
        self.assertEqual(len(actual_mel3[0]), 3)

    def test_melody_tracks(self):
        mel_tracks = self.mtrack.melody_stems()
        self.assertEqual(len(mel_tracks), 2)
        self.assertEqual(mel_tracks[0].component, 'melody')
        self.assertEqual(mel_tracks[0].stem_idx, 6)
        self.assertEqual(len(mel_tracks[0].pitch_annotation), 6591)

    def test_bass_tracks(self):
        bass_tracks = self.mtrack.bass_stems()
        self.assertEqual(len(bass_tracks), 1)
        self.assertEqual(bass_tracks[0].component, 'bass')
        self.assertEqual(bass_tracks[0].stem_idx, 1)

    def test_num_stems(self):
        actual = self.mtrack.num_stems()
        expected = 12
        self.assertEqual(actual, expected)

    def test_num_raw(self):
        actual = self.mtrack.num_raw()
        expected = 55
        self.assertEqual(actual, expected)

    def test_stem_filepaths(self):
        actual = len(self.mtrack.stem_filepaths())
        expected = 12
        self.assertEqual(actual, expected)

    def test_raw_filepaths(self):
        actual = len(self.mtrack.raw_filepaths())
        expected = 55
        self.assertEqual(actual, expected)

    def test_stem_activations(self):
        actual = self.mtrack.stem_activations
        self.assertEqual(type(actual), list)

    def test_stem_activations_v2(self):
        actual = self.mtrack.stem_activations_v2
        self.assertEqual(type(actual), list)

    def test_activation_conf_from_stem1(self):
        actual = self.mtrack.activation_conf_from_stem(3)[0]
        expected = [0.0, 0.0474]
        self.assertEqual(actual, expected)

    def test_activation_conf_from_stem_v2(self):
        actual = self.mtrack.activation_conf_from_stem(3, version='v2')[0]
        expected = [0.0, 0.0474]
        self.assertEqual(actual, expected)

    def test_activation_conf_from_stem2(self):
        actual = self.mtrack.activation_conf_from_stem(50)
        expected = None
        self.assertEqual(actual, expected)

    def test_get_mixing_coefficient(self):
        mtrack = multitrack.MultiTrack('AClassicEducation_NightOwl')
        actual = mtrack._get_mixing_coefficient(3)
        expected = 0.2
        self.assertEqual(actual, expected)

    def test_get_mixing_coefficient2(self):
        actual = self.mtrack2._get_mixing_coefficient(3)
        expected = 0.585016969071061
        self.assertAlmostEqual(actual, expected)


class TestTrack(unittest.TestCase):
    def test_track(self):
        track = multitrack.Track(
            'blurbophone', 'fake/path1', 'S12', 'fake/path2',
            component='melody'
        )
        self.assertEqual(track.instrument, ['blurbophone'])
        self.assertEqual(track.audio_path, 'fake/path1')
        self.assertEqual(track.component, 'melody')
        self.assertEqual(track.stem_idx, 12)
        self.assertEqual(track.raw_idx, None)
        self.assertEqual(track.mix_path, 'fake/path2')
        self.assertEqual(track.pitch_path, None)

    def test_track2(self):
        track = multitrack.Track(
            'kazoo', 'fake/path1', 50, 'fake/path2',
            raw_idx='R07'
        )
        self.assertEqual(track.instrument, ['kazoo'])
        self.assertEqual(track.audio_path, 'fake/path1')
        self.assertEqual(track.component, '')
        self.assertEqual(track.stem_idx, 50)
        self.assertEqual(track.raw_idx, 7)
        self.assertEqual(track.mix_path, 'fake/path2')

    def test_track_equality(self):
        track1 = multitrack.Track(
            'blurbophone', 'fake/path1', 'S12', 'fake/path2',
            component='melody'
        )
        track2 = multitrack.Track(
            'blurbophone', 'fake/path1', 'S12', 'fake/path2',
            component='melody'
        )
        actual = track1 == track2
        expected = True
        self.assertEqual(expected, actual)

    def test_track_inequality(self):
        track1 = multitrack.Track(
            'blurbophone', 'fake/path1', 'S12', 'fake/path2',
            component='melody'
        )
        track2 = multitrack.Track(
            'kazoo', 'fake/path1', 50, 'fake/path2',
            raw_idx='R07'
        )
        actual = track1 != track2
        expected = True
        self.assertEqual(expected, actual)


class TestPathBasedir(unittest.TestCase):
    def test_basedir(self):
        path = 'this/is/a/path'
        actual = multitrack._path_basedir(path)
        expected = 'path'
        self.assertEqual(actual, expected)

    def test_basedir2(self):
        path = 'this/is/a/second/path/'
        actual = multitrack._path_basedir(path)
        expected = 'path'
        self.assertEqual(actual, expected)

    def test_basedir3(self):
        path = 'this/is/a/path/with/an/ending/file.txt'
        actual = multitrack._path_basedir(path)
        expected = 'file.txt'
        self.assertEqual(actual, expected)


class TestGetDictLeaves(unittest.TestCase):
    def test_get_leaves(self):
        test_dict = {
            'a': ['z', 'y', 'x'],
            'b': ['w', 't'],
            'c': ['elephant'],
            'd': {'asdf': ['z']},
            'e': {'borg': ['foo']}
        }
        actual = multitrack.get_dict_leaves(test_dict)
        expected = set(['z', 'y', 'x', 'w', 't', 'elephant', 'foo'])
        self.assertEqual(actual, expected)

    def test_get_leaves2(self):
        mtrack = multitrack.MultiTrack('NightPanther_Fire')
        test_dict = {
            'a': mtrack,
            'b': {1: mtrack, 2: mtrack},
            'c': [mtrack],
            'd': {'asdf': mtrack},
            'e': {'borg': [mtrack]}
        }
        actual = multitrack.get_dict_leaves(test_dict)
        expected = set([mtrack, mtrack, mtrack, mtrack, mtrack])
        self.assertEqual(actual, expected)


class TestGetDuration(unittest.TestCase):
    def test_get_duration(self):
        actual = multitrack.get_duration(os.path.join(
            os.path.dirname(__file__), 'data/short_audio.wav'))
        expected = 4.0
        self.assertEqual(actual, expected)


class TestReadAnnotationFile(unittest.TestCase):
    def test_readpitch(self):
        actual, header = multitrack.read_annotation_file(
            os.path.join(os.path.dirname(__file__), 'data/pitch.csv')
        )
        expected = [
            [0.023219954, 189.187],
            [0.029024943, 191.782],
            [0.034829931, 200.344]
        ]
        self.assertEqual(actual, expected)
        self.assertEqual(header, [])

    def test_readmelody(self):
        actual, header = multitrack.read_annotation_file(
            os.path.join(os.path.dirname(__file__), 'data/melody.csv')
        )
        expected = [
            [0.0, 0.0],
            [0.0058049886621315194, 0.0],
            [0.011609977324263039, 0.0],
            [0.017414965986394557, 0.0],
            [0.023219954648526078, 189.18700000000001]
        ]
        self.assertEqual(actual, expected)
        self.assertEqual(header, [])

    def test_invalidpath(self):
        actual, header = multitrack.read_annotation_file('blurb/blork/barg')
        expected = None
        self.assertEqual(actual, expected)
        self.assertEqual(header, expected)


class TestGetValidInstrumentLabels(unittest.TestCase):
    def setUp(self):
        self.labels = multitrack.get_valid_instrument_labels()
        test_taxonomy_fpath = os.path.join(
            os.path.dirname(__file__), 'data/test_taxonomy.yaml')
        with open(test_taxonomy_fpath, 'r') as fhandle:
            self.test_taxonomy = yaml.load(fhandle)

    def test_inclusion(self):
        self.assertTrue('female singer' in self.labels)

    def test_inclusion2(self):
        self.assertTrue('erhu' in self.labels)

    def test_exclusion(self):
        self.assertFalse('squidward' in self.labels)

    def test_alternate_taxonomy(self):
        actual = multitrack.get_valid_instrument_labels(
            taxonomy=self.test_taxonomy
        )
        expected = set([
            'rick',
            'morty',
            'beth',
            'summer',
            'jerry',
            'mrs pancakes',
            'tiny rick',
            'squanchy',
            'traflorkians',
            'unity'
        ])
        self.assertEqual(actual, expected)


class TestIsValidInstrument(unittest.TestCase):
    def test_valid_instrument(self):
        actual = multitrack.is_valid_instrument('clarinet')
        expected = True
        self.assertEqual(actual, expected)

    def test_invalid_instrument(self):
        actual = multitrack.is_valid_instrument('Clarinet')
        expected = False
        self.assertEqual(actual, expected)

    def test_invalid_instrument2(self):
        actual = multitrack.is_valid_instrument('mayonnaise')
        expected = False
        self.assertEqual(actual, expected)


class TestGetDatasetVersion(unittest.TestCase):
    def test_version_1(self):
        actual = multitrack.get_dataset_version('MusicDelta_Beethoven')
        expected = 'V1'
        self.assertEqual(expected, actual)

    def test_version_v2(self):
        actual = multitrack.get_dataset_version("FennelCartwright_DearTessie")
        expected = 'V2'
        self.assertEqual(expected, actual)

    def test_version_extra(self):
        actual = multitrack.get_dataset_version("AHa_TakeOnMe")
        expected = 'EXTRA'
        self.assertEqual(expected, actual)

    def test_version_bach10(self):
        actual = multitrack.get_dataset_version("Bach10_05DieNacht")
        expected = 'BACH10'
        self.assertEqual(expected, actual)

    def test_version_none(self):
        actual = multitrack.get_dataset_version("ManateeCommune_Blueberry")
        expected = ''
        self.assertEqual(expected, actual)