import socket
import time

from matelightfont import *


FLASZKI_UDP_IP = "10.8.0.196"
FLASZKI_UDP_PORT = 65506

HEADER_DRGB = 2
HEADER_TIME_INFINITE = 255
HEADER_TIME_WAIT = 0

DISPLAY_RES_X = 12
DISPLAY_RES_Y = 10


current_text_offset=0

def get_char_pixel_length(ch):
    l = {
        'k': letter_k[0],
        'u': letter_u[0],
        'p': letter_p[0],
        'a': letter_a[0],
        ' ': letter_space[0]
    }.get(ch, 0)
    return l + 1

def get_char_pixel_bitmap(ch):
    l = {
        'k': letter_k[1],
        'u': letter_u[1],
        'p': letter_p[1],
        'a': letter_a[1],
        ' ': letter_space[1]
    }.get(ch, ["0000","0000","0000","0000","0000"])
    return l

def get_string_pixel_length(st):
    l=0
    for c in st:
        l += get_char_pixel_length(c)

    return l

def print_letter(ch):
    white=(255,255,255)
    for x in range(0,ch[0]):
        for y in range(0,5):
            if ch[1][y][x]=='1':
                ft.set(x,y,white)

def print_letter_debug(ch):
    print("Debug letter print")    

def render_thread_debug(name):
    print("Debug render thread")

render_buffer = bytearray(0)

def prepare_render_buffer(r,g,b):
    global render_buffer
    render_buffer = bytearray([HEADER_DRGB,HEADER_TIME_INFINITE])
    for y in range(DISPLAY_RES_Y):
        for x in range(DISPLAY_RES_X):
            render_buffer.append(r)
            render_buffer.append(g)
            render_buffer.append(b)

def clear_render_buffeR(r,g,b):
    global render_buffer
    for y in range(DISPLAY_RES_Y):
        for x in range(DISPLAY_RES_X):
            render_buffer[2+x+y*x]=r
            render_buffer[3+x+y*x]=g
            render_buffer[4+x+y*x]=b


def render_stub():
    global render_buffer
    prepare_render_buffer(255,0,0)
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.sendto(render_buffer, (FLASZKI_UDP_IP, FLASZKI_UDP_PORT))
    time.sleep(3)
    sock.sendto(bytearray([HEADER_DRGB,HEADER_TIME_WAIT]), (FLASZKI_UDP_IP, FLASZKI_UDP_PORT))



def get_text_vline(st, i):
    done=False
    letter=0
    offset=0
    previous_offset = 0
    if i >= get_string_pixel_length(st):
        return['0','0','0','0','0']
    while not done:
        offset +=get_char_pixel_length(st[letter])
        if i < offset-1:

            done=True
            vline = [get_char_pixel_bitmap(st[letter])[0][i-previous_offset],get_char_pixel_bitmap(st[letter])[1][i-previous_offset],get_char_pixel_bitmap(st[letter])[2][i-previous_offset],get_char_pixel_bitmap(st[letter])[3][i-previous_offset], get_char_pixel_bitmap(st[letter])[4][i-previous_offset]]
            return vline
        elif i == offset-1:
            
            vline = ['0','0','0','0','0']
            done=True
        else:
            
            letter += 1
            previous_offset = offset
    return vline

def prepare_text_block(st):
    l=get_string_pixel_length(st)
    #l+=8 # add full clear screen for text rotation
    block=[]
    i=0
    for vline in range(0,l):
        block.append(get_text_vline(st, i))
        i+=1

    return block


def print_text(block):
    for x in range(current_text_offset, current_text_offset+8):
        for y in range(0, ft.height):
            if block[x][y] == '1':
                ft.set(x-current_text_offset, y, (255,255,255))

def render_thread(name):
    global current_text_offset
    text="  kupa  "
    print("we start sraning")
    block = prepare_text_block(text)
    while isKupa:
        for y in range(0, ft.height):
            for x in range(0, ft.width):
                ft.set(x, y, (255, 0, 255))
        #print_text(block)
        print_letter(letter_k)
        #ft.send()
        time.sleep(0.125)
        current_text_offset+=1
        if (current_text_offset >= get_string_pixel_length(text)-8):
            current_text_offset = 0