import neopixel
from machine import Pin
import time
from random import randint, random, seed, choice

seed()

ws_pin = 0
led_zahl = 64
helligkeit = 0.05

matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)

taster_hoch = Pin(1, Pin.IN, Pin.PULL_UP)
taster_runter = Pin(2, Pin.IN, Pin.PULL_UP)
taster_rechts = Pin(3, Pin.IN, Pin.PULL_UP)
taster_links = Pin(4, Pin.IN, Pin.PULL_UP)

scalar = float # a scale value (0.0 to 1.0)
def hsv2rgb(h:scalar, s:scalar, v:scalar) -> tuple:
    if s:
        if h == 1.0: h = 0.0
        i = int(h*6.0); f = h*6.0 - i
        
        w = int(255*( v * (1.0 - s) ))
        q = int(255*( v * (1.0 - s * f) ))
        t = int(255*( v * (1.0 - s * (1.0 - f)) ))
        v = int(255*v)
        
        if i==0: return (v, t, w)
        if i==1: return (q, v, w)
        if i==2: return (w, v, t)
        if i==3: return (w, q, v)
        if i==4: return (t, w, v)
        if i==5: return (v, w, q)
    else: v = int(255*v); return (v, v, v)

def zufall_farbe():
    return hsv2rgb(random(), 1.0, 1.0)

def setze_helligkeit(farbe):
    r, g, b = farbe
    r = int(r * helligkeit)
    g = int(g * helligkeit)
    b = int(b * helligkeit)
    return (r, g, b)

def setze_pixel(x, y, farbe):
    farbe = setze_helligkeit(farbe)
    i = y * 8 + x
    matrix[i] = farbe

def neue_richtung():
    if not taster_runter.value():
        return "runter"
    if not taster_rechts.value():
        return "rechts"
    if not taster_links.value():
        return "links"
    if not taster_hoch.value(): 
        return "hoch"

RICHTUNGEN = {
    "hoch": (0, -1),
    "runter": (0, 1),
    "links": (-1, 0),
    "rechts": (1, 0)
}

def anzeigen(snake, essen):
    matrix.fill((0, 0, 0))

    # Snake anzeigen
    length = len(snake)
    for i, (x, y) in enumerate(snake):
        hue = (i / length) % 1.0  # Spread hue over the snake's body
        color = hsv2rgb(hue, 1.0, 1.0)
        setze_pixel(x, y, color)

    # Essen anzeigen
    fx, fy = essen
    setze_pixel(fx, fy, zufall_farbe())

    matrix.write()

def neues_essen(snake):
    leere_felder = [(x, y) for x in range(8) for y in range(8) if (x, y) not in snake]
    return choice(leere_felder)

def draw_x_pattern(color):
    for i in range(8):
        setze_pixel(i, i, color)
        setze_pixel(i, 7 - i, color)
    matrix.write()

DIGIT_PATTERNS = {
    '0': ["###",
          "# #",
          "# #",
          "# #",
          "###"],
    '1': ["  #",
          "  #",
          "  #",
          "  #",
          "  #"],
    '2': ["###",
          "  #",
          "###",
          "#  ",
          "###"],
    '3': ["###",
          "  #",
          "###",
          "  #",
          "###"],
    '4': ["# #",
          "# #",
          "###",
          "  #",
          "  #"],
    '5': ["###",
          "#  ",
          "###",
          "  #",
          "###"],
    '6': ["###",
          "#  ",
          "###",
          "# #",
          "###"],
    '7': ["###",
          "  #",
          "  #",
          "  #",
          "  #"],
    '8': ["###",
          "# #",
          "###",
          "# #",
          "###"],
    '9': ["###",
          "# #",
          "###",
          "  #",
          "###"]
}

def draw_digit(digit, x_offset, y_offset, color):
    pattern = DIGIT_PATTERNS.get(str(digit), ["   "]*5)
    for y, row in enumerate(pattern):
        for x, char in enumerate(row):
            if char == '#':
                px = x + x_offset
                py = y + y_offset
                if 0 <= px < 8 and 0 <= py < 8:
                    setze_pixel(px, py, color)

def game_over(score):
    red = (255, 0, 0)
    black = (0, 0, 0)

    # Flash X pattern
    matrix.fill(black)
    flashes = 3
    for _ in range(flashes):
        draw_x_pattern(red)
        time.sleep(0.3)
        draw_x_pattern(black)
        time.sleep(0.2)

    # Fade out the X
    steps = 10
    for i in range(steps, -1, -1):
        fade_color = (int(255 * i / steps), 0, 0)
        draw_x_pattern(fade_color)
        time.sleep(0.05)
    matrix.fill(black)
    matrix.write()

    digits = f"{score:02}"

    # Draw the two digits centered (3x5 font with 1 column space)
    matrix.fill(black)
    draw_digit(digits[0], 0, 1, red)
    draw_digit(digits[1], 5, 1, red)
    matrix.write()
    time.sleep(1.5)

    matrix.fill(black)
    matrix.write()

def spiel():
    snake = [(4, 4)]
    richtung = "rechts"
    essen = neues_essen(snake)

    while True:
        naechste_richtung = neue_richtung()

        if naechste_richtung in RICHTUNGEN:
            richtung = naechste_richtung

        dx, dy = RICHTUNGEN[richtung]
        head_x, head_y = snake[0]
        neuer_kopf = (head_x + dx, head_y + dy)

        if (neuer_kopf in snake or
            not (0 <= neuer_kopf[0] < 8 and 0 <= neuer_kopf[1] < 8)):
            game_over(len(snake) - 1)
            break

        snake.insert(0, neuer_kopf)

        if neuer_kopf == essen:
            essen = neues_essen(snake)
        else:
            snake.pop()

        anzeigen(snake, essen)
        time.sleep(0.4)

while True:
    spiel()
    time.sleep(1)