import jarray
import math
import itertools

_byte_lookup = {}
brightness_max = 0.5

# Bit values which represent the zero and one bit pulses.
_ZERO = bytearray([0b00000000])
_ONE = bytearray([0b11111111])

def _build_byte_lookup():
    """Return lookup table to map from every byte value 0-255 and the associated raw SPI data."""
    lookup = {}
    for i in range(256):
        value = bytearray()
        for j in range(7, -1, -1):
            if ((i >> j) & 1) == 0:
                value += _ZERO
            else:
                value += _ONE
        lookup[i] = value
    return lookup

def color_to_rgb(c):
    """Convert a 24 bit color to RGB triplets."""
    return ((c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF)

def _encode_color_grb(c):
    """Encode an RGB tuple into NeoPixel GRB 24 byte SPI bit stream."""
    return _byte_lookup[int(c[1] * brightness)] + _byte_lookup[int(c[0] * brightness)] + _byte_lookup[int(c[2] * brightness)]

def _encode_pixel(c):
    """Encode an RGB tuple into NeoPixel GRB 24 byte SPI bit stream."""
    rgb = color_to_rgb(c)
    encoded = _encode_color_grb(rgb)
    return encoded

def prepare_data(dimension, b):
    global brightness
    global _byte_lookup
    if b > brightness_max:
        brightness = brightness_max
    else:
        brightness = b
    _byte_lookup = _build_byte_lookup()
    data = jarray.zeros(dimension * 24 + 1, "b")
    return data

'''
Possibilities:
    Start: Top left / Top Right / Bottom Left / Bottom Right
    Direction: Up / Down / Right / Left
'''


def make_line(type, nb, long_line):
    '''
    If moving up or down: 0 <= nb < height
    If moving right or left: 0 <= nb < width
    '''
    indexes = []
    if type == 0:
        # top left -> down / OK
        pxstart = nb
        for h in range(height):
            indexes.append(pxstart + width * h)
    elif type == 1:
        # top left -> right / OK
        pxstart = nb * width
        for w in range(width):
            indexes.append(pxstart + w)
    elif type == 2:
        # bottom left -> up / OK
        pxstart = width * (height - 1) + nb
        for h in range(height):
            indexes.append(pxstart - width * h)
    elif type == 3:
        # bottom left -> right / OK
        pxstart = width * (height - 1) - nb * width
        for w in range(width):
            indexes.append(pxstart + w)
    elif type == 4:
        # top right -> down / OK
        pxstart = width - 1 - nb
        for h in range(height):
            indexes.append(pxstart + width * h)
    elif type == 5:
        # top right -> left / OK
        pxstart = width - 1 + nb * width
        for w in range(width):
            indexes.append(pxstart - w)
    elif type == 6:
        # bottom right -> up / OK
        pxstart = width * height - 1 - nb * height
        for h in range(height):
            indexes.append(pxstart - width * h)
    elif type == 7:
        # bottom right -> left / OK
        pxstart = width * height - 1 - nb * width
        for w in range(width):
            indexes.append(pxstart - w)
    else:
        raise Exception("Invalid Type")

    if long_line and nb % 2 == 1:
        return reversed([pixels[px] for px in indexes])
    return [pixels[px] for px in indexes]


def image2data(data, type, long_line):
    offset = 0
    loadPixels()
    inline_image = []
    if type in [0, 2, 4, 6]:
        # Organized up or down
        for x in range(0, width):
            inline_image += make_line(type, x, long_line)
    elif type in [1, 3, 5, 7]:
        # Organized left or right
        for x in range(0, height):
            inline_image += make_line(type, x, long_line)
    for img_px in inline_image:
        py_bytes = _encode_pixel(img_px)
        for b in py_bytes:
            if b > 127:
                # Convert to signed bytes (expected by jarray)
                b -= 256
                data[offset] = b
            else:
                data[offset] = b
            offset += 1
    # New line
    data[-1] = 10
    return data