import pygame


class Keys:
    """
    random object structure to handle keyboard keys
    """
    def __init__(self) -> None:
        pass

    @property
    def K_BACKSPACE(self):
        """
        backspace
        """
        return pygame.K_BACKSPACE

    @property
    def K_TAB(self):
        """
        tab
        """
        return pygame.K_TAB

    @property
    def K_CLEAR(self):
        """
        clear
        """
        return pygame.K_CLEAR

    @property
    def K_RETURN(self):
        """
        return
        """
        return pygame.K_RETURN

    @property
    def K_PAUSE(self):
        """
        pause
        """
        return pygame.K_PAUSE

    @property
    def K_ESCAPE(self):
        """
        escape
        """
        return pygame.K_ESCAPE

    @property
    def K_SPACE(self):
        """
        space
        """
        return pygame.K_SPACE

    @property
    def K_EXCLAIM(self):
        """
        exclaim
        """
        return pygame.K_EXCLAIM

    @property
    def K_QUOTEDBL(self):
        """
        quotedbl
        """
        return pygame.K_QUOTEDBL

    @property
    def K_HASH(self):
        """
        hash
        """
        return pygame.K_HASH

    @property
    def K_DOLLAR(self):
        """
        dollar
        """
        return pygame.K_DOLLAR

    @property
    def K_AMPERSAND(self):
        """
        ampersand
        """
        return pygame.K_AMPERSAND

    @property
    def K_QUOTE(self):
        """
        quote
        """
        return pygame.K_QUOTE

    @property
    def K_LEFTPAREN(self):
        """
        left parenthesis
        """
        return pygame.K_LEFTPAREN

    @property
    def K_RIGHTPAREN(self):
        """
        right parenthesis
        """
        return pygame.K_RIGHTPAREN

    @property
    def K_ASTERISK(self):
        """
        asterisk
        """
        return pygame.K_ASTERISK

    @property
    def K_PLUS(self):
        """
        plus sign
        """
        return pygame.K_PLUS

    @property
    def K_COMMA(self):
        """
        comma
        """
        return pygame.K_COMMA

    @property
    def K_MINUS(self):
        """
        minus sign
        """
        return pygame.K_MINUS

    @property
    def K_PERIOD(self):
        """
        period
        """
        return pygame.K_PERIOD

    @property
    def K_SLASH(self):
        """
        forward slash
        """
        return pygame.K_SLASH

    @property
    def K_0(self):
        """
        0
        """
        return pygame.K_0

    @property
    def K_1(self):
        """
        1
        """
        return pygame.K_1

    @property
    def K_2(self):
        """
        2
        """
        return pygame.K_2

    @property
    def K_3(self):
        """
        3
        """
        return pygame.K_3

    @property
    def K_4(self):
        """
        4
        """
        return pygame.K_4

    @property
    def K_5(self):
        """
        5
        """
        return pygame.K_5

    @property
    def K_6(self):
        """
        6
        """
        return pygame.K_6

    @property
    def K_7(self):
        """
        7
        """
        return pygame.K_7

    @property
    def K_8(self):
        """
        8
        """
        return pygame.K_8

    @property
    def K_9(self):
        """
        9
        """
        return pygame.K_9

    @property
    def K_COLON(self):
        """
        colon
        """
        return pygame.K_COLON

    @property
    def K_SEMICOLON(self):
        """
        semicolon
        """
        return pygame.K_SEMICOLON

    @property
    def K_LESS(self):
        """
        less-than sign
        """
        return pygame.K_LESS

    @property
    def K_EQUALS(self):
        """
        equals sign
        """
        return pygame.K_EQUALS

    @property
    def K_GREATER(self):
        """
        greater-than sign
        """
        return pygame.K_GREATER

    @property
    def K_QUESTION(self):
        """
        question mark
        """
        return pygame.K_QUESTION

    @property
    def K_AT(self):
        """
        at
        """
        return pygame.K_AT

    @property
    def K_LEFTBRACKET(self):
        """
        left bracket
        """
        return pygame.K_LEFTBRACKET

    @property
    def K_BACKSLASH(self):
        """
        backslash
        """
        return pygame.K_BACKSLASH

    @property
    def K_RIGHTBRACKET(self):
        """
        right bracket
        """
        return pygame.K_RIGHTBRACKET

    @property
    def K_CARET(self):
        """
        caret
        """
        return pygame.K_CARET

    @property
    def K_UNDERSCORE(self):
        """
        underscore
        """
        return pygame.K_UNDERSCORE

    @property
    def K_BACKQUOTE(self):
        """
        grave
        """
        return pygame.K_BACKQUOTE

    @property
    def K_a(self):
        """
        a
        """
        return pygame.K_a

    @property
    def K_b(self):
        """
        b
        """
        return pygame.K_b

    @property
    def K_c(self):
        """
        c
        """
        return pygame.K_c

    @property
    def K_d(self):
        """
        d
        """
        return pygame.K_d

    @property
    def K_e(self):
        """
        e
        """
        return pygame.K_e

    @property
    def K_f(self):
        """
        f
        """
        return pygame.K_f

    @property
    def K_g(self):
        """
        g
        """
        return pygame.K_g

    @property
    def K_h(self):
        """
        h
        """
        return pygame.K_h

    @property
    def K_i(self):
        """
        i
        """
        return pygame.K_i

    @property
    def K_j(self):
        """
        j
        """
        return pygame.K_j

    @property
    def K_k(self):
        """
        k
        """
        return pygame.K_k

    @property
    def K_l(self):
        """
        l
        """
        return pygame.K_l

    @property
    def K_m(self):
        """
        m
        """
        return pygame.K_m

    @property
    def K_n(self):
        """
        n
        """
        return pygame.K_n

    @property
    def K_o(self):
        """
        o
        """
        return pygame.K_o

    @property
    def K_p(self):
        """
        p
        """
        return pygame.K_p

    @property
    def K_q(self):
        """
        q
        """
        return pygame.K_q

    @property
    def K_r(self):
        """
        r
        """
        return pygame.K_r

    @property
    def K_s(self):
        """
        s
        """
        return pygame.K_s

    @property
    def K_t(self):
        """
        t
        """
        return pygame.K_t

    @property
    def K_u(self):
        """
        u
        """
        return pygame.K_u

    @property
    def K_v(self):
        """
        v
        """
        return pygame.K_v

    @property
    def K_w(self):
        """
        w
        """
        return pygame.K_w

    @property
    def K_x(self):
        """
        x
        """
        return pygame.K_x

    @property
    def K_y(self):
        """
        y
        """
        return pygame.K_y

    @property
    def K_z(self):
        """
        z
        """
        return pygame.K_z

    @property
    def K_DELETE(self):
        """
        delete
        """
        return pygame.K_DELETE

    @property
    def K_KP0(self):
        """
        keypad 0
        """
        return pygame.K_KP0

    @property
    def K_KP1(self):
        """
        keypad 1
        """
        return pygame.K_KP1

    @property
    def K_KP2(self):
        """
        keypad 2
        """
        return pygame.K_KP2

    @property
    def K_KP3(self):
        """
        keypad 3
        """
        return pygame.K_KP3

    @property
    def K_KP4(self):
        """
        keypad 4
        """
        return pygame.K_KP4

    @property
    def K_KP5(self):
        """
        keypad 5
        """
        return pygame.K_KP5

    @property
    def K_KP6(self):
        """
        keypad 6
        """
        return pygame.K_KP6

    @property
    def K_KP7(self):
        """
        keypad 7
        """
        return pygame.K_KP7

    @property
    def K_KP8(self):
        """
        keypad 8
        """
        return pygame.K_KP8

    @property
    def K_KP9(self):
        """
        keypad 9
        """
        return pygame.K_KP9

    @property
    def K_KP_PERIOD(self):
        """
        keypad period
        """
        return pygame.K_KP_PERIOD

    @property
    def K_KP_DIVIDE(self):
        """
        keypad divide
        """
        return pygame.K_KP_DIVIDE

    @property
    def K_KP_MULTIPLY(self):
        """
        keypad multiply
        """
        return pygame.K_KP_MULTIPLY

    @property
    def K_KP_MINUS(self):
        """
        keypad minus
        """
        return pygame.K_KP_MINUS

    @property
    def K_KP_PLUS(self):
        """
        keypad plus
        """
        return pygame.K_KP_PLUS

    @property
    def K_KP_ENTER(self):
        """
        keypad enter
        """
        return pygame.K_KP_ENTER

    @property
    def K_KP_EQUALS(self):
        """
        keypad equals
        """
        return pygame.K_KP_EQUALS

    @property
    def K_UP(self):
        """
        up arrow
        """
        return pygame.K_UP

    @property
    def K_DOWN(self):
        """
        down arrow
        """
        return pygame.K_DOWN

    @property
    def K_RIGHT(self):
        """
        right arrow
        """
        return pygame.K_RIGHT

    @property
    def K_LEFT(self):
        """
        left arrow
        """
        return pygame.K_LEFT

    @property
    def K_INSERT(self):
        """
        insert
        """
        return pygame.K_INSERT

    @property
    def K_HOME(self):
        """
        home
        """
        return pygame.K_HOME

    @property
    def K_END(self):
        """
        end
        """
        return pygame.K_END

    @property
    def K_PAGEUP(self):
        """
        page up
        """
        return pygame.K_PAGEUP

    @property
    def K_PAGEDOWN(self):
        """
        page down
        """
        return pygame.K_PAGEDOWN

    @property
    def K_F1(self):
        """
        F1
        """
        return pygame.K_F1

    @property
    def K_F2(self):
        """
        F2
        """
        return pygame.K_F2

    @property
    def K_F3(self):
        """
        F3
        """
        return pygame.K_F3

    @property
    def K_F4(self):
        """
        F4
        """
        return pygame.K_F4

    @property
    def K_F5(self):
        """
        F5
        """
        return pygame.K_F5

    @property
    def K_F6(self):
        """
        F6
        """
        return pygame.K_F6

    @property
    def K_F7(self):
        """
        F7
        """
        return pygame.K_F7

    @property
    def K_F8(self):
        """
        F8
        """
        return pygame.K_F8

    @property
    def K_F9(self):
        """
        F9
        """
        return pygame.K_F9

    @property
    def K_F10(self):
        """
        F10
        """
        return pygame.K_F10

    @property
    def K_F11(self):
        """
        F11
        """
        return pygame.K_F11

    @property
    def K_F12(self):
        """
        F12
        """
        return pygame.K_F12

    @property
    def K_F13(self):
        """
        F13
        """
        return pygame.K_F13

    @property
    def K_F14(self):
        """
        F14
        """
        return pygame.K_F14

    @property
    def K_F15(self):
        """
        F15
        """
        return pygame.K_F15

    @property
    def K_NUMLOCK(self):
        """
        numlock
        """
        return pygame.K_NUMLOCK

    @property
    def K_CAPSLOCK(self):
        """
        capslock
        """
        return pygame.K_CAPSLOCK

    @property
    def K_SCROLLOCK(self):
        """
        scrollock
        """
        return pygame.K_SCROLLOCK

    @property
    def K_RSHIFT(self):
        """
        right shift
        """
        return pygame.K_RSHIFT

    @property
    def K_LSHIFT(self):
        """
        left shift
        """
        return pygame.K_LSHIFT

    @property
    def K_RCTRL(self):
        """
        right control
        """
        return pygame.K_RCTRL

    @property
    def K_LCTRL(self):
        """
        left control
        """
        return pygame.K_LCTRL

    @property
    def K_RALT(self):
        """
        right alt
        """
        return pygame.K_RALT

    @property
    def K_LALT(self):
        """
        left alt
        """
        return pygame.K_LALT

    @property
    def K_RMETA(self):
        """
        right meta
        """
        return pygame.K_RMETA

    @property
    def K_LMETA(self):
        """
        left meta
        """
        return pygame.K_LMETA

    @property
    def K_LSUPER(self):
        """
        left Windows key
        """
        return pygame.K_LSUPER

    @property
    def K_RSUPER(self):
        """
        right Windows key
        """
        return pygame.K_RSUPER

    @property
    def K_MODE(self):
        """
        mode shift
        """
        return pygame.K_MODE

    @property
    def K_HELP(self):
        """
        help
        """
        return pygame.K_HELP

    @property
    def K_PRINT(self):
        """
        print screen
        """
        return pygame.K_PRINT

    @property
    def K_SYSREQ(self):
        """
        sysrq
        """
        return pygame.K_SYSREQ

    @property
    def K_BREAK(self):
        """
        break
        """
        return pygame.K_BREAK

    @property
    def K_MENU(self):
        """
        menu
        """
        return pygame.K_MENU

    @property
    def K_POWER(self):
        """
        power
        """
        return pygame.K_POWER

    @property
    def K_EURO(self):
        """
        Euro
        """
        return pygame.K_EURO


all_keys = [
    "K_BACKSPACE", "K_TAB", "K_CLEAR", "K_RETURN", "K_PAUSE", "K_ESCAPE",
    "K_SPACE", "K_EXCLAIM", "K_QUOTEDBL", "K_HASH", "K_DOLLAR", "K_AMPERSAND",
    "K_QUOTE", "K_LEFTPAREN", "K_RIGHTPAREN", "K_ASTERISK", "K_PLUS",
    "K_COMMA", "K_MINUS", "K_PERIOD", "K_SLASH", "K_0", "K_1", "K_2", "K_3",
    "K_4", "K_5", "K_6", "K_7", "K_8", "K_9", "K_COLON", "K_SEMICOLON",
    "K_LESS", "K_EQUALS", "K_GREATER", "K_QUESTION", "K_AT", "K_LEFTBRACKET",
    "K_BACKSLASH", "K_RIGHTBRACKET", "K_CARET", "K_UNDERSCORE", "K_BACKQUOTE",
    "K_a", "K_b", "K_c", "K_d", "K_e", "K_f", "K_g", "K_h", "K_i", "K_j",
    "K_k", "K_l", "K_m", "K_n", "K_o", "K_p", "K_q", "K_r", "K_s", "K_t",
    "K_u", "K_v", "K_w", "K_x", "K_y", "K_z", "K_DELETE", "K_KP0", "K_KP1",
    "K_KP2", "K_KP3", "K_KP4", "K_KP5", "K_KP6", "K_KP7", "K_KP8", "K_KP9",
    "K_KP_PERIOD", "K_KP_DIVIDE", "K_KP_MULTIPLY", "K_KP_MINUS", "K_KP_PLUS",
    "K_KP_ENTER", "K_KP_EQUALS", "K_UP", "K_DOWN", "K_RIGHT", "K_LEFT",
    "K_INSERT", "K_HOME", "K_END", "K_PAGEUP", "K_PAGEDOWN", "K_F1", "K_F2",
    "K_F3", "K_F4", "K_F5", "K_F6", "K_F7", "K_F8", "K_F9", "K_F10", "K_F11",
    "K_F12", "K_F13", "K_F14", "K_F15", "K_NUMLOCK", "K_CAPSLOCK",
    "K_SCROLLOCK", "K_RSHIFT", "K_LSHIFT", "K_RCTRL", "K_LCTRL", "K_RALT",
    "K_LALT", "K_RMETA", "K_LMETA", "K_LSUPER", "K_RSUPER", "K_MODE", "K_HELP",
    "K_PRINT", "K_SYSREQ", "K_BREAK", "K_MENU", "K_POWER", "K_EURO"
]

pygame_key_binding = [
    pygame.K_BACKSPACE, pygame.K_TAB, pygame.K_CLEAR, pygame.K_RETURN,
    pygame.K_PAUSE, pygame.K_ESCAPE, pygame.K_SPACE, pygame.K_EXCLAIM,
    pygame.K_QUOTEDBL, pygame.K_HASH, pygame.K_DOLLAR, pygame.K_AMPERSAND,
    pygame.K_QUOTE, pygame.K_LEFTPAREN, pygame.K_RIGHTPAREN, pygame.K_ASTERISK,
    pygame.K_PLUS, pygame.K_COMMA, pygame.K_MINUS, pygame.K_PERIOD,
    pygame.K_SLASH, pygame.K_0, pygame.K_1, pygame.K_2, pygame.K_3, pygame.K_4,
    pygame.K_5, pygame.K_6, pygame.K_7, pygame.K_8, pygame.K_9, pygame.K_COLON,
    pygame.K_SEMICOLON, pygame.K_LESS, pygame.K_EQUALS, pygame.K_GREATER,
    pygame.K_QUESTION, pygame.K_AT, pygame.K_LEFTBRACKET, pygame.K_BACKSLASH,
    pygame.K_RIGHTBRACKET, pygame.K_CARET, pygame.K_UNDERSCORE,
    pygame.K_BACKQUOTE, pygame.K_a, pygame.K_b, pygame.K_c, pygame.K_d,
    pygame.K_e, pygame.K_f, pygame.K_g, pygame.K_h, pygame.K_i, pygame.K_j,
    pygame.K_k, pygame.K_l, pygame.K_m, pygame.K_n, pygame.K_o, pygame.K_p,
    pygame.K_q, pygame.K_r, pygame.K_s, pygame.K_t, pygame.K_u, pygame.K_v,
    pygame.K_w, pygame.K_x, pygame.K_y, pygame.K_z, pygame.K_DELETE,
    pygame.K_KP0, pygame.K_KP1, pygame.K_KP2, pygame.K_KP3, pygame.K_KP4,
    pygame.K_KP5, pygame.K_KP6, pygame.K_KP7, pygame.K_KP8, pygame.K_KP9,
    pygame.K_KP_PERIOD, pygame.K_KP_DIVIDE, pygame.K_KP_MULTIPLY,
    pygame.K_KP_MINUS, pygame.K_KP_PLUS, pygame.K_KP_ENTER, pygame.K_KP_EQUALS,
    pygame.K_UP, pygame.K_DOWN, pygame.K_RIGHT, pygame.K_LEFT, pygame.K_INSERT,
    pygame.K_HOME, pygame.K_END, pygame.K_PAGEUP, pygame.K_PAGEDOWN,
    pygame.K_F1, pygame.K_F2, pygame.K_F3, pygame.K_F4, pygame.K_F5,
    pygame.K_F6, pygame.K_F7, pygame.K_F8, pygame.K_F9, pygame.K_F10,
    pygame.K_F11, pygame.K_F12, pygame.K_F13, pygame.K_F14, pygame.K_F15,
    pygame.K_NUMLOCK, pygame.K_CAPSLOCK, pygame.K_SCROLLOCK, pygame.K_RSHIFT,
    pygame.K_LSHIFT, pygame.K_RCTRL, pygame.K_LCTRL, pygame.K_RALT,
    pygame.K_LALT, pygame.K_RMETA, pygame.K_LMETA, pygame.K_LSUPER,
    pygame.K_RSUPER, pygame.K_MODE, pygame.K_HELP, pygame.K_PRINT,
    pygame.K_SYSREQ, pygame.K_BREAK, pygame.K_MENU, pygame.K_POWER,
    pygame.K_EURO
]
