from Universal import ioservice

class TMDBService:
    def __init__(self, loggingservice):
        self.logger = loggingservice
        self.report(2, "Initializing")
        try:
            import tmdbsimple
            self.tmdb = tmdbsimple
            self.report(2, "API Found")
            self.enabled = True
            self.tmdb_key = None
            self.addDefaultConfiguration()
        except ImportError:
            self.report(3, "Module 'tmdbsimple' was not found")
            self.report(3, "Disabling TMDB API")
            self.enabled = False
        self.connected = False

    def addDefaultConfiguration(self):
        ioservice.addConfiguration("TMDB Service", "TMDB API Key", "NONE")

    def updateConfiguration(self):
        if self.tmdb_key == None:
            self.tmdb_key = ioservice.getConfigurationStr("TMDB Service", "TMDB API Key")

    def report(self, level, message):
        match level:
            case 0:
                self.logger.infoReport("[TMDB] " + message)
            case 1:
                self.logger.warningReport("[TMDB] " + message)
            case 2:
                self.logger.debugReport("[TMDB] " + message)
            case 3:
                self.logger.errorReport("[TMDB] " + message)

    def isEnabled(self):
        return self.enabled

    def isConnected(self):
        self.report(2, "isConnected")
        return self.connected

    def connectToService(self):
        self.report(2, "connectToService")
        if not self.connected:
            try:
                self.report(2, "Attempting to Login")
                self.updateConfiguration()
                self.tmdb.API_KEY = self.tmdb_key
                self.connected = True
                self.report(2, "Connected")
            except self.tmdb.APIKeyError:
                self.report(3, "API Key is incorrect")
                self.report(3, "Disabling TMDB API")
                self.enabled = False
        else:
            self.report(2, "Already connected")

    def searchMovie(self, name):
        self.report(2, "searchMovie")
        tmp_search = self.tmdb.Search()
        tmp_response = tmp_search.movie(query=name)
        tmp_list = []
        for movie in tmp_search.results:
            tmp_runtime = self.tmdb.Movies(movie['id']).info()['runtime']
            try:
                tmp_releasedate = movie['release_date']
            except:
                tmp_releasedate = 9999
            if not tmp_runtime or tmp_runtime is None:
                tmp_runtime = 0
            if not tmp_releasedate or tmp_releasedate is None:
                tmp_releasedate = 9999
            tmp_list.append([movie['title'], int(tmp_runtime), int(tmp_releasedate[:4])])
        return tmp_list

    def getBestMovie(self, name, length=None, year=None):
        self.report(2, "getBestMovie")
        tmp_movies = self.searchMovie(name)
        if not year and not length:
            self.report(0, "Does not know year or runtime... Selecting first response.")
            return tmp_movies[0]
        elif not year:
            self.report(0, "Got runtime but no year. Selecting closest match based on runtime.")
            tmp_time = []
            for movies in tmp_movies:
                if movies[1] == None:
                    movies[1] = 0
                tmp_time.append(movies[1])
            return tmp_movies[min(enumerate(tmp_time), key=lambda x:abs(x[1]-length))[0]]
        else:
            tmp_year = []
            for movies in tmp_movies:
                if movies[2] == None:
                    movies[2] = 9999
                tmp_year.append(movies[2])
            return tmp_movies[min(enumerate(tmp_year), key=lambda x:abs(x[1]-year))[0]]

    def getShowName(self, name):
        self.report(2, "getShowName")
        tmp_search = self.tmdb.Search()
        tmp_response = tmp_search.tv(query=name)
        return tmp_search.results[0]

    def getEpisodeName(self, name, season, episode):
        self.report(2, "getEpisodeName")
        self.tmdb.Search().tv(query=name)
        return self.tmdb.TV_Episodes(self.tmdb.results[0]['id'], season, episode).info()['name']