#include <sys/cdefs.h>
/**
 * @Author: 李建
 * @Date: 2025/3/18 10:23
 * Description: wifi 相关操作
 * Copyright: Copyright (©) 2025 永续绿建. All rights reserved.
 */
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include <freertos/event_groups.h>
#include <esp_wifi_types.h>
#include <esp_netif.h>
#include <esp_event.h>
#include <esp_wifi_default.h>
#include <esp_wifi.h>
#include <esp_log.h>
#include <string.h>
#include "wifi.h"
#include "lvgl_port.h"
#include "framework/system/miscellaneous_interface.h"
#include "main.h"
#include "framework.h"
#include "framework_compat.h"

bool wifi_scan_status;

bool get_var_wifi_scan_status() {
    return wifi_scan_status;
}

static wifi_connect_cb cb;

void set_var_wifi_scan_status(bool value) {
    wifi_scan_status = value;
}

#define DEFAULT_SCAN_LIST_SIZE   10                // 最大扫描wifi个数
// wifi事件组
static EventGroupHandle_t s_wifi_event_group;
// wifi事件
#define WIFI_CONNECTED_BIT    BIT0
#define WIFI_FAIL_BIT         BIT1
#define WIFI_START_BIT        BIT2

#define NVS_SSID_KEY  "wifi_ssid" // nvs 保存ssid的key
#define NVS_PASSWORD_KEY  "wifi_password" // nvs 保存wifi密码的key
EventGroupHandle_t frame_work_event_group;
// wifi最大重连次数
static uint8_t ESP_MAXIMUM_RETRY = 0;

static bool wifi_is_connected = false;

static const char *TAG = "wifi-setting";
// wifi账号队列
static QueueHandle_t xQueueWifiAccount = NULL;
static int s_retry_num = 0;
static bool is_scanning =false;
static int wifi_connect_state = 0; // 0：手动 1：自动
// 队列要传输的内容
typedef struct {
    char wifi_ssid[32];  // 获取wifi名称
    char wifi_password[64]; // 获取wifi密码
} wifi_account_t;

// 读取本地存储的wifi账号和密码，并尝试连接
static void connect_wifi(void) {
    char *ssid = yx_data_get(NVS_SSID_KEY);
    char *pwd = yx_data_get(NVS_PASSWORD_KEY);
    if (ssid && pwd) {
        ESP_LOGI(TAG, "Found saved WiFi config - SSID: %s", ssid);
        wifi_connect_state = 1;  // 标记为自动连接状态
        // 发送连接信息
        wifi_account_t wifi_account;
        strcpy(wifi_account.wifi_ssid, ssid);
        strcpy(wifi_account.wifi_password, pwd);
        xQueueSend(xQueueWifiAccount, &wifi_account, 0);
    }
}

static void 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) {
        xEventGroupSetBits(s_wifi_event_group, WIFI_START_BIT);
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if(ESP_MAXIMUM_RETRY ==0) { // 自动连接时，无限重试
            esp_wifi_connect();
        } else {
            // 手动连接时，限制次数
            if (s_retry_num < ESP_MAXIMUM_RETRY) {
                esp_wifi_connect();
                s_retry_num++;
                ESP_LOGI(TAG, "retry to connect to the AP");
            } else {
                xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
                s_retry_num = 0;
            }
        }
        ESP_LOGI(TAG, "connect to the AP fail");
        wifi_is_connected = false;
        yxlj_framework_deinit();
        lvgl_port_lock(-1);
        lv_obj_add_flag(guider_ui.screen_main_label_wifi, LV_OBJ_FLAG_HIDDEN);
        lvgl_port_unlock();
    } 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));
        wifi_is_connected = true;
        s_retry_num = 0;
        lvgl_port_lock(-1);
        // 显示wifi图标
        lv_obj_clear_flag(guider_ui.screen_main_label_wifi, LV_OBJ_FLAG_HIDDEN);
        lvgl_port_unlock();
        yxlj_framework_init();
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

// 扫描附近wifi
static void wifi_scan(wifi_ap_record_t ap_info[], uint16_t *ap_number) {
    uint16_t ap_count = 0;
    memset(ap_info, 0, *ap_number * sizeof(wifi_ap_record_t));
    esp_wifi_scan_start(NULL, true);
    ESP_LOGI(TAG, "Max AP number ap_info can hold = %u", *ap_number);
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_num(&ap_count));  // 获取扫描到的wifi数量
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(ap_number, ap_info)); // 获取真实的获取到wifi数量和信息
    ESP_LOGI(TAG, "Total APs scanned = %u, actual AP number ap_info holds = %u", ap_count, *ap_number);
    is_scanning = false;
}

/**
 * 点击列表项的事件回调
 * @param e
 */
static void list_btn_cb(lv_event_t *e) {
    // 隐藏扫描的列表
    lv_obj_add_flag(guider_ui.SettingPage_list_wifi, LV_OBJ_FLAG_HIDDEN);
    // 获取点击到的WiFi名称
    const char *wifi_name = NULL;
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t *obj = lv_event_get_target(e);
    if (code == LV_EVENT_CLICKED) {
        wifi_name = lv_list_get_btn_text(guider_ui.SettingPage_list_wifi, obj);
        ESP_LOGI(TAG, "WLAN Name: %s", wifi_name);
    }
    lvgl_port_lock(0);
    lv_obj_clear_flag(guider_ui.SettingPage_p_wifi_connect, LV_OBJ_FLAG_HIDDEN);
    lv_label_set_text(guider_ui.SettingPage_lab_wifi_ssid, wifi_name);
    lv_obj_align(guider_ui.SettingPage_lab_wifi_ssid, LV_ALIGN_TOP_MID, 0, 10);
    lvgl_port_unlock();

}

/**
 * wifi连接任务
 * @param arg
 */
void wifi_connect_task(void *arg) {
    wifi_account_t wifi_account;
    while (true) {
        if (xQueueReceive(xQueueWifiAccount, &wifi_account, portMAX_DELAY)) {
            wifi_config_t wifi_config = {
                    .sta = {
                            .threshold.authmode = WIFI_AUTH_WPA_WPA2_PSK,
                            .sae_pwe_h2e = WPA3_SAE_PWE_BOTH,
                            .sae_h2e_identifier = "",
                            .pmf_cfg = {
                                    .capable = true,
                                    .required = false},
                    },
            };

            // 不管是自动连接还是手动连接，都需要设置WiFi配置
            strcpy((char *) wifi_config.sta.ssid, wifi_account.wifi_ssid);
            strcpy((char *) wifi_config.sta.password, wifi_account.wifi_password);

            ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
            ESP_LOGI(TAG, "trying to connect to ap SSID:%s password:%s",
                     wifi_config.sta.ssid, wifi_config.sta.password);
            ESP_ERROR_CHECK(esp_wifi_connect());
            EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
                                                   WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
                                                   pdTRUE,
                                                   pdFALSE,
                                                   portMAX_DELAY);

            if (bits & WIFI_CONNECTED_BIT) {
                ESP_LOGI(TAG, "connected to ap SSID:%s password:%s",
                         wifi_config.sta.ssid, wifi_config.sta.password);
                if(wifi_connect_state == 0) {
                    yx_data_set(NVS_SSID_KEY,
                                (char *) wifi_config.sta.ssid);
                    yx_data_set(NVS_PASSWORD_KEY,
                                (char *) wifi_config.sta.password);
                    ESP_MAXIMUM_RETRY = 0;
                    lvgl_port_lock(-1);
                    lv_label_set_text_static(guider_ui.SettingPage_lab_wifi_status, "连接成功");
                    lv_obj_set_style_text_color(guider_ui.SettingPage_lab_wifi_status, lv_color_hex(0x00ff00), LV_PART_MAIN);
                    lv_obj_add_flag(guider_ui.SettingPage_sp_wifi_scan, LV_OBJ_FLAG_HIDDEN);
                    lv_obj_remove_state(guider_ui.SettingPage_btn_2, LV_STATE_DISABLED);
                    lvgl_port_unlock();
                } else {
                    if(guider_ui.screen_main){
                        lvgl_port_lock(-1);
                        // 显示wifi图标
                        lv_obj_clear_flag(guider_ui.screen_main_label_wifi, LV_OBJ_FLAG_HIDDEN);
                        lvgl_port_unlock();
                    }
                }
                lvgl_port_lock(-1);
                // 显示wifi图标
                lv_obj_clear_flag(guider_ui.screen_main_label_wifi, LV_OBJ_FLAG_HIDDEN);
                lvgl_port_unlock();
                ESP_LOGI(TAG, "Wi-Fi connected, deleting wifi_connect_task task");
                // 执行回调
                if(cb != NULL) {
                    cb();
                }
                vTaskDelete(NULL);
            } else if (bits & WIFI_FAIL_BIT) {
                ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s",
                         wifi_config.sta.ssid, wifi_config.sta.password);
                if(wifi_connect_state == 0)
                {
                    lvgl_port_lock(-1);
                    lv_label_set_text(guider_ui.SettingPage_lab_wifi_status, "连接失败");
                    lv_obj_set_style_text_color(guider_ui.SettingPage_lab_wifi_status, lv_color_hex(0xff0000), LV_PART_MAIN);
                    lv_obj_add_flag(guider_ui.SettingPage_sp_wifi_scan, LV_OBJ_FLAG_HIDDEN);
                    lv_obj_remove_state(guider_ui.SettingPage_btn_2, LV_STATE_DISABLED);
                    lvgl_port_unlock();
                }
                lvgl_port_lock(-1);
                lv_obj_add_flag(guider_ui.screen_main_label_wifi, LV_OBJ_FLAG_HIDDEN);
                lvgl_port_unlock();
            }
        }
    }
}


_Noreturn static void monitor_mqtt_task(void * pv) {
    for(;;) {
        EventBits_t bits = xEventGroupWaitBits(frame_work_event_group,
                                               MQTT_DISCONNECTED,
                                               pdTRUE,
                                               pdFALSE,
                                               portMAX_DELAY);
        if(bits & MQTT_DISCONNECTED) {
            if(get_wifi_status()) {
                yxlj_framework_init();
            }
        }
    }
}

/**
 * wifi功能初始化
 */

void app_wifi_init(wifi_connect_cb _cb) {
    cb = _cb;
    s_wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_event_loop_create_default());//创建一个默认系统事件调度循环，之后可以注册回调函数来处理系统的一些事件
    esp_netif_t *sta_netif = esp_netif_create_default_wifi_sta();//使用默认配置创建STA对象
    assert(sta_netif);

    //初始化WIFI
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));


    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    //注册事件
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
                                                        ESP_EVENT_ANY_ID,
                                                        &event_handler,
                                                        NULL,
                                                        &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
                                                        IP_EVENT_STA_GOT_IP,
                                                        &event_handler,
                                                        NULL,
                                                        &instance_got_ip));
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_start());
    ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));

    // 创建wifi连接任务
    xQueueWifiAccount = xQueueCreate(2, sizeof(wifi_account_t));
    frame_work_event_group = xEventGroupCreate();
    xTaskCreatePinnedToCore(wifi_connect_task, "wifi_connect_task", 3 * 1024, NULL, 5, NULL, 1);
    xTaskCreate(monitor_mqtt_task, "monitor_task", 1024, NULL, 5, NULL);
    // 尝试连接wifi
    connect_wifi();
}

void app_connect_wifi() {
    ESP_LOGI(TAG, "OK Clicked");
    s_retry_num = 0;
    wifi_connect_state = 0;
    ESP_MAXIMUM_RETRY = 5;
    xEventGroupClearBits(s_wifi_event_group, WIFI_FAIL_BIT | WIFI_CONNECTED_BIT | WIFI_START_BIT);
    const char *wifi_ssid = lv_label_get_text(guider_ui.SettingPage_lab_wifi_ssid);
    const char *wifi_password = lv_textarea_get_text(guider_ui.SettingPage_txt_wifi_password);
    if (*wifi_password != '\0') // 判断是否为空字符串
    {
        wifi_account_t wifi_account;
        strcpy(wifi_account.wifi_ssid, wifi_ssid);
        strcpy(wifi_account.wifi_password, wifi_password);
        ESP_LOGI(TAG, "connect to ap SSID:%s password:%s",
                 wifi_account.wifi_ssid, wifi_account.wifi_password);
        ESP_ERROR_CHECK( esp_wifi_disconnect());
        lvgl_port_lock(-1);
        lv_label_set_text(guider_ui.SettingPage_lab_wifi_status, "正在连接");
        lvgl_port_unlock();
        // 发送WiFi账号密码信息到队列
        wifi_connect_state = 0;
        xQueueSend(xQueueWifiAccount, &wifi_account, portMAX_DELAY);
    }
}

void app_wifi_scan(void) {
    if(is_scanning)return;
    is_scanning = true;
    // 扫描WLAN信息
    wifi_ap_record_t ap_info[DEFAULT_SCAN_LIST_SIZE];
    uint16_t ap_number = DEFAULT_SCAN_LIST_SIZE;
    wifi_scan(ap_info, &ap_number); // 扫描附近wifi
    // 先读取保存的ssid和密码来连接
    char *ssid = yx_data_get(NVS_SSID_KEY);
    char *pwd = yx_data_get(NVS_PASSWORD_KEY);
    if (ssid && pwd) {
        ESP_LOGI(TAG, "Found saved WiFi config - SSID: %s", ssid);
    }
    lv_obj_clear_flag(guider_ui.SettingPage_sp_wifi_scan, LV_OBJ_FLAG_HIDDEN);
    // 显示wifi信息
    lv_obj_t *btn;

    for (int i = 0; i < ap_number; i++) {
        bool found = false;
        ESP_LOGI(TAG, "Comparing with scanned SSID: %s", (char *) ap_info[i].ssid);
        if (ssid && strcmp((char *) ap_info[i].ssid, ssid) == 0) {
            found = true;
        }

        ESP_LOGI(TAG, "SSID \t\t%s", ap_info[i].ssid);  // 终端输出wifi名称
        ESP_LOGI(TAG, "RSSI \t\t%d", ap_info[i].rssi);  // 终端输出wifi信号质量
        // 添加wifi列表
        btn = lv_list_add_btn(guider_ui.SettingPage_list_wifi, LV_SYMBOL_WIFI, (const char *) ap_info[i].ssid);
        if (found)
            lv_obj_set_style_text_color(btn, lv_color_hex(0x00FF00), LV_PART_MAIN);
        lv_obj_add_event_cb(btn, list_btn_cb, LV_EVENT_CLICKED, NULL); // 添加点击回调函数
    }
    lv_obj_add_flag(guider_ui.SettingPage_sp_wifi_scan, LV_OBJ_FLAG_HIDDEN);
    lv_obj_clear_flag(guider_ui.SettingPage_list_wifi, LV_OBJ_FLAG_HIDDEN);
    lvgl_port_unlock();
}

/*
 * wifi连接状态查询
 * 返回：1：连接 0：未连接
 */
int get_wifi_status() {

    if (wifi_is_connected) {
        return 1;
    } else
        return 0;
}