from solo_tool import SoloTool
import pathlib
import shutil

class MockPlayer():
    STOPPED = 0
    PLAYING = 1
    PAUSED = 2

    def __init__(self):
        self.state = MockPlayer.STOPPED
        self.rate = 1.0
        self.position = 0.0
        self.volume = 1.0
        self.currentSong = None

    def play(self):
        self.state = MockPlayer.PLAYING

    def stop(self):
        self.state = MockPlayer.STOPPED

    def pause(self):
        self.state = MockPlayer.PAUSED

    def setPlaybackRate(self, rate):
        self.rate = rate

    def getPlaybackRate(self):
        return self.rate

    def setPlaybackPosition(self, position):
        self.position = position

    def getPlaybackPosition(self):
        return self.position

    def setPlaybackVolume(self, volume):
        self.volume = volume

    def getPlaybackVolume(self):
        return self.volume

    def setCurrentSong(self, path):
        self.currentSong = path

def test_playerControls():
    mockPlayer = MockPlayer()
    uut = SoloTool(mockPlayer)
    
    assert mockPlayer.state == MockPlayer.STOPPED
    uut.play()
    assert mockPlayer.state == MockPlayer.PLAYING
    uut.pause()
    assert mockPlayer.state == MockPlayer.PAUSED
    uut.stop()
    assert mockPlayer.state == MockPlayer.STOPPED

    assert mockPlayer.rate == 1.0
    uut.setPlaybackRate(0.5)
    assert mockPlayer.rate == 0.5

    assert mockPlayer.position == 0.0
    uut.setPlaybackPosition(0.5)
    assert mockPlayer.position == 0.5

    assert mockPlayer.volume == 1.0
    uut.setPlaybackVolume(0.5)
    assert mockPlayer.volume == 0.5

def test_addAndSetSongs():
    songs = [
        "test.flac",
        "test.mp3"
    ]
    mockPlayer = MockPlayer()
    uut = SoloTool(mockPlayer)
    
    for s in songs:
        uut.addSong(s)
    assert mockPlayer.currentSong == None
    
    for i, s in enumerate(songs):
        uut.setSong(i)
        assert mockPlayer.currentSong == songs[i]

def test_addAndSetAbLimits():
    song = "test.flac"
    abLimits = [
        [0.2, 0.4],
        [0.1, 0.3]
    ]
    mockPlayer = MockPlayer()
    uut = SoloTool(mockPlayer)

    uut.addSong(song)
    uut.setSong(0)

    uut.storeAbLimits(abLimits[0][0], abLimits[0][1])
    uut.storeAbLimits(abLimits[1][0], abLimits[1][1])

    mockPlayer.position = 0.0
    uut.tick()
    assert mockPlayer.position == 0.0

    mockPlayer.position = 0.5
    uut.tick()
    assert mockPlayer.position == 0.5

    uut.setAbLimit(0)

    uut.tick()
    assert mockPlayer.position == 0.5

    uut.setAbLimitEnable(True)

    uut.tick()
    assert mockPlayer.position == 0.2

    uut.tick()
    assert mockPlayer.position == 0.2

    uut.setAbLimit(1)
    uut.tick()
    assert mockPlayer.position == 0.2

    mockPlayer.position = 0.8
    uut.tick()
    assert mockPlayer.position == 0.1

def test_multipleSongsAndAbLimits():
    songs = [
        "test.flac",
        "test.mp3"
    ]
    abLimits = [
        [0.2, 0.4],
        [0.5, 0.7]
    ]
    mockPlayer = MockPlayer()
    uut = SoloTool(mockPlayer)
    
    for s in songs:
        uut.addSong(s)

    for i, l in enumerate(abLimits):
        uut.setSong(i)
        uut.storeAbLimits(l[0], l[1])

    uut.setAbLimitEnable(True)
   
    for i, l in enumerate(abLimits):
        uut.setSong(i)
        uut.setAbLimit(0)

        mockPlayer.position = l[0]
        uut.tick()
        assert mockPlayer.position == l[0]

        mockPlayer.position = l[1] + 0.1
        uut.tick()
        assert mockPlayer.position == l[0]

def test_storeAbLimitsWithoutSong():
    song = "test.flac"
    abLimit = [0.2, 0.4]
    overflow = abLimit[1] + 0.1
    mockPlayer = MockPlayer()
    uut = SoloTool(mockPlayer)
    mockPlayer.position = overflow
    uut.setAbLimitEnable(True)

    uut.storeAbLimits(abLimit[0], abLimit[1])
    uut.tick()
    assert mockPlayer.position == overflow
    
    uut.setAbLimit(0)
    uut.tick()
    assert mockPlayer.position == overflow

    uut.addSong(song)
    uut.tick()
    assert mockPlayer.position == overflow

    uut.setAbLimit(0)
    uut.tick()
    assert mockPlayer.position == overflow

    uut.setSong(0)
    uut.tick()
    assert mockPlayer.position == overflow

    uut.setAbLimit(0)
    uut.tick()
    assert mockPlayer.position == overflow

    uut.storeAbLimits(abLimit[0], abLimit[1])
    uut.tick()
    assert mockPlayer.position == overflow

    uut.setAbLimit(0)
    uut.tick()
    assert mockPlayer.position == abLimit[0]

def copyTestFiles(tmp_path):
    testFiles = [
        "test.flac",
        "test.mp3",
        "test_session.json"
    ]
    for f in testFiles:
        shutil.copy(pathlib.Path(f), tmp_path)

def test_loadAndSaveSession(tmp_path):
    copyTestFiles(tmp_path)
    mockPlayer = MockPlayer()
    uut = SoloTool(mockPlayer)

    loadedSessionFile = tmp_path / "test_session.json"
    savedSessionFile = tmp_path / "test_session_save.json"

    uut.loadSession(loadedSessionFile)
    uut.saveSession(savedSessionFile)

    import json
    with open(loadedSessionFile, "r") as f:
        loadedSession = json.loads(f.read())
        
    with open(savedSessionFile, "r") as f:
        savedSession = json.loads(f.read())

    assert loadedSession == savedSession

def test_addInexistentFile():
    song = "not/a/real/file"

    mockPlayer = MockPlayer()
    uut = SoloTool(mockPlayer)

    uut.addSong(song)
    uut.setSong(0)

    assert mockPlayer.currentSong == None

def test_getters():
    song = "test.flac"
    abLimit = [0.2, 0.4]
    mockPlayer = MockPlayer()
    uut = SoloTool(mockPlayer)

    uut.addSong(song)
    uut.setSong(0)
    uut.storeAbLimits(abLimit[0], abLimit[1])

    assert uut.getSongs() == [song]

    limits = uut.getAbLimits()
    assert len(limits) == 1
    assert limits[0][0] == abLimit[0]
    assert limits[0][1] == abLimit[1]

    mockPlayer.position = 0.8
    assert uut.getPlaybackPosition() == 0.8