import pygame
import pygame.locals as pygame_consts
from UncasedDict import UncasedDict

DICT_EVENT_IB = {
    "QUIT": pygame_consts.QUIT,
    "ACTIVE_EVENT": pygame_consts.ACTIVEEVENT,
    "KEY_DOWN": pygame_consts.KEYDOWN,
    "KEY_UP": pygame_consts.KEYUP,
    "MOUSE_MOTION": pygame_consts.MOUSEMOTION,
    "MOUSE_BUTTON_UP": pygame_consts.MOUSEBUTTONUP,
    "MOUSE_BUTTON_DOWN": pygame_consts.MOUSEBUTTONDOWN,
    "JOY_AXIS_MOTION": pygame_consts.JOYAXISMOTION,
    "JOY_BALL_MOTION": pygame_consts.JOYBALLMOTION,
    "JOY_HAT_MOTION": pygame_consts.JOYHATMOTION,
    "JOY_BUTTON_UP": pygame_consts.JOYBUTTONUP,
    "JOY_BUTTOND_OWN": pygame_consts.JOYBUTTONDOWN,
    "VIDEO_RESIZE": pygame_consts.VIDEORESIZE,
    "VIDEO_EXPOSE": pygame_consts.VIDEOEXPOSE,
    # "USER_EVENT": pygame_consts.USEREVENT,
    # think of begin_step, step and end_step
}


DICT_KEYS = {
    r"BACKSPACE": pygame_consts.K_BACKSPACE,
    r"TAB": pygame_consts.K_TAB,
    r"CLEAR": pygame_consts.K_CLEAR,
    r"RETURN": pygame_consts.K_RETURN,
    r"PAUSE": pygame_consts.K_PAUSE,
    r"ESCAPE": pygame_consts.K_ESCAPE,
    r"SPACE": pygame_consts.K_SPACE,
    r"EXCLAIM": pygame_consts.K_EXCLAIM,
    r"QUOTEDBL": pygame_consts.K_QUOTEDBL,
    r"HASH": pygame_consts.K_HASH,
    r"DOLLAR": pygame_consts.K_DOLLAR,
    r"AMPERSAND": pygame_consts.K_AMPERSAND,
    r"QUOTE": pygame_consts.K_QUOTE,
    r"LEFTPAREN": pygame_consts.K_LEFTPAREN,
    r"RIGHTPAREN": pygame_consts.K_RIGHTPAREN,
    r"ASTERISK": pygame_consts.K_ASTERISK,
    r"PLUS": pygame_consts.K_PLUS,
    r"COMMA": pygame_consts.K_COMMA,
    r"MINUS": pygame_consts.K_MINUS,
    r"PERIOD": pygame_consts.K_PERIOD,
    r"SLASH": pygame_consts.K_SLASH,
    r"0": pygame_consts.K_0,
    r"1": pygame_consts.K_1,
    r"2": pygame_consts.K_2,
    r"3": pygame_consts.K_3,
    r"4": pygame_consts.K_4,
    r"5": pygame_consts.K_5,
    r"6": pygame_consts.K_6,
    r"7": pygame_consts.K_7,
    r"8": pygame_consts.K_8,
    r"9": pygame_consts.K_9,
    r"COLON": pygame_consts.K_COLON,
    r"SEMICOLON": pygame_consts.K_SEMICOLON,
    r"LESS": pygame_consts.K_LESS,
    r"EQUALS": pygame_consts.K_EQUALS,
    r"GREATER": pygame_consts.K_GREATER,
    r"QUESTION": pygame_consts.K_QUESTION,
    r"AT": pygame_consts.K_AT,
    r"LEFTBRACKET": pygame_consts.K_LEFTBRACKET,
    r"BACKSLASH": pygame_consts.K_BACKSLASH,
    r"RIGHTBRACKET": pygame_consts.K_RIGHTBRACKET,
    r"CARET": pygame_consts.K_CARET,
    r"UNDERSCORE": pygame_consts.K_UNDERSCORE,
    r"BACKQUOTE": pygame_consts.K_BACKQUOTE,
    r"a": pygame_consts.K_a,
    r"b": pygame_consts.K_b,
    r"c": pygame_consts.K_c,
    r"d": pygame_consts.K_d,
    r"e": pygame_consts.K_e,
    r"f": pygame_consts.K_f,
    r"g": pygame_consts.K_g,
    r"h": pygame_consts.K_h,
    r"i": pygame_consts.K_i,
    r"j": pygame_consts.K_j,
    r"k": pygame_consts.K_k,
    r"l": pygame_consts.K_l,
    r"m": pygame_consts.K_m,
    r"n": pygame_consts.K_n,
    r"o": pygame_consts.K_o,
    r"p": pygame_consts.K_p,
    r"q": pygame_consts.K_q,
    r"r": pygame_consts.K_r,
    r"s": pygame_consts.K_s,
    r"t": pygame_consts.K_t,
    r"u": pygame_consts.K_u,
    r"v": pygame_consts.K_v,
    r"w": pygame_consts.K_w,
    r"x": pygame_consts.K_x,
    r"y": pygame_consts.K_y,
    r"z": pygame_consts.K_z,
    r"DELETE": pygame_consts.K_DELETE,
    r"KP0": pygame_consts.K_KP0,
    r"KP1": pygame_consts.K_KP1,
    r"KP2": pygame_consts.K_KP2,
    r"KP3": pygame_consts.K_KP3,
    r"KP4": pygame_consts.K_KP4,
    r"KP5": pygame_consts.K_KP5,
    r"KP6": pygame_consts.K_KP6,
    r"KP7": pygame_consts.K_KP7,
    r"KP8": pygame_consts.K_KP8,
    r"KP9": pygame_consts.K_KP9,
    r"KP_PERIOD": pygame_consts.K_KP_PERIOD,
    r"KP_DIVIDE": pygame_consts.K_KP_DIVIDE,
    r"KP_MULTIPLY": pygame_consts.K_KP_MULTIPLY,
    r"KP_MINUS": pygame_consts.K_KP_MINUS,
    r"KP_PLUS": pygame_consts.K_KP_PLUS,
    r"KP_ENTER": pygame_consts.K_KP_ENTER,
    r"KP_EQUALS": pygame_consts.K_KP_EQUALS,
    r"UP": pygame_consts.K_UP,
    r"DOWN": pygame_consts.K_DOWN,
    r"RIGHT": pygame_consts.K_RIGHT,
    r"LEFT": pygame_consts.K_LEFT,
    r"INSERT": pygame_consts.K_INSERT,
    r"HOME": pygame_consts.K_HOME,
    r"END": pygame_consts.K_END,
    r"PAGEUP": pygame_consts.K_PAGEUP,
    r"PAGEDOWN": pygame_consts.K_PAGEDOWN,
    r"F1": pygame_consts.K_F1,
    r"F2": pygame_consts.K_F2,
    r"F3": pygame_consts.K_F3,
    r"F4": pygame_consts.K_F4,
    r"F5": pygame_consts.K_F5,
    r"F6": pygame_consts.K_F6,
    r"F7": pygame_consts.K_F7,
    r"F8": pygame_consts.K_F8,
    r"F9": pygame_consts.K_F9,
    r"F10": pygame_consts.K_F10,
    r"F11": pygame_consts.K_F11,
    r"F12": pygame_consts.K_F12,
    r"F13": pygame_consts.K_F13,
    r"F14": pygame_consts.K_F14,
    r"F15": pygame_consts.K_F15,
    r"NUMLOCK": pygame_consts.K_NUMLOCK,
    r"CAPSLOCK": pygame_consts.K_CAPSLOCK,
    r"SCROLLOCK": pygame_consts.K_SCROLLOCK,
    r"RSHIFT": pygame_consts.K_RSHIFT,
    r"LSHIFT": pygame_consts.K_LSHIFT,
    r"RCTRL": pygame_consts.K_RCTRL,
    r"LCTRL": pygame_consts.K_LCTRL,
    r"RALT": pygame_consts.K_RALT,
    r"LALT": pygame_consts.K_LALT,
    r"RMETA": pygame_consts.K_RMETA,
    r"LMETA": pygame_consts.K_LMETA,
    r"LSUPER": pygame_consts.K_LSUPER,
    r"RSUPER": pygame_consts.K_RSUPER,
    r"MODE": pygame_consts.K_MODE,
    r"HELP": pygame_consts.K_HELP,
    r"PRINT": pygame_consts.K_PRINT,
    r"SYSREQ": pygame_consts.K_SYSREQ,
    r"BREAK": pygame_consts.K_BREAK,
    r"MENU": pygame_consts.K_MENU,
    r"POWER": pygame_consts.K_POWER,
    r"EURO": pygame_consts.K_EURO,
}

LIST_EVENTS_GAME_PRE = ["BEGIN_STEP"]
# Custom events to be registered here
LIST_EVENTS_GAME_POST = ["STEP", "DRAW", "END_STEP"]
LIST_EVENTS_CUSTOM = [
    "KEY_PRESS", "MOUSE_PRESS", "Instance_Create", "Instance_Destroy"]


dict_event_name = UncasedDict()
list_event = []
list_event_old = []
list_state_key = []
list_state_key_old = []
list_state_mouse, list_state_mouse_old = [], []


def register_event_name(ev_name, ev_id=None):
    if (ev_name in dict_event_name):
        raise TypeError(
            "ev_name={0} is already registered".format(ev_name))
    if (ev_id is None):
        ev_id = max(
            pygame_consts.USEREVENT + 1, max(dict_event_name.values()) + 1)
    dict_event_name[ev_name] = ev_id


def add_each_event(ev):
    if not (ev.ev_name in dict_event_name):
        return TypeError("ev_name not registered")
    else:
        # make list_event_accessible
        list_event.append(ev)


def add_returned_events(ev_or_ev_list):
    # fix below cond
    if hasattr(ev_or_ev_list, "__iter__"):
        # list of events
        for each_ev in ev_or_ev_list:
            add_each_event(each_ev)
    else:
        # single event
        add_each_event(ev_or_ev_list)


def get_event_name(ev_id):
    for ev_name in dict_event_name:
        if dict_event_name[ev_name] == ev_id:
            return ev_name


def get_event_id(ev_name):
    return dict_event_name.get(ev_name)


def get_key_name(key_id):
    for key_name in DICT_KEYS:
        if DICT_KEYS[key_name] == key_id:
            return key_name


def get_key_id(key_name):
    return DICT_KEYS.get(key_name)


def get_mouse_btn_name(btn_id):
    # btn_id can be 0, 1 or 2
    if btn_id == 0:
        return "left"
    elif btn_id == 1:
        return "middle"
    elif btn_id == 2:
        return "right"
    else:
        raise ValueError("btn_id must be 0, 1 or 2")

# No sort_events, event_generators should be pushed in correct order


def fuzzy_match_event_name(string_, event_or_action):
    str_upper = string_.upper()
    if not (str_upper in dict_event_name):
        event_or_action = event_or_action.lower()
        if event_or_action == "event" or event_or_action == "action":
            # STR_STARTER becomes event_ or action_
            STR_STARTER = event_or_action.upper() + "_"
        else:
            raise TypeError(
                "event_or_action arg must be 'event' or 'action'.")
        str_normalized = str_upper[
            str_upper.find(STR_STARTER) + len(STR_STARTER):]
        for tmp_event_name in dict_event_name:
            # tmp event is the event_name, keys of KW_EVENTS
            tmp_event_name_normalized = tmp_event_name.upper().replace("_", "")
            if str_normalized.startswith(tmp_event_name) or str_normalized.startswith(tmp_event_name_normalized):
                return tmp_event_name
    else:
        return str_upper


def add_ev_name_GAME_PRE():
    for ev_name in LIST_EVENTS_GAME_PRE:
        register_event_name(ev_name)


def add_ev_name_IB():
    for ev_name in DICT_EVENT_IB:
        register_event_name(ev_name, DICT_EVENT_IB[ev_name])


def add_ev_name_GAME_POST():
    for ev_name in LIST_EVENTS_GAME_POST:
        register_event_name(ev_name)


def add_ev_name_CUSTOM():
    for ev_name in LIST_EVENTS_CUSTOM:
        register_event_name(ev_name)

# event_generators


def gen_event_GAME_PRE():
    return [Event(ev_name) for ev_name in LIST_EVENTS_GAME_PRE]


def gen_event_IB():
    # move current list to old list
    list_event_IB = pygame.event.get()
    # Above list contains pygame_events, cant be modified
    # But need to replace type with ev_name
    new_list_ev = []
    for each_ev in list_event_IB:
        ev_name = get_event_name(each_ev.type)
        tmp_ev = Event(ev_name, each_ev.dict)
        new_list_ev.append(tmp_ev)

    return new_list_ev


def gen_event_GAME_POST():
    return [Event(ev_name) for ev_name in LIST_EVENTS_GAME_POST]


def gen_event_KEY_PRESS():
    global list_state_key, list_state_key_old
    list_state_key_old = list_state_key
    list_state_key = pygame.key.get_pressed()
    list_key_press_event = []
    for tmp_key_id, bool_pressed in enumerate(list_state_key):
        if bool_pressed:
            tmp_key_name = get_key_name(tmp_key_id)
            list_key_press_event.append(
                Event("KEY_PRESS", {"key_name": tmp_key_name.lower(), "key_id": tmp_key_id}))
    return list_key_press_event


def gen_event_MOUSE_PRESS():
    global list_state_mouse, list_state_mouse_old
    list_state_mouse_old = list_state_mouse
    list_state_mouse = pygame.mouse.get_pressed()
    list_mouse_press_event = []
    for tmp_mouse_btn_id, bool_pressed in enumerate(list_state_mouse):
        if bool_pressed:
            tmp_btn_name = get_mouse_btn_name(tmp_mouse_btn_id)
            list_mouse_press_event.append(
                Event("MOUSE_PRESS", {"btn_name": tmp_btn_name.lower(), "btn_id": tmp_mouse_btn_id}))
    return list_mouse_press_event

# pygame.mouse.get_pressed

# add ev_names
# Ordered list of name adders
LIST_ADDER_EV_NAME = [
    add_ev_name_IB, add_ev_name_GAME_PRE, add_ev_name_GAME_POST, add_ev_name_CUSTOM]
for each_adder_func in LIST_ADDER_EV_NAME:
    each_adder_func()


# add event generators
# Ordered list of generators
list_ordered_custom_generator = [gen_event_KEY_PRESS, gen_event_MOUSE_PRESS]

list_ordered_generators = [
    gen_event_GAME_PRE, gen_event_IB, list_ordered_custom_generator, gen_event_GAME_POST]


def register_custom_event_generator(ev_func):
    ''' ev_func will be run in each step before step event and after begin step event and should return a / a list of dicts
        each with ev_name (to be registered beforehand) and other props'''
    global list_ordered_custom_generator
    list_ordered_custom_generator.append(ev_func)


def get_event_generators():
    return_list = []
    for gen_or_list in list_ordered_generators:
        if hasattr(gen_or_list, "__iter__"):
            return_list.extend(gen_or_list)
        else:
            return_list.append(gen_or_list)
    return return_list


# Todo: Howto programatically register at the right position of generator list
# Event collector


def collect_events():
    # First, clear the old ev list
    global list_event, list_event_old
    list_event_old = list_event
    list_event = []
    for each_gen in get_event_generators():
        add_returned_events(each_gen())

# Event dispatcher
# To be used by appr. classes


def dispatch_events_class(cls):
    # cls.list_class must be available
    for each_class in cls.list_class:
        each_class.dispatch_events_instance(list_event)


def dispatch_events_instance(cls, list_event):
    for each_instance in cls.list_instance:
        each_instance.dispatch_events_self(list_event)


def dispatch_events_self(self, list_event):
    for each_ev in list_event:
        if each_ev.ev_name.upper() in self.dict_action_func:
            self.dispatch_events_local()
            for each_action in self.dict_action_func[each_ev.ev_name]:
                # similar as self.action_step(each_ev)
                each_action(self, each_ev)


def dispatch_events_local(self):
    for each_ev in self.list_event_local:
        if each_ev.ev_name.upper() in self.dict_action_func:
            for each_action in self.dict_action_func[each_ev.ev_name]:
                # similar as self.action_step(each_ev)
                each_action(self, each_ev)
    self.clear_event_local()


def push_event_local(self, ev_or_ev_list):
    if hasattr(ev_or_ev_list, "__iter__"):
        # list of events
        for each_ev in ev_or_ev_list:
            self._push_event_local_single(each_ev)
    else:
        # single event
        self._push_event_local_single(ev_or_ev_list)


def clear_event_local(self):
    self.list_event_local = []


def _push_event_local_single(self, ev):
    self.list_event_local.append(ev)


class Event(object):

    def __init__(self, ev_name, dict_=None):
        super(Event, self).__init__()
        self.ev_name = ev_name
        self.dict = dict_


def _check_event(ev_name, new_or_old):
    ''' ev_name_or_type => name_or_type(numb)_of_event
        new_or_old => current_event_list or old_event_list '''
    global list_event, list_event_old
    matched_events = []
    if new_or_old == "new":
        list_to_check = list_event
    elif new_or_old == "old":
        list_to_check = list_event_old
    else:
        raise AttributeError("new_or_old must be 'new' or 'old'.")

    ev_name = fuzzy_match_event_name(ev_name, "event")

    for ev in list_to_check:
        if ev.ev_name == ev_name:
            matched_events.append(ev)
    return matched_events


def check_event(ev_name):
    return _check_event(ev_name, "new")


def check_event_old(ev_name):
    return _check_event(ev_name, "old")


def _get_key_press(key_name=None, new_or_old=None):
    ''' Returns list of dict with key_name and key_id, if key_name matches.
        If key_name is None, all key preeses are allowed.'''
    global list_state_key, list_state_key_old
    if new_or_old == "new":
        list_to_check = list_state_key
    elif new_or_old == "old":
        list_to_check = list_state_key_old
    else:
        raise TypeError("new_or_old must be 'new' or 'old', CANT be None")
    list_key_press_event = []
    for tmp_key_id, bool_pressed in enumerate(list_to_check):
        if bool_pressed:
            tmp_key_name = get_key_name(tmp_key_id)
            if (key_name is None) or (tmp_key_name.lower() == key_name.lower()):
                # Todo: Cant match event_name directly, need a fuzzy key name
                # search func
                list_key_press_event.append(
                    {"key_name": tmp_key_name.lower(), "key_id": tmp_key_id})
    return list_key_press_event


def _get_mouse_press(btn_name=None, new_or_old=None):
    global list_state_mouse, list_state_mouse_old
    if new_or_old == "new":
        list_to_check = list_state_mouse
    elif new_or_old == "old":
        list_to_check = list_state_mouse_old
    else:
        raise TypeError("new_or_old must be 'new' or 'old', CANT be None")

    list_mouse_press_event = []
    for tmp_mouse_btn_id, bool_pressed in enumerate(list_to_check):
        if bool_pressed:
            tmp_btn_name = get_mouse_btn_name(tmp_mouse_btn_id)
            if (btn_name is None) or (btn_name.lower() == tmp_btn_name.lower()):
                list_mouse_press_event.append(
                    {"btn_name": tmp_btn_name.lower(), "btn_id": tmp_mouse_btn_id})
    return list_mouse_press_event


def get_key_press(key_name=None):
    return _get_key_press(key_name, "new")


def get_key_press_old(key_name=None):
    return _get_key_press(key_name, "old")


def get_mouse_press(btn_name=None):
    return _get_mouse_press(btn_name, "new")


def get_mouse_press_old(btn_name=None):
    return _get_mouse_press(btn_name, "old")