from .rounded_rect import *
from .action import *
from .font import font
import time
import sys
import pygame

class Key:
    default_outer_color = (120, 120, 120)
    lighter_outer_color = (200, 200, 200)
    default_inner_color = (255, 255, 255)
    mapped_inner_color  = (  0, 255,   0)
    mapped_unready_inner_color  = (  0, 255,   0, 100)

    def __init__(self, mapping, draw_lock, key_name, key_sym, top, left, width = 48, height = 48, disabled = False):
        self.draw_lock = draw_lock
        self.mapping = mapping
        self.key_name = key_name
        self.key_sym  = key_sym

        self.top = top
        self.left   = left
        self.width  = width
        self.height = height

        self.bottom = self.top  + self.height
        self.right  = self.left + self.width

        self.rect     = (self.left, self.top, self.right, self.bottom)
        self.position = (self.left, self.top)
        self.disabled = disabled

        if disabled:
            self.outer_color = self.lighter_outer_color
            self.linewidth = 1
        else:
            self.outer_color = self.default_outer_color
            self.linewidth = 3

        self.inner_color = self.default_inner_color
        self.actions = []
        self.description = []
        self.custom_color = self.mapped_inner_color
        self.custom_unready_color = self.mapped_unready_inner_color

    def square(self, all_actions_ready):
        if self.has_actions():
            if all_actions_ready:
                self.inner_color = self.custom_color
            else:
                self.inner_color = self.custom_unready_color

        return RoundedRect((0, 0, self.width, self.height),
            self.outer_color, self.inner_color, self.linewidth)

    def collidepoint(self, position):
        return self.surface.get_rect().collidepoint(
                position[0] - self.position[0],
                position[1] - self.position[1]
                )

    def set_description(self, description):
        for desc in description:
            if desc is None:
                self.description.append("")
            else:
                self.description.append(str(desc))

    def set_color(self, color):
        self.custom_color = tuple(color)
        color.append(100)
        self.custom_unready_color = tuple(color)

    def draw(self, background_surface):
        self.draw_lock.acquire()
        all_actions_ready = self.all_actions_ready()

        self.surface = self.square(all_actions_ready).surface()

        police = font(14)
        text_police = font(10)

        police.set_bold(True)
        text = police.render(self.key_sym, True, (0,0,0))
        self.surface.blit(text, (5,5))

        is_first_line = True
        offset = 11 + text_police.get_linesize() - 4
        first_line_offset = 18
        for description in self.description:
            text = text_police.render(description, True, (0,0,0))
            if is_first_line:
                self.surface.blit(text, (first_line_offset, 9))
                is_first_line = False
            else:
                self.surface.blit(text, (3, offset))
                offset += text_police.get_linesize() - 4

        background_surface.blit(self.surface, self.position)
        self.draw_lock.release()

        return not all_actions_ready

    def poll_redraw(self, background):
        while True:
            time.sleep(1)
            if self.all_actions_ready():
                self.draw(background)
                self.mapping.blit()
                break

    def has_actions(self):
        return len(self.actions) > 0

    def all_actions_ready(self):
        return all(action.ready() for action in self.actions)

    def add_action(self, action_name, **arguments):
        self.actions.append(Action(action_name, self, **arguments))

    def do_actions(self):
        print("running actions for {}".format(self.key_sym))
        start_time = time.time()
        self.mapping.start_running(self, start_time)
        for action in self.actions:
            if self.mapping.keep_running(self, start_time):
                action.run()

        self.mapping.finished_running(self, start_time)

    def list_actions(self, screen):
        action_descriptions = [action.description() for action in self.actions]
        #print("actions linked to key {}:".format(self.key_sym))
        #print("\t" + "\n\t".join(action_descriptions))
        self.draw_lock.acquire()
        surface = pygame.Surface((690, 250)).convert()
        surface.fill((250, 250, 250))
        police = font(14)

        offset = 0
        police.set_bold(True)
        text = police.render("actions linked to key {}:".format(self.key_sym), True, (0,0,0))
        surface.blit(text, (0, offset))
        offset += police.get_linesize()

        police.set_bold(False)
        for description in action_descriptions:
            text = police.render(description, True, (0,0,0))
            surface.blit(text, (0, offset))
            offset += police.get_linesize()

        screen.blit(surface, (5, 308))
        pygame.display.flip()
        self.draw_lock.release()