include

#include <string.h>

#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/task.h"

#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"

#include "esp_netif.h"
#include "esp_wifi.h"
#include "esp_wifi_types.h"  // 确保有这个
#include "mqtt_client.h"

static const char *TAG = "mixio_test";

// ===== 改这里：Wi-Fi =====
#define WIFI_SSID "JXL2F"
#define WIFI_PASS "88888888"

// ===== 改这里：MixIO MQTT =====
// TCP 明文 MQTT
#define MQTT_HOST      "mixio.722400.xyz"
#define MQTT_PORT      1883

#define MQTT_USERNAME  "865000353@qq.com"
#define MQTT_PASSWORD  "4bd9ffb15f5434e991407f4ae1edb254"

#define TOPIC_SUB "865000353@qq.com/led/on"
#define TOPIC_PUB "865000353@qq.com/led/status"

static EventGroupHandle_t s_wifi_event_group;
static const int WIFI_CONNECTED_BIT = BIT0;

static esp_mqtt_client_handle_t s_mqtt = NULL;

static void wifi_event_handler(void* arg, esp_event_base_t event_base,
                               int32_t event_id, void* event_data) {
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
    wifi_event_sta_disconnected_t* d = (wifi_event_sta_disconnected_t*)event_data;
    ESP_LOGW(TAG, "WiFi disconnected, reason=%d", d->reason);
    esp_wifi_connect();
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "Got IP: " IPSTR, IP2STR(&event->ip_info.ip));
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

static void wifi_init_sta(void) {
    s_wifi_event_group = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &wifi_event_handler, NULL));

    wifi_config_t wifi_config = { 0 };
    strncpy((char*)wifi_config.sta.ssid, WIFI_SSID, sizeof(wifi_config.sta.ssid));
    strncpy((char*)wifi_config.sta.password, WIFI_PASS, sizeof(wifi_config.sta.password));

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
    ESP_ERROR_CHECK(esp_wifi_start());

    ESP_LOGI(TAG, "wifi_init_sta finished.");
}

static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
    (void)handler_args;
    (void)base;

    esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t)event_data;
    esp_mqtt_client_handle_t client = event->client;

    switch ((esp_mqtt_event_id_t)event_id) {
    case MQTT_EVENT_CONNECTED:
        ESP_LOGI(TAG, "MQTT connected");
        esp_mqtt_client_subscribe(client, TOPIC_SUB, 0);
        esp_mqtt_client_publish(client, TOPIC_PUB, "{\"boot\":true}", 0, 0, 0);
        break;

    case MQTT_EVENT_DISCONNECTED:
        ESP_LOGW(TAG, "MQTT disconnected");
        break;

    case MQTT_EVENT_SUBSCRIBED:
        ESP_LOGI(TAG, "Subscribed, msg_id=%d", event->msg_id);
        break;

    case MQTT_EVENT_DATA:
        ESP_LOGI(TAG, "RX topic=%.*s data=%.*s",
                 event->topic_len, event->topic,
                 event->data_len, event->data);
        // 回发收到的 payload 到 status
        esp_mqtt_client_publish(client, TOPIC_PUB, event->data, event->data_len, 0, 0);
        break;

    case MQTT_EVENT_ERROR:
        ESP_LOGE(TAG, "MQTT error");
        break;

    default:
        break;
    }
}

static void mqtt_app_start(void) {
    esp_mqtt_client_config_t cfg = { 0 };

    // IDF 5.x 推荐用 broker/address 结构
    cfg.broker.address.hostname = MQTT_HOST;
    cfg.broker.address.port = MQTT_PORT;
    cfg.broker.address.transport = MQTT_TRANSPORT_OVER_TCP;

    cfg.credentials.username = MQTT_USERNAME;
    cfg.credentials.authentication.password = MQTT_PASSWORD;

    s_mqtt = esp_mqtt_client_init(&cfg);
    esp_mqtt_client_register_event(s_mqtt, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
    esp_mqtt_client_start(s_mqtt);
}

void app_main(void) {
    ESP_ERROR_CHECK(nvs_flash_init());

    wifi_init_sta();

    ESP_LOGI(TAG, "Waiting for WiFi...");
    xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);

    mqtt_app_start();

    // 心跳：每 5 秒发一次（可选）
    while (1) {
        vTaskDelay(pdMS_TO_TICKS(5000));
        if (s_mqtt) {
            esp_mqtt_client_publish(s_mqtt, TOPIC_PUB, "{\"alive\":true}", 0, 0, 0);
        }
        ESP_LOGI(TAG, "alive");
    }
}