#include <stdio.h>             // Biblioteca para entrada e saída (printf).
#include "pico/stdlib.h"       // Biblioteca do Pico para GPIO e temporização.
#include "hardware/adc.h"      // Biblioteca para controle do ADC (Conversor Analógico-Digital).
#include "hardware/pwm.h"      // Biblioteca para controle do PWM (servo motor).
#include <string.h>            // Biblioteca para manipulação de strings.
#include "dht.h"               // biblioteca própria criada pro dht

// Definições dos pinos para o joystick, botão, LEDs, servo motor e LDR
#define VRX_PIN 26    // Pino GP26 para o eixo X do joystick (Canal ADC0).
#define VRY_PIN 27    // Pino GP27 para o eixo Y do joystick (Canal ADC1).
#define SW_PIN 22     // Pino GP22 para o botão do joystick (entrada digital).
#define btn_A 6
#define rgb_R 12      // Pino GP12 para o LED vermelho.
#define rgb_G 13      // Pino GP13 para o LED verde.
#define rgb_B 11      // Pino GP11 para o LED azul.
#define SERVO_PIN 18  // Pino GP18 para controle do servo motor.
#define LDR_PIN 28    // Pino GP28 para leitura do sensor de luz (Canal ADC2).
#define MAX_SEQUENCE 4 // Tamanho máximo para a sequência de comandos
const uint DHT_PIN = 15;
char sequence[MAX_SEQUENCE] = ""; // Array pra armazenar string
bool last_sw_state = false; // Variável para armazenar o estado anterior do botão

// Função para adicionar um movimento à sequência
void add_to_sequence(char move) {
    if (strlen(sequence) < MAX_SEQUENCE - 1) { // Garante que a sequência não exceda o tamanho máximo
        int len = strlen(sequence);
        sequence[len] = move; // Adiciona o novo movimento à sequência
        sequence[len + 1] = '\0'; // Finaliza a string corretamente
    }
}

// Função para configurar e movimentar o servo motor
void set_servo_pulse(uint16_t pulse_width) {
    pwm_set_gpio_level(SERVO_PIN, pulse_width);
}

// Função para ler o LDR e ajustar a iluminação
void check_ldr() {
    adc_select_input(2); // Seleciona o canal ADC2 (LDR)
    uint16_t ldr_value = adc_read(); // Faz a leitura do LDR
    float voltage = ldr_value * (3.3f / (1 << 12)); // Converte para tensão
    //printf("LDR: %d, Tensão: %.2f V\n", ldr_value, voltage);// se quiser ver

    // Ajusta a cor do LED com base na luz ambiente
    if (ldr_value > 1000) {
      // Posição máxima (geralmente 180 graus)
      set_servo_pulse(2850);
    }else{
      set_servo_pulse(1000);
    }
}

// Função para verificar se a sequência corresponde a um comando específico

#include <string.h>
#include <stdio.h>

// Assumindo que estas variáveis estão definidas em algum lugar
extern int rgb_R, rgb_G, rgb_B;
extern char sequence[]; // Certifique-se de que esta variável está corretamente declarada

void check_command() {
    printf("Sequência recebida: %s\n", sequence); // Debug: imprime a sequência atual

    if (strcmp(sequence, "LUC") == 0) {
        printf("Luz vermelha\n");
        // Comentei as linhas de GPIO para evitar erros se não estiverem definidas
        // gpio_put(rgb_R, 1);
        // gpio_put(rgb_G, 0);
        // gpio_put(rgb_B, 0);
    } else if (strcmp(sequence, "RRU") == 0) {
        printf("Luz verde\n");
        // gpio_put(rgb_R, 0);
        // gpio_put(rgb_G, 1);
        // gpio_put(rgb_B, 0);
    } else if (strcmp(sequence, "DDC") == 0) {
        printf("Luz azul\n");
        // gpio_put(rgb_R, 0);
        // gpio_put(rgb_G, 0);
        // gpio_put(rgb_B, 1);
    } else {
        printf("Comando não reconhecido\n");
    }

    printf("Limpando sequência...\n");
    memset(sequence, 0, sizeof(sequence)); // Limpa a sequência após verificar
    printf("Sequência após limpeza: %s\n", sequence); // Debug: confirma que a sequência foi limpa
}
int main() {
    stdio_init_all(); // Inicializa a comunicação serial
    adc_init(); // Inicializa o ADC

    adc_gpio_init(VRX_PIN); // Inicia ADC0 (pino 26)
    adc_gpio_init(VRY_PIN); // Inicia ADC1 (pino 27)
    adc_gpio_init(LDR_PIN); // Mesma coisa pro LDR, inicia o GP28 como o ADC2

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

    gpio_init(rgb_R);
    gpio_set_dir(rgb_R, GPIO_OUT);
    gpio_put(rgb_R, 0);

    gpio_init(rgb_G);
    gpio_set_dir(rgb_G, GPIO_OUT);
    gpio_put(rgb_G, 0);

    gpio_init(rgb_B);
    gpio_set_dir(rgb_B, GPIO_OUT);
    gpio_put(rgb_B, 0);

    gpio_init(DHT_PIN); // INICIA pino do DHT

    gpio_set_function(SERVO_PIN, GPIO_FUNC_PWM);
    uint slice_num = pwm_gpio_to_slice_num(SERVO_PIN);

    pwm_set_wrap(slice_num, 20000);
    pwm_set_clkdiv(slice_num, 64);
    pwm_set_enabled(slice_num, true);


    while (true) {
        adc_select_input(0);
        uint16_t vrx_value = adc_read();

        adc_select_input(1);
        uint16_t vry_value = adc_read();

        bool sw_value = gpio_get(SW_PIN) == 0;

        if (vrx_value > 3000) add_to_sequence('L'); // LEFT
        else if (vrx_value < 1000) add_to_sequence('R'); // RIGHT

        if (vry_value > 3000) add_to_sequence('U'); // UP
        else if (vry_value < 1000) add_to_sequence('D'); //DOWN

        if (!last_sw_state && sw_value) { // debounce
            add_to_sequence('C');
        }
        last_sw_state = sw_value;

        printf("VRX: %u, VRY: %u, SW: %d, Sequence: %s\n", vrx_value, vry_value, sw_value, sequence);
        
        dht_reading reading;
        read_from_dht(&reading, DHT_PIN); // função de dht.h
        float fahrenheit = (reading.temp_celsius * 9 / 5) + 32;
        printf("Humidity = %.1f%%, Temperature = %.1fC (%.1fF)\n",
               reading.humidity, reading.temp_celsius, fahrenheit);
        check_command();
        check_ldr();
        sleep_ms(500);

    }
    return 0;
}//main