import os

from .abcontroller import ABController
from .session_manager import loadSession, saveSession
from .notifier import Notifier
from .player_vlc import Player

class SoloTool:
    def __init__(self, playerOverride=None):
        self._player = Player() if playerOverride is None else playerOverride
        self._abController = ABController(enabled=False, callback=self._abControllerCallback)
        self._notifier = Notifier(self._player)
        self._songList = []
        self._song = None

    def _updateSong(self, index):
        self._song = index
        path = self._songList[index]
        self._player.setCurrentSong(path)
        self._abController.setCurrentSong(path)
        self._notifier.notify(Notifier.CURRENT_SONG_EVENT, index)

    def _abControllerCallback(self, position):
        self._player.setPlaybackPosition(position)

    def tick(self):
        position = self._player.getPlaybackPosition()
        self._abController.positionChanged(position)

    @property
    def songList(self) -> list[str]:
        return self._songList

    def addSong(self, path: str) -> None:
        if os.path.isfile(path):
            self._songList.append(path)

    @property
    def song(self) -> int:
        return self._song

    @song.setter
    def song(self, new: int) -> None:
        if new >= 0 and new < len(self._songList) and new != self._song:
            self._updateSong(new)

    def storeAbLimits(self, aLimit, bLimit):
        self._abController.storeLimits(aLimit, bLimit)

    def loadAbLimits(self, index):
        previous = self._abController.getLoadedIndex()
        self._abController.loadLimits(index)
        new = self._abController.getLoadedIndex()
        if previous != new:
            self._notifier.notify(Notifier.CURRENT_AB_EVENT, new)
    
    def setAbLimits(self, aLimit, bLimit):
        self._abController.setLimits(aLimit, bLimit)

    def getStoredAbLimits(self):
        if self._song is not None:
            return self._abController.getStoredLimits(self.songList[self._song])
        else:
            return list()

    def setAbLimitEnable(self, enable):
        previous = self._abController.isEnabled()
        self._abController.setEnable(enable)
        new = self._abController.isEnabled()
        if previous != new:
            self._notifier.notify(Notifier.AB_LIMIT_ENABLED_EVENT, new)

    def isAbLimitEnabled(self):
        return self._abController.isEnabled()

    def nextStoredAbLimits(self):
        previous = self._abController.getLoadedIndex()
        self._abController.nextStoredAbLimits()
        new = self._abController.getLoadedIndex()
        if previous != new:
            self._notifier.notify(Notifier.CURRENT_AB_EVENT, new)

    def previousStoredAbLimits(self):
        previous = self._abController.getLoadedIndex()
        self._abController.previousStoredAbLimits()
        new = self._abController.getLoadedIndex()
        if previous != new:
            self._notifier.notify(Notifier.CURRENT_AB_EVENT, new)

    def jumpToA(self):
        a = self._abController.getCurrentLimits()[0]
        # XXX assumes that player.setPlaybackPosition is thread-safe!
        self._player.setPlaybackPosition(a)

    def loadSession(self, path):
        with open(path, "r") as f:
            loadSession(f, self._songList, self._abController)

    def saveSession(self, path):
        with open(path, "w") as f:
            saveSession(f, self._songList, self._abController)

    def play(self):
        self._player.play()

    def pause(self):
        self._player.pause()

    def stop(self):
        self._player.stop()

    def isPlaying(self):
        return self._player.isPlaying()

    def setPlaybackRate(self, rate):
        previous = self._player.getPlaybackRate()
        self._player.setPlaybackRate(rate)
        new = self._player.getPlaybackRate()
        if previous != new:
            self._notifier.notify(Notifier.PLAYBACK_RATE_EVENT, new)

    def getPlaybackRate(self):
        return self._player.getPlaybackRate()

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

    def getPlaybackPosition(self):
        return self._player.getPlaybackPosition()

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

    def getPlaybackVolume(self):
        return self._player.getPlaybackVolume()

    def registerPlayingStateCallback(self, callback):
        self._notifier.registerCallback(Notifier.PLAYING_STATE_EVENT, callback)

    def registerPlaybackVolumeCallback(self, callback):
        self._notifier.registerCallback(Notifier.PLAYBACK_VOLUME_EVENT, callback)

    def registerPlaybackRateCallback(self, callback):
        self._notifier.registerCallback(Notifier.PLAYBACK_RATE_EVENT, callback)

    def registerCurrentSongCallback(self, callback):
        self._notifier.registerCallback(Notifier.CURRENT_SONG_EVENT, callback)

    def registerCurrentAbLimitsCallback(self, callback):
        self._notifier.registerCallback(Notifier.CURRENT_AB_EVENT, callback)

    def registerAbLimitEnabledCallback(self, callback):
        self._notifier.registerCallback(Notifier.AB_LIMIT_ENABLED_EVENT, callback)