#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include <time.h>

#define FIRST_GPIO 2
#define BUTTON_GPIO (FIRST_GPIO+7)
#define START_BUTTON 19

#define YELLOW_BUTTON 22
#define BLUE_BUTTON 21
#define RED_BUTTON 20

#define YELLOW_LED 18
#define BLUE_LED 17
#define RED_LED 16

#define TRANSISTOR_1 12
#define TRANSISTOR_2 13
#define TRANSISTOR_3 14
#define TRANSISTOR_4 15

// Inverted bit patterns for common cathode display
int bits[10] = {
    0x3f,  // 0
    0x06,  // 1
    0x5b,  // 2
    0x4f,  // 3
    0x66,  // 4
    0x6d,  // 5
    0x7d,  // 6
    0x07,  // 7
    0x7f,  // 8
    0x67   // 9
};

/*// Function to perform debounce
bool debounce(int button) {
    const int debounce_time_ms = 20; // Adjust debounce time as needed
    bool state = gpio_get(button);
    sleep_ms(debounce_time_ms);
    return state == gpio_get(button);
}*/

int main() {
    stdio_init_all();
    //printf("Hello, 7segment - press button to count down!\n");

    for (int gpio = FIRST_GPIO; gpio < FIRST_GPIO + 7; gpio++) {
        gpio_init(gpio);
        gpio_set_dir(gpio, GPIO_OUT);
    }

    gpio_init(START_BUTTON);
    gpio_set_dir(START_BUTTON, GPIO_IN);
    gpio_pull_up(START_BUTTON);

    gpio_init(YELLOW_BUTTON);
    gpio_set_dir(YELLOW_BUTTON, GPIO_IN);
    gpio_pull_up(YELLOW_BUTTON);

    gpio_init(BLUE_BUTTON);
    gpio_set_dir(BLUE_BUTTON, GPIO_IN);
    gpio_pull_up(BLUE_BUTTON);

    gpio_init(RED_BUTTON);
    gpio_set_dir(RED_BUTTON, GPIO_IN);
    gpio_pull_up(RED_BUTTON);

    gpio_init(BUTTON_GPIO);
    gpio_set_dir(BUTTON_GPIO, GPIO_IN);
    gpio_pull_up(BUTTON_GPIO);

    gpio_init(YELLOW_LED);
    gpio_set_dir(YELLOW_LED, GPIO_OUT);

    gpio_init(BLUE_LED);
    gpio_set_dir(BLUE_LED, GPIO_OUT);

    gpio_init(RED_LED);
    gpio_set_dir(RED_LED, GPIO_OUT);

    // Inicializa el pin del LED como salida
    gpio_init(TRANSISTOR_1);
    gpio_set_dir(TRANSISTOR_1, GPIO_OUT);
    
    gpio_init(TRANSISTOR_2);
    gpio_set_dir(TRANSISTOR_2, GPIO_OUT);

    gpio_init(TRANSISTOR_3);
    gpio_set_dir(TRANSISTOR_3, GPIO_OUT);

    gpio_init(TRANSISTOR_4);
    gpio_set_dir(TRANSISTOR_4, GPIO_OUT);

    int counting = 0;
    int val = 0;
    int timer = 0;
    int uni = 0;
    int dec = 0;
    int cen = 0;
    int mil = 0;
    int i = 0;
    int flag = 0;

    bool prev_blue_state = true; // Previous state of BLUE_BUTTON
    bool prev_red_state = true;  // Previous state of RED_BUTTON
    bool prev_yellow_state = true;  // Previous state of YELLOW_BUTTON

    while (true) {
        if (flag == 0) {
            if (!gpio_get(START_BUTTON)) {
                counting = 0;
                val = 0;
                timer = 0;
                uni = 0;
                dec = 0;
                cen = 0;
                mil = 0;
                i = 0;
                flag = 0;

                printf("GET READY!\n");
                //turn on 3 leds
                gpio_put(YELLOW_LED, 1);
                gpio_put(BLUE_LED, 1);
                gpio_put(RED_LED, 1);
                sleep_ms(1000);
                //turn off led 3
                gpio_put(YELLOW_LED, 0);
                sleep_ms(1000);
                //turn off led 2
                gpio_put(BLUE_LED, 0);
                sleep_ms(1000);
                //turn off led 1
                gpio_put(RED_LED, 0);
                sleep_ms(1000);

                //Wait a random time (from 1000 ms to 10000 ms)
                int random_time;
                srand(time(NULL));
                random_time = (rand() % (10000 - 1000 + 1)) + 1000;
                printf("Random time: %d\n", random_time);
                sleep_ms(random_time);

                //once random_time passed, select a random LED.
                int random_led;
                //srand(time(NULL));
                random_led = (rand() % (3)) + 1;
                printf("Random led: %d\n", random_led);
                
                //once random led selected, put random led on.
                gpio_put(random_led + 15, 1);
                val = 0;
                flag = 1;
                counting = 1;
            }
        } else {   //if counting
            gpio_put(TRANSISTOR_1 + i, 1); // Enciende el LED*
            i++;
            if (i == 4) {
                i = 0;
            }
            sleep_ms(1);
            gpio_put(TRANSISTOR_1, 0); // Enciende el LED*
            gpio_put(TRANSISTOR_2, 0); // Enciende el LED*
            gpio_put(TRANSISTOR_3, 0); // Enciende el LED*
            gpio_put(TRANSISTOR_4, 0); // Enciende el LED*
                //if (debounce(YELLOW_BUTTON)) {
                //    printf("PULSASTE EL BOTON AMARILLO\n");
                //    counting = 0;
                //}
            if (!gpio_get(YELLOW_BUTTON) && prev_yellow_state) { // Rising edge on yellow button
                printf("(Yellow Button)\n");
                prev_yellow_state = false;
                if(gpio_get(YELLOW_LED)){
                  printf("YELLOW MATCH\n");
                  counting = 0;
                }
                else{
                  printf("PENALIZACION!!!!!!!!!!!!!!!!!\n");
                  if(val>=9999  || uni>=10){
                    printf("PERDISTE\n");
                    val = 9999;
                    uni = 9;
                    dec = 9;
                    cen = 9;
                    mil = 9;
                    counting = 0;
                  }
                  else{
                    val = val + 1000;
                    uni++;
                  }
                }
            } else if (gpio_get(YELLOW_BUTTON) && !prev_yellow_state) {
                prev_yellow_state = true;
            } else if (!gpio_get(BLUE_BUTTON) && prev_blue_state) { // Rising edge on blue button
                printf("(Blue Button)\n");
                prev_blue_state = false;
                if(gpio_get(BLUE_LED)){
                  printf("BLUE MATCH\n");
                  counting = 0;
                }
                else{
                  printf("PENALIZACION!!!!!!!!!!!!!!!!!\n");
                  if(val>=9999  || uni>=10){
                    printf("PERDISTE\n");
                    val = 9999;
                    uni = 9;
                    dec = 9;
                    cen = 9;
                    mil = 9;
                    counting = 0;
                  }
                  else{
                    val = val + 1000;
                    uni++;
                  }
                }
            } else if (gpio_get(BLUE_BUTTON) && !prev_blue_state) {
                prev_blue_state = true;
            } else if (!gpio_get(RED_BUTTON) && prev_red_state) { // Rising edge on red button
                printf("(Red Button)\n");
                prev_red_state = false;
                if(gpio_get(RED_LED)){
                  printf("RED MATCH\n");
                  counting = 0;
                }
                else{
                  printf("PENALIZACION!!!!!!!!!!!!!!!!!\n");
                  if(val>=9999  || uni>=10){
                    printf("PERDISTE\n");
                    val = 9999;
                    uni = 9;
                    dec = 9;
                    cen = 9;
                    mil = 9;
                    counting = 0;
                  }
                  else{
                    val = val + 1000;
                    uni++;
                  }
                }
            } else if (gpio_get(RED_BUTTON) && !prev_red_state) {
                prev_red_state = true;
            }

            if (!gpio_get(START_BUTTON)) {
              flag = 0;        
              counting = 0;
            }

        if (counting) {
            if (val >= 9999) {
                printf("PERDISTE\n");
                counting = 0;
            } else {
                val++;
                // Update units
                mil++;
                if (mil >= 10) {
                    mil = 0;
                    // Update tens
                    cen++;
                    if (cen >= 10) {
                        cen = 0;
                        // Update hundreds
                        dec++;
                        if (dec >= 10) {
                            dec = 0;
                            // Update thousands
                            uni++;
                            if (uni >= 10) {
                                uni = 0;
                            }
                        }
                    }
                }
            }
        }

        int32_t mask = bits[uni] << FIRST_GPIO;

        gpio_set_mask(mask);
        sleep_ms(1);
        gpio_clr_mask(mask);
        printf("%d %d %d %d \n", uni, dec, cen, mil);
    }
}
}