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':
                pset(x,y,255,255,255)

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):
            x3 = x*3
            res3 = DISPLAY_RES_X*3
            render_buffer[2+x3+y*res3]=r
            render_buffer[3+x3+y*res3]=g
            render_buffer[4+x3+y*res3]=b

def pset(x,y,r,g,b):
    global render_buffer
    x3 = x*3
    res3 = DISPLAY_RES_X*3
    render_buffer[2+x3+y*res3]=r
    render_buffer[3+x3+y*res3]=g
    render_buffer[4+x3+y*res3]=b

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

def flush_render():
    global sock
    sock.sendto(render_buffer, (FLASZKI_UDP_IP, FLASZKI_UDP_PORT))

def close_sock():
    global sock
    sock.sendto(bytearray([HEADER_DRGB, HEADER_TIME_WAIT]), (FLASZKI_UDP_IP, FLASZKI_UDP_PORT))


def render_stub():
    render_thread("dupa")

    global render_buffer
    prepare_render_buffer(255,0,0)
    #clear_render_buffer(0,0,255)
    print_letter(letter_k)
    flush_render()
    time.sleep(3)
    close_sock()
    
    

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):
    print(block)
    for x in range(current_text_offset, current_text_offset+12):
        for y in range(0, 5):
            print(x,y)
            if block[x][y] == '1':
                pset(x-current_text_offset, y, 255,255,255)

def render_thread(name):
    global render_buffer
    global current_text_offset
    
    prepare_render_buffer(255,0,0)
    flush_render()
    text="  kupa  "
    print("we start sraning")
    block = prepare_text_block(text)
    
    isKupa = True
    while isKupa:
        clear_render_buffer(255,0,0)
        
        print_text(block)
        #print_letter(letter_k)
        
        flush_render()
        time.sleep(0.125)
        current_text_offset+=1
        if (current_text_offset >= get_string_pixel_length(text)-12):
            current_text_offset = 0