#include "pico/cyw43_arch.h"
#include "pico/stdlib.h"
#include "lwip/dns.h"
#include "lwip/tcp.h"
#include "hardware/adc.h"
#include "hardware/clocks.h"
#include "hardware/pwm.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define WIFI_SSID "Wokwi-GUEST"
#define WIFI_PASS ""
#define THINGSPEAK_HOST "api.thingspeak.com"
#define THINGSPEAK_API_KEY "906KM6SHZCDQI4I2"

#define NUM_READINGS 10
#define LED_VERDE 11
#define LED_VERMELHO 13
#define BUZZER_PIN 21
#define FREQUENCIA_BAIXA 440
#define FREQUENCIA_ALTA 660
#define DURACAO_NOTA 850

float readings[NUM_READINGS] = {0};
float humidity_readings[NUM_READINGS] = {50};
int idx = 0;
int count = 0;
struct tcp_pcb *pcb_global;

// Função para gerar umidade relativa simulada com variação fixa
float gerar_umidade()
{
    static float current_humidity = 50.0;
    static int variation_index = 0;
    int variations[] = {0.5, 5, 9, 3, 7};

    current_humidity += (rand() % 2 == 0 ? 1 : -1) * variations[variation_index];
    if (current_humidity < 30) current_humidity = 30;
    if (current_humidity > 70) current_humidity = 70;
    
    variation_index = (variation_index + 1) % (sizeof(variations) / sizeof(variations[0]));

    return current_humidity;
}

// Função para calcular a média das leituras de temperatura
float calcular_media()
{
    float soma = 0;
    for (int i = 0; i < NUM_READINGS; i++)
    {
        soma += readings[i];
    }
    return soma / NUM_READINGS;
}

// Callback ao conectar ao ThingSpeak
static err_t thingspeak_connected_callback(void *arg, struct tcp_pcb *tpcb, err_t err)
{
    if (err != ERR_OK)
    {
        printf("Erro ao conectar ao ThingSpeak: %d\n", err);
        return err;
    }

    float temperatura = *(float *)arg;
    float umidade = gerar_umidade();
    printf("Umidade relativa: %.2f%%\n", umidade);
    char post_data[150];
    snprintf(post_data, sizeof(post_data), "api_key=%s&field1=%.2f&field2=%.2f&field3=%d&field4=%d", 
             THINGSPEAK_API_KEY, temperatura, umidade, gpio_get(LED_VERDE), gpio_get(LED_VERMELHO));

    char request[512];
    snprintf(request, sizeof(request),
             "POST /update HTTP/1.1\r\n"
             "Host: " THINGSPEAK_HOST "\r\n"
             "User-Agent: PicoWClient/1.0\r\n"
             "Connection: close\r\n"
             "Content-Type: application/x-www-form-urlencoded\r\n"
             "Content-Length: %d\r\n\r\n"
             "%s",
             (int)strlen(post_data), post_data);

    printf("Enviando dados para ThingSpeak...\n");
    tcp_write(tpcb, request, strlen(request), TCP_WRITE_FLAG_COPY);
    tcp_output(tpcb);
    return ERR_OK;
}

// Callback de resolução de DNS
static void dns_callback(const char *name, const ip_addr_t *ipaddr, void *arg)
{
    if (ipaddr == NULL)
    {
        printf("Erro ao resolver o DNS do ThingSpeak.\n");
        return;
    }

    struct tcp_pcb *pcb = tcp_new();
    if (!pcb)
    {
        printf("Erro ao criar PCB para ThingSpeak\n");
        return;
    }

    float *temp = (float *)arg;
    pcb_global = pcb;
    tcp_arg(pcb, temp);
    tcp_connect(pcb, ipaddr, 80, thingspeak_connected_callback);
}

// Função para enviar dados ao ThingSpeak
void send_to_thingspeak(float temperatura)
{
    printf("Resolvendo DNS do ThingSpeak...\n");
    ip_addr_t thingspeak_ip;
    err_t err = dns_gethostbyname(THINGSPEAK_HOST, &thingspeak_ip, dns_callback, &temperatura);

    if (err == ERR_OK)
    {
        dns_callback(THINGSPEAK_HOST, &thingspeak_ip, &temperatura);
    }
}

// Função principal
int main()
{
    stdio_init_all();
    sleep_ms(10000);
    printf("Iniciando...\n");

    srand(time(NULL)); // Inicializa a semente do gerador de números aleatórios

    if (cyw43_arch_init())
    {
        printf("Erro ao inicializar o Wi-Fi\n");
        return 1;
    }

    cyw43_arch_enable_sta_mode();
    printf("Conectando ao Wi-Fi...\n");
    if (cyw43_arch_wifi_connect_timeout_ms(WIFI_SSID, WIFI_PASS, CYW43_AUTH_WPA2_AES_PSK, 10000))
    {
        printf("Falha ao conectar ao Wi-Fi\n");
        return 1;
    }
    else
    {
        printf("Wi-Fi conectado!\n");
    }

    adc_init();
    adc_set_temp_sensor_enabled(true);
    adc_select_input(4);

    gpio_init(LED_VERDE);
    gpio_set_dir(LED_VERDE, GPIO_OUT);
    gpio_init(LED_VERMELHO);
    gpio_set_dir(LED_VERMELHO, GPIO_OUT);

    while (true)
    {
        uint16_t raw = adc_read();
        float conversion_factor = 3.3f / (1 << 12);
        float result = raw * conversion_factor;
        float temp = 27 - (result - 0.706) / 0.001721;

        readings[idx] = temp;
        idx = (idx + 1) % NUM_READINGS;
        count++;

        if (count == NUM_READINGS)
        {
            float media_temp = calcular_media();
            printf("Média da temperatura: %.2f C\n", media_temp);
            send_to_thingspeak(media_temp);
            count = 0;

            if (media_temp >= 29.0)
            {
                gpio_put(LED_VERDE, 0);
                gpio_put(LED_VERMELHO, 1);
            }
            else
            {
                gpio_put(LED_VERDE, 1);
                gpio_put(LED_VERMELHO, 0);
            }
        }

        sleep_ms(1000);
    }
}