import gc
import random
import sys
from math import floor, ceil


if not hasattr(sys, "_called_from_test"):
    from .settings import KEYS
    from .rotated_list import forward, backward
    import display
else:
    from settings import KEYS
    from rotated_list import forward, backward

# ttb, rtl, btt  -> left to right, top to bottom, right to left. perhaps later diagonal.
DIRECTION_LTR = 0
DIRECTION_RTL = 1
DIRECTION_TTB = 2
DIRECTION_BTT = 3

RED = 0xFF0000
GREEN = 0x00FF00
BLUE = 0x0000FF
WHITE = 0xFFFFFF
BLACK = 0x000000

width = height = [0, 1, 2, 3]

state = {
    "frame": 0,
    "current_animation": None,
    "sweep": {"position": 0, "direction": DIRECTION_LTR, "limit_frames": 2},
    "flash": {"limit_frames": 8},
    "debug": {"limit_frames": 100, "limit_subframes": 10},
    "angle": {"direction": 0},
    "shapes": {"limit_frames": 5}
}

# can only write the the first level of a dictionary.
# sounds crazy, but it seems to be the case.
smooth_color_transition_directions = {"r": 1, "g": 1, "b": 1}
sweep_current_color = {'color': WHITE}

opposites = {3: 0, 2: 1, 1: 2, 0: 3}

happy_colors = [0xFF6E6E, 0xFFA36E, 0xFFC06E, 0x59FFAC, 0x59A9FF, 0x8E59FF, 0xF530FF]

# This is the first color of the display, and it will be continuously adjusted.
smooth_transition_current_color = {'color': 0xFF6E6E}
state["current_animation"] = default_animation = "smooth_color_transition"


def darken_color_part(hex_color, color_name):
    bits = 16 if color_name == "r" else 8 if color_name == "g" else 0
    current_color = hex_color >> bits & 0b11111111
    new_color = ceil(current_color * 0.9)
    # don't go completely dark, so the hex value still has something to <<
    return 17 if new_color < 1 else new_color


def lighten_color_part(hex_color, color_name):
    bits = 16 if color_name == "r" else 8 if color_name == "g" else 0
    current_color = hex_color >> bits & 0b11111111
    new_color = ceil(current_color * 1.1)
    # don't go completely dark, so the hex value still has something to <<
    return 255 if new_color > 255 else new_color


def make_new_color_part(hex_color, color_name: str):
    global smooth_color_transition_directions

    bits = 16 if color_name == "r" else 8 if color_name == "g" else 0
    # https://stackoverflow.com/questions/45220959/python-how-do-i-extract-specific-bits-from-a-byte
    current_color = hex_color >> bits & 0b11111111

    # 255 == max
    if current_color > 249:
        smooth_color_transition_directions[color_name] = 0

    # don't make it too dark
    if current_color < 100:
        smooth_color_transition_directions[color_name] = 1

    return (
        current_color + random.randint(0, 2)
        if smooth_color_transition_directions[color_name]
        else current_color - random.randint(0, 2)
    )


def smooth_transition_color(hex_color):
    """
    # slowly adjust the color based on random values. This will slowly change the color of the display.
    # the base color can be changed by hitting a button. How can we do some bit magic that changes one
    # of the colors slightly? This can be done per pixel even, which is nicer. But let's start with one color and
    # fading.

    # Colors are always represented in 24-bit from within Python, in the 0xRRGGBB format.
    # This matches HTML/CSS colors which are #RRGGBB as well. 6 bits.

    :param hex_color:
    :return:
    """

    return (
        make_new_color_part(hex_color, "r") << 16
        | make_new_color_part(hex_color, "g") << 8
        | make_new_color_part(hex_color, "b")
    )


def darken_color(hex_color):
    darker = (
        darken_color_part(hex_color, "r") << 16
        | darken_color_part(hex_color, "g") << 8
        | darken_color_part(hex_color, "b")
    )
    return darker


def lighten_color(hex_color):
    lighter = (
        lighten_color_part(hex_color, "r") << 16
        | lighten_color_part(hex_color, "g") << 8
        | lighten_color_part(hex_color, "b")
    )
    return lighter


def get_random_color():
    global happy_colors
    return happy_colors[random.randint(0, len(happy_colors) - 1)]


def full_sceen_feedback():
    global state, smooth_transition_current_color

    new_color = get_random_color()
    # x, y, width, height, filled, color
    display.drawFill(new_color)

    # as an extra, alter the smooth color transition, so during this animation the animation
    # continues from this random color, which looks more cool
    smooth_transition_current_color['color'] = new_color


def bootscreen():
    display.drawFill(WHITE)
    display.flush()


def animation_wifi_searching():
    # waiting for wifi is a thing. The 'wifi' samples are probably not available. So visualize without deps.

    # draw wifi signal thingy, the top left corner is a status color, that changes color every connection attempt.
    display.drawFill(WHITE)

    display.drawPixel(0, 2, 0x333333)
    display.drawPixel(1, 1, 0x333333)
    display.drawPixel(2, 1, 0x333333)
    display.drawPixel(3, 2, 0x333333)

    display.flush()


def animation_wifi_searching_progress():
    # used as a progress bar indicator, also helps with feedback when crashing during (WIFI) setup.
    display.drawPixel(0, 0, get_random_color())
    display.flush()


def draw_buttons():
    # previous and next buttons for music and animations,

    lighten_button(KEYS["previous_track"])
    darken_button(KEYS["previous_animation"])
    darken_button(KEYS["next_animation"])
    lighten_button(KEYS["next_track"])


def key_to_xy(key_number):
    return key_number % 4, floor(key_number / 4)


def lighten_button(key_number):
    x, y = key_to_xy(key_number)
    display.drawPixel(x, y, lighten_color(swap_rb(display.getPixel(x, y))))


def darken_button(key_number):
    x, y = key_to_xy(key_number)
    display.drawPixel(x, y, darken_color(swap_rb(display.getPixel(x, y))))


def sweep_frame():
    global state, opposites, sweep_current_color
    """
    Draws a line in a random direction: left to right, up to down etc.
    Together with fade_out this will create an interesting loading effect.

    todo: i can just reorient the frame buffer... which is much easier. But this will not allow 
    two animations at the same time in different directions. So no. Or then again re-pan?

    :return: 
    """
    angles = {
        DIRECTION_LTR: 0,
        DIRECTION_RTL: 180,
        DIRECTION_TTB: 90,
        DIRECTION_BTT: 270,
    }

    display.orientation(angles[state["sweep"]["direction"]])
    display.drawLine(state["sweep"]["position"], 0, state["sweep"]["position"], 3, sweep_current_color['color'])
    display.orientation(-angles[state["sweep"]["direction"]])

    # prepare for the next sweep animation step
    # It turns out, that for whatever reason, you can't write to global integer directly, but you can to a dict.
    if state["sweep"]["position"] > 2:
        state["sweep"]["position"] = 0
        # next sweep direction
        state["sweep"]["direction"] = random.choice(
            [DIRECTION_LTR, DIRECTION_TTB, DIRECTION_RTL, DIRECTION_BTT]
        )
        # next sweep color:
        sweep_current_color['color'] = get_random_color()
    else:
        state["sweep"]["position"] += 1


def get_frame():
    frame = []

    for x in width:
        for y in height:
            frame += [display.getPixel(x, y)]

    return frame


matrix_drops = []
matrix_blinks = []


def animate_matrix():
    # Creates a path and walks through it.
    global state, matrix_drops, matrix_blinks

    # animate drops
    new_drops = []
    for drop in matrix_drops:
        x, y = drop
        # disappearing drop
        if y == 4:
            continue
        if y < 3:
            display.drawPixel(x, y + 1, GREEN)
            new_drops.append((x, y + 1))
    matrix_drops = new_drops

    # add new drops:
    if random.randint(0, 10) < 5:
        matrix_drops.append([random.randint(0, 3), random.randint(-1, 2)])

    # animate blinks
    new_blinks = []
    for blink in matrix_blinks:
        x, y = blink
        if random.randint(0, 100) > 90:
            # blink disappears
            continue
        display.drawPixel(x, y, GREEN)
        if random.randint(0, 100) > 90:
            # blink disappears
            display.drawPixel(x, y, darken_color(GREEN))
        if random.randint(0, 100) > 90:
            # blink disappears
            display.drawPixel(x, y, lighten_color(GREEN))
        new_blinks.append((x, y))
    matrix_blinks = new_blinks

    if random.randint(0, 10) < 4:
        matrix_blinks.append([random.randint(0, 3), random.randint(0, 3)])

    fade_out_entire_display()


def animate_shapes():
    shapes = [
        # dash
        [1, 0, 0, 1,
         0, 1, 0, 0,
         0, 0, 1, 0,
         1, 0, 0, 1],
        # circle
        [0, 1, 1, 0,
         1, 0, 0, 1,
         1, 0, 0, 1,
         0, 1, 1, 0],
        # 4x line
        [0, 1, 0, 1,
         1, 1, 1, 1,
         0, 1, 0, 1,
         1, 1, 1, 1],
        # sideways line
        [0, 1, 0, 0,
         1, 0, 1, 0,
         0, 1, 0, 1,
         0, 0, 1, 0],
        # checkerboard
        [1, 0, 1, 0,
         0, 1, 0, 1,
         1, 0, 1, 0,
         0, 1, 0, 1],
        # arrow
        [0, 0, 0, 0,
         0, 1, 1, 0,
         1, 0, 0, 1,
         0, 0, 0, 0],
        # big line
        [0, 0, 0, 0,
         1, 1, 1, 1,
         1, 1, 1, 1,
         0, 0, 0, 0],
        # small circle
        [0, 1, 1, 1,
         0, 1, 0, 1,
         0, 1, 1, 1,
         0, 0, 0, 0],
        # large circle
        [1, 1, 1, 1,
         1, 0, 0, 1,
         1, 0, 0, 1,
         1, 1, 1, 1],
        # side bar
        [1, 1, 1, 1,
         1, 1, 1, 1,
         0, 0, 0, 0,
         0, 0, 0, 0],
        # blinds
        [1, 1, 1, 1,
         0, 0, 0, 0,
         1, 1, 1, 1,
         0, 0, 0, 0],
    ]

    # randomize direction, color and inversion
    orientation = random.choice([0, 90, 180, 270])
    shape = random.choice(shapes)
    inverse = random.choice([0, 1])
    color = get_random_color()

    if inverse:
        shape = [0x000000 if thing else color for thing in shape]
    else:
        shape = [color if thing else 0x000000 for thing in shape]

    if state["frame"] % state["shapes"]["limit_frames"] == 0:
        display.orientation(orientation)
        for i in range(0, 16):
            display.drawPixel(i // 4, i % 4, shape[i])
        display.orientation(-orientation)
    else:
        fade_out_entire_display()


def fade_out_entire_display():
    """
    Fades the entire screen with one step. This is used to create ghosting effects.

    Reads all pixels, and writes them with a darker variant. Probably also possible with a single mask
    operation... but oh welll..

    :return:
    """

    # makes it looks like the fading comes from the center, which is smoother
    for x in [1, 2, 3, 0]:
        for y in [1, 2, 3, 0]:
            display.drawPixel(x, y, swap_rb(darken_color(display.getPixel(x, y))))


def animate_sweep():
    if state["frame"] % state["sweep"]["limit_frames"] == 0:
        sweep_frame()
        fade_out_entire_display()


def animate_smooth_color_transition():  # noqa not using time because it's not needed. Provided for when you do.
    global smooth_transition_current_color
    smooth_transition_current_color['color'] = smooth_transition_color(
        smooth_transition_current_color['color']
    )
    display.drawFill(smooth_transition_current_color['color'])


def animate_sparkle():
    # a random pixel somewhere, which fades out.
    display.drawPixel(
        random.choice([0, 1, 2, 3]), random.choice([0, 1, 2, 3]), get_random_color()
    )
    fade_out_entire_display()


def animate_amateurstrobe():
    frames = {
        0: BLACK,
        1: WHITE,
    }

    display.drawFill(frames[state["frame"] % len(frames)])


def animate_professionalstrobe():
    frames = {
        0: RED,
        1: GREEN,
        2: BLUE,
    }

    display.drawFill(frames[state["frame"] % len(frames)])


def animate_chadstrobe():
    # only for chads

    frames = {
        0: WHITE,
        1: BLACK,
        2: RED,
        3: BLACK,
        4: WHITE,
        5: BLACK,
        6: GREEN,
        7: BLACK,
        8: WHITE,
        9: BLACK,
        10: BLUE,
        11: BLACK
    }

    display.drawFill(frames[state["frame"] % len(frames)])


def swap_rb(hex_color):
    """
    Swap R and B color, as an attempt to see if it's possible to work with the badget display code instead of
    my own python library (which is ofc much slower). Of course this is also a slow routine...

    :param hex_color:
    :return:
    """
    r = hex_color >> 16 & 0b11111111
    g = hex_color >> 8 & 0b11111111
    b = hex_color >> 0 & 0b11111111

    return b << 16 | g << 8 | r


def animate_debug():
    # fill the entire screen, which fades out, every 5 frames
    # the getPixel retrieves a sampled down value, and then writes that again, this causes colors to get lost.
    global state

    if state["frame"] % state["debug"]["limit_frames"] == 0:
        new_color = get_random_color()
        display.drawFill(new_color)
        print("New color: " + bin(new_color))

    if state["frame"] % state["debug"]["limit_subframes"] == 0:
        # Because getpixel does not return the value that has been drawn
        # the screen will do crazy stuff when writing the current value to it
        read = display.getPixel(0, 0)
        read = swap_rb(read)
        display.drawFill(read)
        print("The display is now: " + bin(read))


animations = {
    "smooth_color_transition": animate_smooth_color_transition,
    "swipe": animate_sweep,
    "sparkle": animate_sparkle,
    "matrix": animate_matrix,
    "shapes": animate_shapes,
    "debug": animate_debug,
    "amateur_strobe": animate_amateurstrobe,
    "professional_strobe": animate_professionalstrobe,
    "chad_strobe": animate_chadstrobe,
}

available_animations = ['smooth_color_transition', "shapes", 'swipe', 'sparkle','matrix',
                        'amateur_strobe', 'professional_strobe', 'chad_strobe']  # dict.keys() didn't work...


def get_previous_animation():
    global available_animations, state
    return backward(available_animations, state["current_animation"])


def get_next_animation():
    global available_animations, state
    return forward(available_animations, state["current_animation"])


def set_animation(animation_name):
    global state
    print("Setting animation to: " + animation_name)
    state["current_animation"] = animation_name


def progress_animation(
    mytimer,
):  # noqa not using time because it's not needed. Provided for when you do.
    """
    This is called with a timer, each call is a frame.

    :param mytimer:
    :return:
    """
    global animations, state

    # make sure it doesn't 'overflow'
    state["frame"] += 1

    if state["frame"] > 10000:
        state["frame"] = 0

    animation_frame = animations[state["current_animation"]]
    animation_frame()

    # possibly that the memory gets filled with above animation calling. make sure to clear some memory
    # otherwise the player will crash after a minute or so... This will impact the framerate a bit, but that's
    # better than a hard crash :)
    del animation_frame
    if state["frame"] % 100 == 0:
        show_memory_usage()
    gc.collect()

    draw_buttons()
    display.flush()


# the badge hangs when animations are used, probably because of memory issues
# it's probably leaking a lot
def show_memory_usage():
    # https://forum.micropython.org/viewtopic.php?t=3499
    import gc
    import os

    def df():
        s = os.statvfs('//')
        return '{0} MB'.format((s[0] * s[3]) / 1048576)

    def free():
        F = gc.mem_free()
        A = gc.mem_alloc()
        T = F + A
        P = '{0:.2f}%'.format(F / T * 100)
        return 'Total:{0} Free:{1} ({2})'.format(T, F, P)

    print(df())
    print(free())