#include "pico/cyw43_arch.h"
#include "pico/stdlib.h"
#include "lwip/dns.h"
#include "lwip/tcp.h"
#include <string.h>
#include <stdio.h>

#define WIFI_SSID "Sofia_2G"
#define WIFI_PASS "........"
#define THINGSPEAK_HOST "api.thingspeak.com"
#define THINGSPEAK_API_KEY "........"

struct tcp_pcb *pcb_global;

// 🔹 Exibir o endereço IP da Pico W
void print_ip_address()
{
    uint8_t *ip_address = (uint8_t *)&(cyw43_state.netif[0].ip_addr.addr);
    printf("Endereço IP: %d.%d.%d.%d\n", ip_address[0], ip_address[1], ip_address[2], ip_address[3]);
}

// 🔹 Callback para receber resposta do ThingSpeak
static err_t thingspeak_recv_callback(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{
    if (p == NULL)
    {
        printf("Conexão fechada pelo servidor\n");
        tcp_close(tpcb);
        return ERR_OK;
    }

    char *response = (char *)p->payload;
    char *first_line = strtok(response, "\r\n");
    printf("Resposta do ThingSpeak: %s\n\n", first_line);

    pbuf_free(p);
    tcp_close(tpcb);
    return ERR_OK;
}

// 🔹 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;
    }

    int sensor_value = *(int *)arg;
    char post_data[100];
    snprintf(post_data, sizeof(post_data), "api_key=%s&field1=%d", THINGSPEAK_API_KEY, sensor_value);

    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");
    err_t write_err = tcp_write(tpcb, request, strlen(request), TCP_WRITE_FLAG_COPY);
    if (write_err != ERR_OK)
    {
        printf("Erro ao enviar dados para ThingSpeak: %d\n", write_err);
        tcp_close(tpcb);
        return write_err;
    }

    tcp_output(tpcb);
    tcp_recv(tpcb, thingspeak_recv_callback);
    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;
    }

    printf("ThingSpeak IP: %s\n", ip4addr_ntoa(ipaddr));
    struct tcp_pcb *pcb = tcp_new();
    if (!pcb)
    {
        printf("Erro ao criar PCB para ThingSpeak\n");
        return;
    }

    int *sensor_value = (int *)arg;
    pcb_global = pcb;
    tcp_arg(pcb, sensor_value);
    tcp_connect(pcb, ipaddr, 80, thingspeak_connected_callback);
}

// 🔹 Enviar dados ao ThingSpeak
void send_to_thingspeak(int sensor_value)
{
    printf("Resolvendo DNS do ThingSpeak...\n");
    ip_addr_t thingspeak_ip;
    err_t err = dns_gethostbyname(THINGSPEAK_HOST, &thingspeak_ip, dns_callback, &sensor_value);

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

// 🔹 Função principal
int main()
{
    stdio_init_all();
    sleep_ms(10000);
    printf("Iniciando conexão com Wi-Fi\n");

    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");
        print_ip_address();
    }

    while (true)
    {
        int sensor_value = 42; // Exemplo de valor do sensor
        send_to_thingspeak(sensor_value);
        sleep_ms(10000); // Enviar a cada 20 segundos
    }

    cyw43_arch_deinit();
    return 0;
}