from session_manager import SessionManager
from json import loads, dumps

testSession = [
    {
        "path" : "/path/to/another/song",
        "ab_limits" : None
    },
    {
        "path" : "/path/to/song",
        "ab_limits" : [
            [0.1, 0.2],
            [0.3, 0.4]
        ]
    },
    {
        "path" : "/path/to/something",
        "ab_limits" : [
            [0.1, 0.2]
        ]
    }
]

class PlaylistMock:
    def __init__(self):
        self.lastAddedSong = None
        self.songs = list()

    def addSong(self, s):
        self.songs.append(s)
        self.lastAddedSong = s

    def getSongs(self):
        return self.songs

class ABControllerMock:
    def __init__(self):
        self.limits = dict()

    def addLimits(self, aLimit, bLimit, song="current"):
        if song not in self.limits: 
            self.limits[song] = list()
        self.limits[song].append([aLimit, bLimit])
    
    def getLimits(self):
        return self.limits

class MockFile:
    def __init__(self, init=""):
        self.contents = init

    def open(self, *args):
        pass

    def write(self, s):
        self.contents += s

    def read(self):
        return self.contents


def test_addSongs():
    songs = [
        "/path/to/song",
        "/path/to/another/song"
    ]

    playlistMock = PlaylistMock()
    uut = SessionManager(playlistMock, None)

    for s in songs:
        uut.addSong(s)
        assert playlistMock.lastAddedSong == s

def test_addAbLimits():
    abLimits = [
        [0.1, 0.2],
        [0.3, 0.4]
    ]

    abControllerMock = ABControllerMock()
    uut = SessionManager(None, abControllerMock)

    for i, ab in enumerate(abLimits):
        uut.addLimits(ab[0], ab[1])
        assert abControllerMock.limits["current"][i] == ab
 
def test_loadSession():
    playlistMock = PlaylistMock()
    abControllerMock = ABControllerMock()
    uut = SessionManager(playlistMock, abControllerMock)

    sessionFile = MockFile(dumps(testSession))
    uut.loadSession(sessionFile)

    for i, entry in enumerate(testSession):
        expectedSong = entry["path"]
        expectedLimits = entry["ab_limits"]
        loadedSong = playlistMock.songs[i]
        loadedLimits = abControllerMock.limits.get(expectedSong)

        assert loadedSong == expectedSong
        assert loadedLimits == expectedLimits

def test_saveSession():
    playlistMock = PlaylistMock()
    abControllerMock = ABControllerMock()
    uut = SessionManager(playlistMock, abControllerMock)

    for i, entry in enumerate(testSession):
        song = entry["path"]
        playlistMock.addSong(song)

        abLimits = entry["ab_limits"]
        if abLimits is not None:
            for l in abLimits:
                abControllerMock.addLimits(l[0], l[1], song)

    sessionFile = MockFile()
    uut.saveSession(sessionFile)

    savedSession = loads(sessionFile.read())
    assert savedSession == testSession

def test_loadAndSaveEmptySession():
    playlistMock = PlaylistMock()
    abControllerMock = ABControllerMock()
    uut = SessionManager(playlistMock, abControllerMock)

    sessionFile = MockFile()

    uut.saveSession(sessionFile)
    assert loads(sessionFile.read()) == list()

    uut.loadSession(sessionFile)
    assert playlistMock.getSongs() == list()
    assert abControllerMock.getLimits() == dict()