#include "pico/stdlib.h"  // Biblioteca padrão para controle de GPIO e temporização.
#include <stdio.h>         // Biblioteca para usar funções como printf para impressão no terminal.

const uint RED_PIN = 13;    // Pino GPIO 13 - Vermelho
const uint GREEN_PIN = 11;  // Pino GPIO 11 - Verde
const uint BLUE_PIN = 12;   // Pino GPIO 12 - Azul
const uint BUTTON_A_PIN = 5;  // Pino GPIO 5 - Botão A
const uint BUTTON_B_PIN = 6;  // Pino GPIO 6 - Botão B

// Variáveis para controle
int button_press_count = 0;  // Contador de pressionamentos do botão A
int current_color = 0;       // Controle da cor atual (0: Vermelho, 1: Verde, 2: Azul)
float blink_frequency = 2.0; // Frequência inicial de piscar (2 Hz)

// Função para desligar todos os LEDs.
void turn_off_leds() {
    gpio_put(RED_PIN, false);
    gpio_put(GREEN_PIN, false);
    gpio_put(BLUE_PIN, false);
    printf("LEDs desligados\n");
}

// Função para acender o LED correspondente à cor atual.
void turn_on_led(int color) {
    turn_off_leds();  // Garante que apenas um LED esteja ligado.

    switch (color) {
        case 0:  // Vermelho
            gpio_put(RED_PIN, true);
            printf("LED Vermelho aceso\n");
            break;
        case 1:  // Verde
            gpio_put(GREEN_PIN, true);
            printf("LED Verde aceso\n");
            break;
        case 2:  // Azul
            gpio_put(BLUE_PIN, true);
            printf("LED Azul aceso\n");
            break;
        default:
            break;
    }
}

// Função para piscar o LED correspondente à cor atual por 10 segundos.
void blink_led(int color, float frequency) {
    printf("Piscando LED por 10 segundos a %.1f Hz\n", frequency);

    int blink_count = (int)(10 * frequency); // Número de piscadas em 10 segundos
    int delay_time = (int)(1000 / (2 * frequency)); // Tempo de liga/desliga em ms

    for (int i = 0; i < blink_count; i++) {
        turn_on_led(color);  // Acende o LED da cor correspondente.
        sleep_ms(delay_time);  // LED ligado.
        turn_off_leds();       // Desliga o LED.
        sleep_ms(delay_time);  // LED desligado.
    }
}

int main() {
    // Inicializa a comunicação serial para imprimir mensagens no terminal.
    stdio_init_all();

    // Inicializa os pinos do LED RGB como saída.
    gpio_init(RED_PIN);
    gpio_init(GREEN_PIN);
    gpio_init(BLUE_PIN);
    gpio_set_dir(RED_PIN, GPIO_OUT);
    gpio_set_dir(GREEN_PIN, GPIO_OUT);
    gpio_set_dir(BLUE_PIN, GPIO_OUT);

    // Inicializa os pinos dos botões como entrada com resistor pull-up.
    gpio_init(BUTTON_A_PIN);
    gpio_set_dir(BUTTON_A_PIN, GPIO_IN);
    gpio_pull_up(BUTTON_A_PIN);  // Habilita o resistor pull-up para o botão A.

    gpio_init(BUTTON_B_PIN);
    gpio_set_dir(BUTTON_B_PIN, GPIO_IN);
    gpio_pull_up(BUTTON_B_PIN);  // Habilita o resistor pull-up para o botão B.

    // Apaga os LEDs no início.
    turn_off_leds();

    while (true) {
        // Verifica se o botão A foi pressionado (nível baixo no pino).
        if (gpio_get(BUTTON_A_PIN) == 0) {  // Botão A pressionado (nível baixo)
            // Aguarda um pequeno intervalo para debounce (evitar múltiplas leituras do botão).
            sleep_ms(200);  // Delay de 200 ms para debounce.

            // Incrementa o contador de pressionamentos.
            button_press_count++;
            printf("Botão A pressionado: %d vezes\n", button_press_count);

            // Verifica se o botão foi pressionado 5 vezes.
            if (button_press_count == 5) {
                // Faz o LED piscar por 10 segundos na frequência atual.
                blink_led(current_color, blink_frequency);

                // Reseta o contador de pressionamentos.
                button_press_count = 0;

                // Passa para a próxima cor na sequência.
                current_color = (current_color + 1) % 3;  // Alterna entre 0 (vermelho), 1 (verde), e 2 (azul).
            }

            // Aguarda até o botão ser liberado para evitar múltiplas leituras.
            while (gpio_get(BUTTON_A_PIN) == 0) {
                sleep_ms(10);  // Delay enquanto o botão ainda estiver pressionado.
            }
        }

        // Verifica se o botão B foi pressionado (nível baixo no pino).
        if (gpio_get(BUTTON_B_PIN) == 0) {  // Botão B pressionado (nível baixo)
            // Aguarda um pequeno intervalo para debounce.
            sleep_ms(200);  // Delay de 200 ms para debounce.

            // Alterna a frequência entre 1 Hz e 2 Hz.
            if (blink_frequency == 2.0) {
                blink_frequency = 1.0;  // Altera para 1 Hz.
                printf("Frequência alterada para 1 Hz\n");
            } else {
                blink_frequency = 2.0;  // Altera para 2 Hz.
                printf("Frequência alterada para 2 Hz\n");
            }

            // Aguarda até o botão ser liberado para evitar múltiplas leituras.
            while (gpio_get(BUTTON_B_PIN) == 0) {
                sleep_ms(10);  // Delay enquanto o botão ainda estiver pressionado.
            }
        }

        // Delay para reduzir o uso da CPU.
        sleep_ms(10);
    }

    return 0;
}