#    FortuneEngine is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    FortuneEngine 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 General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with the FortuneEngine.  If not, see <http://www.gnu.org/licenses/>.
#
#    Author: Justin Lewis  <jlew.blackout@gmail.com>

import pygame
from time import time
from GameEngineConsole import GameEngineConsole
from GameInspect import GameInspect
from DrawableObject import DrawableObject
from DynamicDrawableObject import DynamicDrawableObject
from DrawableFontObject import DrawableFontObject
from Scene import Scene


class GameEngine(object):
    """
    The Fortune Engine GameEngine is a main loop wrapper around pygame.
    It manages the event and drawing loops allowing the user to just
    register for user events and drawing time in the draw loop.
    """
    instance = None

    def __init__(self, width=1200, height=900, always_draw=False, fps_cap=15):
        """
        Constructor for the game engine.

        @param width:        Window width
        @param height:       Window height
        @param always_draw:  Boolean to set the animation mode to always
                             draw vs draw when set_dirty is called
        @param fps_cap:      Sets the framerate cap. Set to 0 to disable
                             the cap. Warning: setting the cap to 0 when
                             always draw = False will cause cpu 100% when
                             not driving.
        """
        GameEngine.instance = self
        pygame.init()
        pygame.mouse.set_visible(False)

        # Window Settings
        self.width = width
        self.height = height
        size = width, height
        self.screen = pygame.display.set_mode(size)
        self.__fps = DrawableFontObject("", pygame.font.Font(None, 17))
        self.__scene = Scene(self.__fps)

        # Engine Internal Variables
        self.__fps_cap = fps_cap
        self.__showfps = False
        self.__dirty = True
        self.__always_draw = always_draw
        self.__font = pygame.font.Font(None, 17)
        self.__run_event = False

        # Variables to hold game engine elements and callbacks
        self.__event_cb = []
        self.__draw_lst = []
        self.__object_hold = {}
        self.__dirtyList=[]

        # Game Timers
        self.__active_event_timers = []
        self.__active_event_timers_tick = []

        # Game Clock
        self.clock = pygame.time.Clock()
        self.__tick_time = 0

        # Inspector
        self._inspector = GameInspect(self.__object_hold)

        # Time Profiler Timers
        self.__draw_time = {}
        self.__draw_calls = {}
        self.__event_time = {}
        self.__event_calls = {}
        self.__timer_time = {}
        self.__timer_calls = {}

        # Initialize Py Console
        self.console = GameEngineConsole(self, (0, 0, width, height / 2))

        # Disable Mouse Usage
        # TODO Allow mouse motion on request
        pygame.event.set_blocked(pygame.MOUSEMOTION)

    def set_dirty(self):
        """
        Sets the dirty flag to force the engine to draw the next time
        it enters the draw flag.
        """
        self.__dirty = True
        
    def get_scene(self):
    
       return self.__scene

    def start_event_timer(self, function_cb, time):
        """
        Starts a timer that fires a user event into the queue every "time"
        milliseconds

        @param function_cb:     The function to call when timer fires
        @param time:            Milliseconds between fires
        """
        avail_timer = len(self.__active_event_timers)

        if avail_timer + pygame.USEREVENT < pygame.NUMEVENTS:
            if function_cb not in self.__active_event_timers:
                self.__timer_time[str(function_cb)] = 0
                self.__timer_calls[str(function_cb)] = 0

                self.__active_event_timers.append(function_cb)
                self.__active_event_timers_tick.append(time)
                pygame.time.set_timer(pygame.USEREVENT + avail_timer, time)
            else:
                print "ERROR TIMER IN LIST"
        else:
            print "Ran out of timers :("
            self.stop_event_loop()

    def stop_event_timer(self, function_cb):
        """
        Stops the timer that has id from firing

        @param function_cb:     The function registered with the timer that
                                should be canceled
        """
        try:
            timer_id = self.__active_event_timers.index(function_cb)
        except ValueError:
            return

        pygame.time.set_timer(pygame.USEREVENT + timer_id, 0)
        del self.__active_event_timers[timer_id]
        del self.__active_event_timers_tick[timer_id]

        # Timers have been removed, now need to clear any events
        # already fired and in the queue
        pygame.event.clear(pygame.USEREVENT + timer_id)

    def list_event_timers(self):
        """
        returns a list of configured timers, if the timers has a time of 0 the
        timer is disabled
        """
        timer_list = "Event Timers:\n"
        i = 0
        for timer_item in self.__active_event_timers:
            timer_list += "\t%d: %d\n" % (timer_item,
                          self.__active_event_timers_tick[i])
            i = i + 1

        return timer_list

    def list_timer_time(self):
        """
        Returns a string representation of the time the game spends
        in each timer callback.
        """
        mystr = "Timer Times:\n\tName\tCalls\tTotal Time\tAvg"
        for key in self.__timer_time:
            timer_times = self.__timer_time[key]
            timer_calls = self.__timer_calls[key]
            if timer_calls == 0:
                avg = 0
            else:
                avg = timer_times / timer_calls

            mystr = "%s\n\t%s\n\t\t%d\t%f\t%f" % \
                    (mystr, key, timer_calls, timer_times, avg)
        return mystr


    def start_main_loop(self):
        """
        Starts the game loop.

        This function does not return until after the game loop exits
        """
        self.__run_event = True
        self._event_loop()

    def _draw(self, tick_time):
        """
        Draws all elements in draw callback to the screen

        @param tick_time:       The amount of time passed since last
                                draw cycle. (should be produced by
                                pygamme.clock.tick method)
        """
        screen = self.screen

        # If console is active, we want to draw console, pausing
        # game drawing (events are still being fired, just no
        # draw updates.
        if self.console.active:
            self.console.draw()
            pygame.display.flip()

        else:
            for fnc in self.__draw_lst:
                 start = time()
                 fnc(screen, tick_time)
                 self.__draw_time[str(fnc)] += time() - start
                 self.__draw_calls[str(fnc)] += 1
            # Print Frame Rate
            if self.__showfps:
                self.__fps.changeText('FPS: %d' % self.clock.get_fps(), (255,255,255))
                self.__fps.setPosition(0,0)
            else:
                self.__fps.changeText('')
            self.__scene.update(tick_time)
            pygame.display.update(self.__scene.draw(screen))

    def _event_loop(self):
        """
        The main event loop.
        """
        while self.__run_event:

            event = pygame.event.poll()

            # Handle Game Quit Message
            if event.type == pygame.QUIT:
                self.__run_event = False

            # No-Op sent, draw if set to always draw
            elif event.type == pygame.NOEVENT:
                # Tick even if not drawing
                # We want to pause the cpu from getting into a
                # 100% usage looping on the poll until something
                # becomes dirty
                self.__tick_time += self.clock.tick(self.__fps_cap)
                if self.__always_draw or self.__dirty:
                    self.__dirty = False
                    self._draw(self.__tick_time)
                    self.__tick_time = 0


            # Handle User event Timers
            elif event.type >= pygame.USEREVENT and \
                event.type < pygame.NUMEVENTS:

                timer_id = event.type - pygame.USEREVENT

                # Call timer
                str_rep = str(self.__active_event_timers[timer_id])
                start = time()
                self.__active_event_timers[timer_id]()
                self.__timer_time[str_rep] += time() - start
                self.__timer_calls[str_rep] += 1

            # Check if we should activate the console
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_w \
                    and pygame.key.get_mods() & pygame.KMOD_CTRL:
                self.console.set_active()
                self.set_dirty()

            # Pass event to console
            elif self.console.process_input(event):
                self.set_dirty()

            # Pass events to all others
            else:
                # Make a copy first so that adding events don't get fired
                # right away
                list_cp = self.__event_cb[:]

                # Reverse list so that newest stuff is on top
                # TODO: cache this list
                list_cp.reverse()

                for cb in list_cp:
                    # Fire the event for all in cb and stop
                    # if the callback returns True
                    start = time()
                    retur_val = cb(event)
                    self.__event_time[str(cb)] += time() - start
                    self.__event_calls[str(cb)] += 1

                    if retur_val:
                        break


    def stop_event_loop(self):
        """
        Sends a pygame.QUIT event into the event queue which
        exits the event loop
        """
        pygame.event.post(pygame.event.Event(pygame.QUIT))

    def add_event_callback(self, cb):
        """
        Adds event callback to the event callback stack

        @param cb:  Callback to be added to the stack when events are fired.
        """
        self.__event_time[str(cb)] = 0
        self.__event_calls[str(cb)] = 0
        self.__event_cb.append(cb)

    def remove_event_callback(self, cb):
        """
        Removes an event from the event callback stack

        @param cb:       The callback to remove from the event callback stack
        @return:         Returns true if successful in removing callback
        """
        try:
            self.__event_cb.remove(cb)
            return True
        except:
            return False

    def list_event_callbacks(self):
        """
        Returns a string representation of all events registered with the game
        engine
        """
        event_callbacks = "Event Listeners:\n"
        for eventlst in self.__event_cb:
            event_callbacks = "%s\t%s\n" % (event_callbacks, str(eventlst))
        return event_callbacks

    def list_event_time(self):
        """
        Returns a string representation of the time the game spends
        in each event callback.
        """
        mystr = "Event Times:\n\tName\tCalls\tTotal Time\tAvg"
        for key in self.__event_time:
            event_times = self.__event_time[key]
            event_calls = self.__event_calls[key]
            if event_calls == 0:
                avg = 0
            else:
                avg = event_times / event_calls

            mystr = "%s\n\t%s\n\t\t%d\t%f\t%f" % \
                    (mystr, key, event_calls, event_times, avg)
        return mystr


    def add_draw_callback(self, fnc):
        """
        Adds a callback to the draw list.  Function will be passed the
        game screen it should draw too.

        @param fnc:    The function to call when system is drawing
        """

        self.__draw_time[str(fnc)] = 0
        self.__draw_calls[str(fnc)] = 0
        self.__draw_lst.append(fnc)

    def pop_draw_callback(self):
        """
        Removes top of draw stack and returns it

        @return:         Returns the top callback function that was removed
        """
        return self.__draw_lst.pop()

    def clear_draw_callback(self):
        """
        Empties draw callback stack
        """
        self.__draw_lst = []

    def remove_draw_callback(self, fnc):
        """
        Removes a draw callback from the game engine draw function

        @param fnc:      The callback function to remove
        @return:         Returns true if successful removal of the function
        """
        try:
            self.__draw_lst.remove(fnc)
            return True
        except:
            return False

    def list_draw_callbacks(self):
        """
        Lists all the draw callbacks currently registered with the game engine
        """

        callbacks = "Draw Callbacks:\n"
        for eventlst in self.__draw_lst:
            callbacks += "\t%s\n" % str(eventlst)
        return callbacks

    def list_draw_time(self):
        """
        Returns a string representation of the time the game spends
        in each drawing callback.
        """
        mystr = "Drawing Times:\n\tName\tCalls\tTotal Time\tAvg"
        for key in self.__draw_time:
            draw_times = self.__draw_time[key]
            draw_calls = self.__draw_calls[key]
            if draw_calls == 0:
                avg = 0
            else:
                avg = draw_times / draw_calls

            mystr = "%s\n\t%s\n\t\t%d\t%f\t%f" % \
                    (mystr, key, draw_calls, draw_times, avg)
        return mystr

    def has_object(self, name):
        """
        Returns true if object is stored in game engine

        @param name:     Name of the object to check if exists
        @return:         Returns true if object found
        """
        return name in self.__object_hold

    def add_object(self, name, obj):
        """
        Adds an object to the game engine datastore

        @param name:     The name used to store the object
        @param obj:      The object to store
        """
        self.__object_hold[name] = obj

    def get_object(self, name):
        """
        Returns an object from the game engine datastore

        @param name:     The name of object to return
        @return:         Returns the object
        """
        return self.__object_hold[name]

    def remove_object(self, name):
        """
        Removes an object from the game engine datastore

        @param name:     The name of the object to remove
        """
        del self.__object_hold[name]

    def list_objects(self):
        """
        Returns a sting of registered objects
        """
        objlist = "Objects Registered:\n"
        for eventlst in self.__object_hold:
            objlist += "\t%s\n" % str(eventlst)
        return objlist

    def toggle_fps(self):
        """
        Toggles fps display
        """
        self.__showfps = not self.__showfps

    def art_scale(self, original, expected, width=True):
        if width:
            return int(self.width / float(expected) * float(original))
        else:

            return int(self.height / float(expected) * float(original))