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

// Define o pino GPIO 4 para controlar o LED.
const uint LED = 4;
// Define o pino GPIO 7 para ler o estado do botão.
const uint BTN_A = 7;
// Define o pino GPIO 15 para ler o estado do botão.
const uint BTN_B = 15;

static volatile int piscaLED = 1;

// Determina a frequência em que o LED ficará piscando
int freq = 100;
// controla o acionamento do LED (true = ligado / false = desligado)
bool control_led_1 = true;
// Variáveis utilizadas para determinar o tempo em que o LED ficará piscando (100 segundos)
static volatile int time = 1000;
int control_led_2 = 0;
// Variável utilizada para fazer o LED piscar na frequência de 1Hz
int control_led_3 = 0;

// Contador de pressões do botão.
static volatile int contador_button = 0;
// Variáveis utilizadas para evitar o bounce do botão
static volatile int control_button_1 = 0;
static volatile int control_button_2 = 0;
static volatile int control_button_3 = 0;
// Variáveis que controlam a frequência em que o LED fica piscando (1Hz ou 10Hz)
static volatile int control_button_4 = 1;
static volatile int control_button_5 = 0;

// Declaração da função de callback da interruupçao
static void gpio_irq_handler_button_a(uint gpio, uint32_t events);

// Função que detecta se o botão foi pressionado
static void gpio_irq_handler_button_a(uint gpio, uint32_t events) {
    // Controle de bounce do botão
    if (control_button_3 == control_button_2) {
        control_button_1++;
    }    
}

// Função de callback que será chamada repetidamente pelo temporizador
// O tipo bool indica que a função deve retornar verdadeiro ou falso para continuar ou parar o temporizador.
bool repeating_timer_callback(struct repeating_timer *t) {
    // Altera a frequência em que o LED fica piscando (1Hz ou 10Hz).
    if (piscaLED == 0) {
        // Faz o LED piscar na frequência de 1Hz
        if(control_button_4 == 1) {
            time = 100;
            control_button_5 = 1;
        }
        // Faz o LED piscar na frequência de 10Hz
        if (control_button_4 == 0) {
            time = 1000;
            control_button_5 = 0;
        }
        piscaLED = 1;
    }
    // Verifica se o botão foi pressionado 5 vezes para acionar o LED
    if (contador_button >= 5) {
        // Faz o controle para que o LED fique piscando na frequência de 10Hz
        if (control_button_5 == 0) {
            // Faz o controle para que o LED fique piscando
            if (control_led_1) {
                gpio_put(LED, true);
                control_led_1 = false;
            } else {
                gpio_put(LED, false);
                control_led_1 = true;
            }
            control_led_2++;
            control_button_4 = 1;              
        } else if (control_button_5 == 1) {
            // Faz o controle para que o LED fique piscando na frequência de 1Hz
            control_led_3++;
            if (control_led_3 == 10) {
                // Faz o controle para que o LED fique piscando
                if (control_led_1) {
                    gpio_put(LED, true);
                    control_led_1 = false;
                } else {
                    gpio_put(LED, false);
                    control_led_1 = true;
                }
                control_led_2++;
                control_led_3 = 0;
                control_button_4 = 0;
            }
        }
        
        // Faz o controle do tempo em que o LED fica ligado (100 segundos)
        if (control_led_2 >= time) {
            // Inicioaliza todas as variáveis
            gpio_put(LED, false);
            contador_button = 0;
            control_button_1 = 0;
            control_button_2 = 0;
            control_button_3 = 0;
            control_led_1 = true;
            control_led_2 = 0;
            control_led_3 = 0;
            time = 100;
        }
    }
    // Retorna true para manter o temporizador repetindo. Se retornar false, o temporizador para.
    return true;
}

int main() {
    // Inicializa a comunicação serial
    stdio_init_all();

    // Configura o pino do LED como saída.
    gpio_init(LED);
    gpio_set_dir(LED, GPIO_OUT);

    // Configura o pino do botão como entrada
    gpio_init(BTN_A);
    gpio_set_dir(BTN_A, GPIO_IN);
    // Habilita o resistor pull-up interno para evitar leituras incorretas.
    gpio_pull_up(BTN_A);

    // Configura o pino do botão como entrada
    gpio_init(BTN_B);
    gpio_set_dir(BTN_B, GPIO_IN);
    // Habilita o resistor pull-up interno para evitar leituras incorretas.
    gpio_pull_up(BTN_B);

    // Configuração da interrupção da borda de subida
    gpio_set_irq_enabled_with_callback(BTN_A, GPIO_IRQ_EDGE_RISE, true, &gpio_irq_handler_button_a);

    // Declaração da estrutura do temporizador.
    // Estrutura que armazena informações sobre o temporizador configurado.
    struct repeating_timer timer;
    // Configura o temporizador para chamar a função de callback a cada 1 segundo.
    // Parâmetros:
    // freq: Intervalo de tempo em milissegundos (100 milissegundos).
    // repeating_timer_callback: Função de callback que será chamada a cada intervalo.
    // NULL: Dados adicionais passados para a função de callback (não utilizados neste caso).
    // &timer: Ponteiro para a estrutura que armazenará informações do temporizador.
    add_repeating_timer_ms(freq, repeating_timer_callback, NULL, &timer);
    
    while (true) {
        // Aguarda o tempo de 500 milissegundos para evitar o bounce do botão
        sleep_ms(500);

        // Conta quantas vezes o botão foi pressionado.
        if (control_button_1 > 0) {
            control_button_1 = 0;
            control_button_3++;
        } else if (control_button_3 > 0) {
            contador_button++;
            control_button_3 = 0;
        }

        if (gpio_get(BTN_B) == 0)
        {
            piscaLED = 0;
            sleep_ms(500);
        }
    }

    return 0;
}