import os

from playlist import Playlist
from abcontroller import ABController
from session_manager import SessionManager
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._playlist = Playlist(self._playlistCallback)
        self._abController = ABController(enabled=False, callback=self._abControllerCallback)
        self._sessionManager = SessionManager(self._playlist, self._abController)
        self._notifier = Notifier(self._player)

    def _playlistCallback(self, path):
        self._player.setCurrentSong(path)
        self._abController.setCurrentSong(path)

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

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

    def addSong(self, path):
        if os.path.isfile(path):
            self._sessionManager.addSong(path)

    def setSong(self, index):
        self._playlist.setCurrentSong(index)

    def nextSong(self):
        self._playlist.nextSong()

    def previousSong(self):
        self._playlist.previousSong()

    def getSongs(self):
        return self._playlist.getSongs()

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

    def loadAbLimits(self, index):
        self._abController.loadLimits(index)
    
    def setAbLimits(self, aLimit, bLimit):
        self._abController.setLimits(aLimit, bLimit)

    def getStoredAbLimits(self):
        currentSong = self._playlist.getCurrentSong()
        if currentSong is not None:
            return self._abController.getStoredLimits(currentSong)
        else:
            return list()

    def setAbLimitEnable(self, enable):
        self._abController.setEnable(enable)

    def nextStoredAbLimits(self):
        self._abController.nextStoredAbLimits()

    def previousStoredAbLimits(self):
        self._abController.previousStoredAbLimits()

    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:
            self._sessionManager.loadSession(f)

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

    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):
        previousRate = self._player.getPlaybackRate()
        self._player.setPlaybackRate(rate)
        if previousRate != rate:
            self._notifier.notify(Notifier.PLAYBACK_RATE_EVENT)

    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)