#
# Aura Engine API (https://gitlab.servus.at/aura/engine-api)
#
# Copyright (C) 2020 - The Aura Engine Team.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import datetime

from models import PlayLog, TrackSchema



class ApiService():
    """
    Service handling API actions.
    """

    config = None
    logger = None


    def __init__(self, config, logger):
        self.config = config
        self.logger = logger


    def current_track(self):  
        """
        Retrieves the currently playing track.  

        Returns:
            (PlayLogEntry)
        """
        track = PlayLog.select_current()
        track_schema = TrackSchema()
        return track_schema.dump(track)


    def list_tracks(self, page=None, size=None):  
        """
        Lists track-service entries with pagination.

        Args:
            page (Integer): The number of the page to return
            size (Integer): The numbers of items to return

        Returns:
            (List[PlayLogEntry])
        """
        if not size or size > 50 or size < 1: size = 20
        tracklist = PlayLog.paginate(page, size, None)
        tracklist_schema = TrackSchema(many=True)
        return tracklist_schema.dump(tracklist)


    def list_playlog(self, page=None, size=None, since_time=None):  
        """
        Get paginated playlog entries for since the given timestamp.  

        Args:
            since_time (datetime): Get entries after this timestamp (e.g. &#x27;2020-08-29T09:12:33.001Z&#x27;)
            page (Integer): The number of items to skip before starting to collect the result set
            size (Integer): The numbers of items to return per page

        Returns:
            (List[PlayLogEntry])
        """
        tracklist = PlayLog.paginate(page, size, since_time)
        tracklist_schema = TrackSchema(many=True)
        return tracklist_schema.dump(tracklist)


    def store_playlog(self, data): 
        """
        Stores the passed playlog entry.

        Returns:
            (PlayLogEntry)
        """
        playlog = PlayLog(data)
        playlog.save()


    def clock_info(self):
        """
        Retrieves the currently playing playlist.  
        """
        return "current playlist"


    def activate_engine(self, engine_number):
        """
        Activates one engine and deactivates the other

        Args:
            engine_number (Integer): Number of the engine
        """
        return 'do some magic!'


    def get_active_engine(self):
        """
        Retrieves the status entry of the currently active engine

        Returns:
            StatusEntry
        """
        return 'do some magic!'


    def get_engine_health(self, engine_number):
        """
        Retrieves the most recent health info of the requested engine

        Args:
            engine_number (Integer): Number of the engine


        Returns:
            (HealthInfo)
        """
        return 'do some magic!'


    def log_engine_health(self, engine_number):
        """
        Logs another health entry for the given engine

        Args:
            engine_number (Integer): Number of the engine

        """
        return 'do some magic!'