import time
import RPi.GPIO as GPIO
from pad4pi import rpi_gpio
from adafruit_character_lcd.character_lcd_i2c import Character_LCD_I2C
import board
import busio

# Configuración de la pantalla LCD
i2c = busio.I2C(board.GP1, board.GP0)
lcd_columns = 16
lcd_rows = 2
lcd = Character_LCD_I2C(i2c, lcd_columns, lcd_rows)



GPIO.setmode(GPIO.BCM)
GPIO.setup(redled, GPIO.OUT)
GPIO.setup(yellowled, GPIO.OUT)
GPIO.setup(greenled, GPIO.OUT)
GPIO.setup(buzzer, GPIO.OUT)

GPIO.output(redled, GPIO.HIGH)
GPIO.output(yellowled, GPIO.HIGH)
GPIO.output(greenled, GPIO.HIGH)

# Configuración del teclado matricial
KEYPAD = [
    ["1", "2", "3"],
    ["4", "5", "6"],
    ["7", "8", "9"],
    ["*", "0", "#"]
]

ROW_PINS = [4, 5, 6, 7]  # Pines GPIO conectados a las filas del teclado
COL_PINS = [8, 9, 10]    # Pines GPIO conectados a las columnas del teclado

factory = rpi_gpio.KeypadFactory()
keypad = factory.create_keypad(keypad=KEYPAD, row_pins=ROW_PINS, col_pins=COL_PINS)

# Variables globales
Hours = 0
Minutes = 0
Seconds = 0
trycount = 0
keycount = 0
password = [""] * 4
entered = [""] * 4
secMillis = 0
interval = 1000

def beep(frequency, duration):
    GPIO.output(buzzer, GPIO.HIGH)
    time.sleep(duration / 1000.0)
    GPIO.output(buzzer, GPIO.LOW)

def set_timer():
    global Hours, Minutes, Seconds, keycount
    lcd.clear()
    lcd.message = "Timer: HH:MM:SS\nSET:   :  :"
    keycount = 5

    while keycount == 5:
        hourstens = keypad.get_key()
        if hourstens and hourstens.isdigit():
            lcd.cursor_position(5, 1)
            lcd.blink = True
            beep(5000, 100)
            lcd.message = hourstens
            hourstenscode = int(hourstens)
            keycount += 1

    while keycount == 6:
        hoursones = keypad.get_key()
        if hoursones and hoursones.isdigit():
            lcd.cursor_position(6, 1)
            lcd.blink = True
            beep(5000, 100)
            lcd.message = hoursones
            hoursonescode = int(hoursones)
            keycount += 1

    while keycount == 7:
        mintens = keypad.get_key()
        if mintens and mintens.isdigit():
            lcd.cursor_position(8, 1)
            lcd.blink = True
            beep(5000, 100)
            lcd.message = mintens
            mintenscode = int(mintens)
            keycount += 1

    while keycount == 8:
        minones = keypad.get_key()
        if minones and minones.isdigit():
            lcd.cursor_position(9, 1)
            lcd.blink = True
            beep(5000, 100)
            lcd.message = minones
            minonescode = int(minones)
            keycount += 1

    while keycount == 9:
        sectens = keypad.get_key()
        if sectens and sectens.isdigit():
            lcd.cursor_position(11, 1)
            lcd.blink = True
            beep(5000, 100)
            lcd.message = sectens
            sectenscode = int(sectens)
            keycount = 10

    while keycount == 10:
        secones = keypad.get_key()
        if secones and secones.isdigit():
            lcd.cursor_position(12, 1)
            lcd.blink = True
            beep(5000, 100)
            lcd.message = secones
            seconescode = int(secones)
            keycount = 11

    if keycount == 11:
        Hours = (hourstenscode * 10) + hoursonescode
        Minutes = (mintenscode * 10) + minonescode
        Seconds = (sectenscode * 10) + seconescode
        time.sleep(0.1)
        lcd.blink = False
        lcd.clear()
        lcd.message = "Timer set at:\n"
        lcd.message += f"{Hours:02}:{Minutes:02}:{Seconds:02}"
        time.sleep(3)
        lcd.clear()
        lcd.message = "Press # to arm"
        keycount = 12

def arm_bomb():
    global keycount
    while keycount == 12:
        armkey = keypad.get_key()
        if armkey == "#":
            for _ in range(3):
                beep(5000, 100)
                time.sleep(0.05)
                beep(0, 100)
                time.sleep(0.05)
            lcd.clear()
            lcd.message = "Bomb Armed!\nCountdown start"
            time.sleep(3)
            lcd.clear()
            keycount = 0

def disarm_bomb():
    global keycount, trycount, Hours, Minutes, Seconds
    lcd.clear()
    lcd.message = "Code: "
    keycount = 0

    while keycount < 4:
        disarmcode = keypad.get_key()
        if disarmcode == "#":
            beep(5000, 100)
            keycount = 0
            lcd.clear()
            lcd.message = "Code: "
        elif disarmcode and disarmcode != "*":
            lcd.cursor_position(keycount + 7, 0)
            lcd.blink = True
            lcd.message = disarmcode
            entered[keycount] = disarmcode
            keycount += 1
            beep(5000, 100)
            time.sleep(0.1)
            lcd.blink = False
            lcd.cursor_position(keycount + 6, 0)
            lcd.message = "*"

    if keycount == 4:
        if entered == password:
            lcd.blink = False
            lcd.clear()
            lcd.message = "Bomb Defused!\nWell Done!"
            keycount = 0
            GPIO.output(greenled, GPIO.LOW)
            time.sleep(15)
            lcd.clear()
            lcd.message = "Reset the Bomb"
            time.sleep(1000)
        else:
            lcd.blink = False
            lcd.clear()
            lcd.message = "Wrong Password!"
            trycount += 1
            if Hours > 0:
                Hours //= 2
            if Minutes > 0:
                Minutes //= 2
            if Seconds > 0:
                Seconds //= 2
            if trycount == 2:
                interval //= 10
            if trycount == 3:
                Minutes -= 59
                Hours -= 59
                Seconds -= 59
            time.sleep(1)
            keycount = 0
def timer():
    global Hours, Minutes, Seconds, secMillis, interval
    lcd.cursor_position(0, 1)
    lcd.message = f"Timer: {Hours:02}:{Minutes:02}:{Seconds:02}"

    if Hours <= 0 and Minutes < 0:
        lcd.blink = False
        lcd.clear()
        lcd.message = "The Bomb Has\nExploded!"
        while Minutes < 0:
            GPIO.output(redled, GPIO.LOW)
            beep(7000, 100)
            time.sleep(0.1)
            GPIO.output(redled, GPIO.HIGH)
            beep(7000, 100)
            time.sleep(0.1)
            GPIO.output(yellowled, GPIO.LOW)
            beep(7000, 100)
            time.sleep(0.1)
            GPIO.output(yellowled, GPIO.HIGH)
            beep(7000, 100)
            time.sleep(0.1)
            GPIO.output(greenled, GPIO.LOW)
            beep(7000, 100)
            time.sleep(0.1)
            GPIO.output(greenled, GPIO.HIGH)
            beep(7000, 100)
            time.sleep(0.1)

    if Hours < 0:
        Hours = 0
    if Minutes < 0:
        Hours -= 1
        Minutes = 59
    if Seconds < 1:
        Minutes -= 1
        Seconds = 59

    if Seconds > 0:
        currentMillis = time.time() * 1000
        if currentMillis - secMillis > interval:
            beep(7000, 50)
            secMillis = currentMillis
            Seconds -= 1
            GPIO.output(yellowled, GPIO.LOW)
            time.sleep(0.01)
            GPIO.output(yellowled, GPIO.HIGH)
            time.sleep(0.01)
def main():
    global keycount
    lcd.clear()
    lcd.message = "Bomb activated!\nEnter Code:"
    while keycount < 4:
        lcd.cursorposition(keycount + 12, 1)
        lcd.blink = True
        armcode = keypad.getkey()
        if armcode and armcode not in ['', '#']:
            lcd.message = armcode
            beep(5000, 100)
            password[keycount] = armcode
            keycount += 1

    if keycount == 4:
        time.sleep(0.5)
        lcd.blink = False
        lcd.clear()
        lcd.message = "Disarm Code is:\n"
        lcd.message += ''.join(password)
        time.sleep(3)
        lcd.clear()
        set_timer()
        arm_bomb()

def loop():
    global keycount
    while True:
        timer()
        disarmcode = keypad.get_key()
        if disarmcode == '':
            beep(5000, 100)
            disarmbomb()

if _name == "__main":
    try:
        main()
        loop()
    except KeyboardInterrupt:
        GPIO.cleanup()