from blinkenbase.animation import Animation
from blinkenbase.blinkenroom import Blinkenroom
import blinkenbase.blinkenroom
import blinkenbase.animation
import time
from blinkenbase.blinkenroom import BLINKENROOM_LOUNGE
import _thread
#from darken import darken

class AnimationHandler(object):

    ERROR_ANIMATION_RUNNING = 100
    ERROR_ANIMATION_NOT_FOUND = 101
    ERROR_OVERLAPPING = 102

    def __init__(self):
        self.running_animations = {}
        self.known_animations = {}
        self.last_frame = None

    #######################
    ###Animation control###
    ######################

    def stop_animation(self, p_name):
        if p_name in self.running_animations:
            animation = self.running_animations[p_name]
            print("Stopping %s" % p_name)
            animation.stop()
            del self.running_animations[p_name]

    def stop_all_animations(self, p_args=None):
        for running in self.running_animations.values():
            running.stop()
        self.running_animations = {}
        self.last_frame = BLINKENROOM_LOUNGE.get_last_frame()

    def pause_animation(self, p_animation_name):
        if p_animation_name in self.running_animations:
            animation = self.running_animations[p_animation_name]
            animation.pause()

    def pause_all_animations(self):
        for animation in self.running_animations.values():
            animation.pause()

    def resume_animation(self, p_animation_name):
        if p_animation_name in self.running_animations:
            animation = self.running_animations[p_animation_name]
            animation.resume()

    def resume_all_animations(self):
        for animation in self.running_animations.values():
            animation.resume()

    def start_animation(self, p_name, p_animation_args):
        p_name = p_name.lower()

        animation_class = None
        try:
            exec("from animations.%s import %s" % (p_name, p_name))
            animation_class = eval(p_name)
        except ImportError:
            print("Animation not found '%s'" % p_name)
            return self.ERROR_ANIMATION_NOT_FOUND

        animation = animation_class()
        required_args = animation.required_args
        for arg in required_args:
            required = required_args[arg]
            if arg not in p_animation_args:
                p_animation_args[arg] = required[1]
            else:
                casting_method = required[0]
                current_arg = p_animation_args[arg]
                p_animation_args[arg] = casting_method(current_arg)

        animation.set_args(p_animation_args)
        animation.init_animation()
        to_stop = []
        for running in self.running_animations.values():
            if animation.blinkenroom.is_overlapping(running.blinkenroom):
                to_stop.append(running.name)

        for running in to_stop:
            self.stop_animation(running)

        self.running_animations[p_name] = animation
        animation.start()

    #################
    ###Light-Level###
    #################

    def _thread_handler_darken(self, a, b):
        f = 100
        while f > 0:
            BLINKENROOM_LOUNGE.set_brightness(f)
            time.sleep(0.05)
            f -= 1
        self.pause_all_animations()

    def _thread_handler_lighten(self, a, b):
        f = 1
        self.resume_all_animations()
        while f <= 100:
            BLINKENROOM_LOUNGE.set_brightness(f)
            time.sleep(0.05)
            f += 1

    def darken(self, p_args):
        _thread.start_new_thread(self._thread_handler_darken, (None, None))

    def lighten(self, p_args):
        _thread.start_new_thread(self._thread_handler_lighten, (None, None))

#    def darken(self, p_args):
#        self.stop_all_animations()
#        darken_dicts = {
#            "frame": self.last_frame,
#            "rate": 30,
#            "steps": 100
#        }
#        animation = darken()
#        animation.set_args(darken_dicts)
#        animation.init_animation()
#        animation.start()