import machine
from machine import Timer
import utime


s0 = machine.Pin(27, machine.Pin.OUT)
s1 = machine.Pin(28, machine.Pin.OUT)
muxIn = machine.Pin(26, machine.Pin.IN)


LED_PINS = [7, 8, 9, 10, 11, 12, 13, 14, 15]
leds = [machine.Pin(pin, machine.Pin.OUT) for pin in LED_PINS]
correctLed = machine.Pin(2, machine.Pin.OUT)
wrongLed = machine.Pin(3, machine.Pin.OUT)
timeoutLed = machine.Pin(1, machine.Pin.OUT)
reset = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_DOWN)


BUTTON_PINS = [18, 17, 16]  
buttons = [
    machine.Pin(pin, machine.Pin.IN, machine.Pin.PULL_DOWN) for pin in BUTTON_PINS
]


PASSCODE = [0, 2, 1]
entered = []

# Function to light up the corresponding LED
def light_up_led(number, prev_number=[None]):

    if 0 <= number < 9:
        if prev_number[0] == number:
            leds[number].toggle()
        else:
            leds[number].value(1)
            prev_number[0] = number
        print(f"LED no. {number} has been toggled")
    else:
        print("Entered binary number is out of range")


# Check if the sequence is correct
def check():

    global entered
    print(f"Entered passcode: {entered}")
    utime.sleep(0.5)
    if entered == PASSCODE:
        entered = []
        print("Passcode correct!")
        correctLed.value(1)
        utime.sleep(0.75)
        correctLed.value(0)
        light_up_led(getBinaryNum())
        utime.sleep(0.25)
    else:
        entered = []
        print("Passcode incorrect!")
        wrongLed.value(1)
        utime.sleep(0.75)
        wrongLed.value(0)
        utime.sleep(0.25)



last_button_press_time = 0

timeout_interval = 3
# Add debounce_delay
debounce_interval = 100  # milliseconds

def interrupt_callback(pin):
    global last_button_press_time
    global last_button_state

    cur_time = utime.ticks_ms()
    button_time_diff = utime.ticks_diff(cur_time, last_button_press_time)

    if button_time_diff >= debounce_interval:
        last_button_press_time = cur_time

        # Read the current state of the button
        current_button_state = pin.value()

        # Compare with the previous state to detect a change
        if current_button_state != last_button_state:
            # Update the last_button_state
            last_button_state = current_button_state

            # Action to be taken when the button is pressed
            if current_button_state == 1:  # Button pressed
                button_index = buttons.index(pin)
                print(f"Button {button_index} pressed")
                entered.append(button_index)
                utime.sleep_ms(debounce_interval)  # Debounce delay

                # Restart the timeout timer
                timeout.init(period=(timeout_interval * 1000), mode=Timer.ONE_SHOT, callback=clearEntered)

# Initialize last_button_state
last_button_state = 0
reset_debounce_interval = 100

def resetLeds(pin):
    global reset_last_button_press_time

    
    cur_time = utime.ticks_ms()

  
    button_time_diff = utime.ticks_diff(cur_time, reset_last_button_press_time)

    if button_time_diff >= debounce_interval:
        reset_last_button_press_time = cur_time
        print("Resetting")
        for led in leds:
            led.value(0)
    


for button in buttons:
    button.irq(trigger=machine.Pin.IRQ_RISING, handler=interrupt_callback)

reset.irq(trigger=machine.Pin.IRQ_RISING, handler=resetLeds)

def clearEntered(pin):
    global entered
    if entered:
        print("Clearing entered sequence due to inactivity...")
        timeoutLed.value(1)
        utime.sleep(0.75)
        timeoutLed.value(0)
        entered = []
        utime.sleep(0.2)


timeout = Timer(period=(timeout_interval*1000), mode=Timer.ONE_SHOT, callback=clearEntered)


def getBinaryNum():

        binary_code = 0
        selectors = [ ( 0, 0 ), ( 0, 1 ), ( 1, 0 ), ( 1, 1 ) ]
        for selector_val in range(4):
            s0.value(selectors[selector_val][1])
            s1.value(selectors[selector_val][0])
            utime.sleep(0.020)
            binary_code += pow(2, selector_val) * muxIn.value()

        return binary_code



def main():

    prev_binary_code = 1

    global binary_code

    while True:
        
        if getBinaryNum() != prev_binary_code:
            print(f"decimal representation: {getBinaryNum()}")
            prev_binary_code = getBinaryNum()
        if len(entered) == len(PASSCODE):
            check()

        utime.sleep(0.2)


if __name__ == "__main__":
    main()