from neopixel import Neopixel
import utime
from machine import Pin, Timer
import _thread



####################TO DO´s##########################
# 1. Multithread für trennung von blinker und animation 
# 2. buttoninterrupt für längere animationen (rainbow/police)
#   - https://www.elektronik-kompendium.de/sites/raspberry-pi/2612181.htm
# 3. animation Police optimieren
#
#
#
#
#
########################################################

numpix = 20
segment = 4
delay = 0.15
brightness = 100
anzahl_animationen = 5

#setup
strip_blinker = Neopixel(numpix, 0, 28, "RGB")
strip_animation = Neopixel(numpix, 0, 28, "RGB")
strip_animation.brightness(brightness)
strip_blinker.brightness(brightness)
button = Pin(18, Pin.IN, Pin.PULL_UP)
toggle_switch_left = Pin(15, Pin.IN, Pin.PULL_DOWN)
toggle_switch_right = Pin(14, Pin.IN, Pin.PULL_DOWN)

blinker_links = False
blinker_rechts = False

animation_NR = 0
# Define the debounce timer
debounce_timer = Timer()

# Flag to indicate if the button is being debounced
debouncing = False

reset_animation = False


#Farben definnieren
blank = (0, 0, 0)
white = (255, 255, 255)

red = (0, 255, 0)
orange = (127, 255, 0)
yellow = (255, 255, 0)
lime = (255, 127, 0)
green = (255, 0, 0)
teal = (255, 0, 127)
cyan = (255, 0, 255)
sky_blue = (127, 0, 255)
blue = (0, 0, 255)
indigo = (0, 127, 255)
magenta = (0, 255, 255)
pink = (0, 255, 127)

colors = [red, orange, yellow, lime, green, teal, cyan, sky_blue, blue, indigo, magenta, pink]


############ Blinker Links ###################
def blink_links():
    global blinker_links
    while True:
        if blinker_links == False:
            break
        strip_blinker.show()

        for x in reversed(range(segment)):
            if blinker_links == False:
                break
            strip_blinker.set_pixel(x, yellow)
            strip_blinker.show()
            utime.sleep(delay)
        
        if blinker_links == False:
            break
        utime.sleep(2 * delay)
        for y in range(segment):
            strip_blinker.set_pixel(y, blank)
            strip_blinker.show()

    for y in range(segment):
        strip_blinker.set_pixel(y, blank)
        strip_blinker.show()
    return

##################################################


############ Blinker Rechts ##################
def blink_rechts():
    global blinker_rechts
    startpoint = numpix - segment
    while True:
        if blinker_rechts == False:
                break

        strip_blinker.show()
        for x in range(segment):
            if blinker_rechts == False:
                break
            strip_blinker.set_pixel(startpoint + x, yellow)
            strip_blinker.show()
            utime.sleep(delay)
        if blinker_rechts == False:
            break
        utime.sleep(2 * delay)
        for y in range(segment):
            strip_blinker.set_pixel(startpoint + y, blank)
            strip_blinker.show()

    for y in range(segment):
            strip_blinker.set_pixel(startpoint + y, blank)
            strip_blinker.show()    
    return


##################################################

# ----------------Animationen------------------#

############ 0.Animation Licht aus ################
def licht_aus():
    global reset_animation
    for i in range(numpix - segment):
        if i >= segment:
            strip_animation.set_pixel(i, blank)
            strip_animation.show()
    while reset_animation == False:
        utime.sleep(delay)


############### 1.Animation Licht an ###############
def fernlicht_an():
    global reset_animation
    for i in range(numpix - segment):
        if i >= segment:
            strip_animation.set_pixel(i, white)
            strip_animation.show()
    while reset_animation == False:
        utime.sleep(delay)
    licht_aus()


############### 2.Animation Rainbow ###############
def rainbow():
    global reset_animation
    for i in range(len(colors)):
        for j in range(numpix - segment):
            if j >= segment:
                strip_animation.set_pixel(j, colors[i])
                strip_animation.show()
                utime.sleep(delay)
                if reset_animation == True:
                    licht_aus()
                    return


############### 3.Animation Police ###############
def police():
    global reset_animation

    strip_animation.set_pixel(4, blue)
    strip_animation.set_pixel(5, blue)
    strip_animation.set_pixel(6, blue)

    strip_animation.set_pixel(7, red)
    strip_animation.set_pixel(8, red)
    strip_animation.set_pixel(9, red)

    strip_animation.set_pixel(10, blue)
    strip_animation.set_pixel(11, blue)
    strip_animation.set_pixel(12, blue)

    strip_animation.set_pixel(13, red)
    strip_animation.set_pixel(14, red)
    strip_animation.set_pixel(15, red)
    strip_animation.show()

    utime.sleep(delay * 2)
    if reset_animation == True:
        licht_aus()
        return
    
    strip_animation.set_pixel(4, red)
    strip_animation.set_pixel(5, red)
    strip_animation.set_pixel(6, red)

    strip_animation.set_pixel(7, blue)
    strip_animation.set_pixel(8, blue)
    strip_animation.set_pixel(9, blue)

    strip_animation.set_pixel(10, red)
    strip_animation.set_pixel(11, red)
    strip_animation.set_pixel(12, red)

    strip_animation.set_pixel(13, blue)
    strip_animation.set_pixel(14, blue)
    strip_animation.set_pixel(15, blue)
    strip_animation.show()

    utime.sleep(delay * 2)


###############  4.Animation Kit   ###############
def kit():
    global reset_animation
    delay = 0.01

    strip_animation.show()
    ############### Left to Right ###############
    for x in range(numpix - segment - 2):
        if x >= segment:
            strip_animation.set_pixel(x + 1, red)
            utime.sleep(delay)
            strip_animation.show()
            strip_animation.set_pixel(x, red)
            utime.sleep(delay)
            strip_animation.show()
            strip_animation.set_pixel(x + 2, red)
            utime.sleep(delay)
            strip_animation.show()
            strip_animation.set_pixel(x, blank)
            utime.sleep(delay)
            strip_animation.set_pixel(x + 1, blank)
            utime.sleep(delay)
            strip_animation.set_pixel(x + 2, blank)
            strip_animation.show()
        if reset_animation == True:
            licht_aus()
            return

    ############### Left to Right ###############
    for x in reversed(range(numpix - segment - 2)):
        if x > segment:
            strip_animation.set_pixel(x + 1, red)
            utime.sleep(delay)
            strip_animation.show()
            strip_animation.set_pixel(x, red)
            utime.sleep(delay)
            strip_animation.show()
            strip_animation.set_pixel(x + 2, red)
            utime.sleep(delay)
            strip_animation.show()
            strip_animation.set_pixel(x, blank)
            utime.sleep(delay)
            strip_animation.set_pixel(x + 1, blank)
            utime.sleep(delay)
            strip_animation.set_pixel(x + 2, blank)
            strip_animation.show()
        if reset_animation == True:
            licht_aus()
            return


##################################################
# -----------------------------------------------#


button = Pin(18, Pin.IN, Pin.PULL_UP)


###########################################################################

# INTERRUPT HANDLER

# Blinker Links
def switch_left_up(pin):
    global blinker_links, blinker_rechts
    # stop blinker rechts if running
    if blinker_rechts == True:
        blinker_rechts = False

    # do nothing if blinker links is already running
    if blinker_links == True:
        return
    
    blinker_links = True

    # start blinker links

    _thread.start_new_thread(blink_links, ())


def switch_left_down(pin):
    global blinker_links
    blinker_links = False
    
toggle_switch_left.irq(handler=switch_left_up, trigger=Pin.IRQ_RISING)
toggle_switch_left.irq(handler=switch_left_down, trigger=Pin.IRQ_FALLING)


# Blinker Rechts
def switch_right_up(pin):
    global blinker_rechts, blinker_links
    # stop blinker links if running
    if blinker_links == True:
        blinker_links = False

    # do nothing if blinker rechts is already running
    if blinker_rechts == True:
        return
    
    blinker_rechts = True

    # start blinker rechts

    _thread.start_new_thread(blink_rechts, ())


def switch_right_down(pin):
    global blinker_rechts
    blinker_rechts = False

toggle_switch_right.irq(handler=switch_right_up, trigger=Pin.IRQ_RISING)
toggle_switch_right.irq(handler=switch_right_down, trigger=Pin.IRQ_FALLING)


# Button Interrupt
def button_pressed(pin):
    global debouncing, animation_NR, reset_animation
    # Handle the button press event
    animation_NR = (animation_NR + 1) % anzahl_animationen
    # Reset the debouncing flag
    debouncing = False
    reset_animation = True

def button_debouncer(pin):
    global debouncing
    if not debouncing:
        debouncing = True
        debounce_timer.init(mode=Timer.ONE_SHOT, period=200, callback=lambda t: button_pressed(pin))

# Set up the button interrupt with the debouncer
button.irq(handler=button_debouncer, trigger=Pin.IRQ_RISING)


###########################################################################

# MAIN LOOPS
def animation_loop():
    global animation_NR, reset_animation
    while True:
        reset_animation = False
        if animation_NR == 0:
            licht_aus()
        elif animation_NR == 1:
            fernlicht_an()
        elif animation_NR == 2:
            rainbow()
        elif animation_NR == 3:
           police()
        elif animation_NR == 4:
            kit()


def test_loop():
    while True:

        #rainbow()
        # kit()
        # fernlicht_an()
        utime.sleep(0.5)
        # licht_aus()
        # utime.sleep(0.5)
        # police()
        print('thread1')

        blink_rechts()
        blink_links()


# start blinker_loop on second core
#_thread.start_new_thread(animation_loop, ())

#blinker_loop()
animation_loop()
#test_loop()