// =========================
// wifi.c  (ESP-IDF v5.4.2)
// =========================

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

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

#include "esp_log.h"
#include "esp_err.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_mac.h"
#include "mdns.h"

#include "network_events.h"
#include "network.h"

// NEW:
#include "storage_service.h"

// -----------------------------------------------------------------------------
// Config
// -----------------------------------------------------------------------------
#define AP_SSID "plx-%02x%02x%02x"
#define MDNS_SSID "plx%02x"

#define NVS_NAMESPACE "wifi"
#define NVS_ENABLED "enabled"
#define NVS_SSID "ssid"
#define NVS_PASSWORD "password"

// Comprimentos com terminador
#define SSID_MAX_LEN 32
#define PASS_MAX_LEN 64
#define SSID_BUF_SZ (SSID_MAX_LEN + 1)
#define PASS_BUF_SZ (PASS_MAX_LEN + 1)

static const char *TAG = "wifi";

// Storage timeouts
#define STORE_TO pdMS_TO_TICKS(800)
#define STORE_FLUSH_TO pdMS_TO_TICKS(2000)

// -----------------------------------------------------------------------------
// Estado global
// -----------------------------------------------------------------------------
static esp_netif_t *sta_netif;
static esp_netif_t *ap_netif;
EventGroupHandle_t wifi_event_group;

// Backoff simples para reconexão STA
static int s_retry_count = 0;
static const int s_retry_max = 7;

// -----------------------------------------------------------------------------
// Helpers storage (robustos)
// -----------------------------------------------------------------------------

static esp_err_t store_flush_best_effort(void)
{
    esp_err_t e = storage_flush_sync(STORE_FLUSH_TO);
    if (e != ESP_OK)
        ESP_LOGW(TAG, "storage_flush_sync failed: %s", esp_err_to_name(e));
    return e;
}

static esp_err_t store_set_u8_best_effort(const char *ns, const char *key, uint8_t v)
{
    for (int attempt = 0; attempt < 3; ++attempt)
    {
        esp_err_t e = storage_set_u8_async(ns, key, v);
        if (e == ESP_OK)
            return ESP_OK;

        if (e == ESP_ERR_TIMEOUT)
        {
            (void)store_flush_best_effort();
            vTaskDelay(pdMS_TO_TICKS(10));
            continue;
        }
        return e;
    }
    return ESP_ERR_TIMEOUT;
}

static esp_err_t store_set_str_best_effort(const char *ns, const char *key, const char *s)
{
    for (int attempt = 0; attempt < 3; ++attempt)
    {
        esp_err_t e = storage_set_str_async(ns, key, s);
        if (e == ESP_OK)
            return ESP_OK;

        if (e == ESP_ERR_TIMEOUT)
        {
            (void)store_flush_best_effort();
            vTaskDelay(pdMS_TO_TICKS(10));
            continue;
        }
        return e;
    }
    return ESP_ERR_TIMEOUT;
}

// Lê string de forma segura (lê para buffer grande e depois trunca para out)
// Nota: isto ajuda se houver lixo antigo no NVS com strings maiores do que o esperado.
static esp_err_t store_get_str_safe(const char *ns, const char *key, char *out, size_t out_sz)
{
    if (!out || out_sz == 0)
        return ESP_ERR_INVALID_ARG;

    out[0] = '\0';

    // buffer grande (sem heap): usa o máximo definido no storage_service
    char tmp[STORAGE_MAX_VALUE_BYTES + 1];
    memset(tmp, 0, sizeof(tmp));

    esp_err_t e = storage_get_str_sync(ns, key, tmp, sizeof(tmp), STORE_TO);
    if (e == ESP_ERR_NOT_FOUND)
    {
        out[0] = '\0';
        return ESP_OK;
    }
    if (e != ESP_OK)
    {
        out[0] = '\0';
        return e;
    }

    size_t n = strnlen(tmp, out_sz - 1); // no máximo out_sz-1
    memcpy(out, tmp, n);
    out[n] = '\0';
    return ESP_OK;
}

// -----------------------------------------------------------------------------
// Eventos
// -----------------------------------------------------------------------------
static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
{
    (void)arg;

    if (event_base == WIFI_EVENT)
    {
        switch (event_id)
        {
        case WIFI_EVENT_AP_STACONNECTED:
        {
            ESP_LOGI(TAG, "AP: STA connected");
            wifi_event_ap_staconnected_t *event = (wifi_event_ap_staconnected_t *)event_data;
            ESP_LOGI(TAG, "WiFi AP " MACSTR " join, AID=%d", MAC2STR(event->mac), event->aid);
            xEventGroupClearBits(wifi_event_group, WIFI_AP_DISCONNECTED_BIT);
            xEventGroupSetBits(wifi_event_group, WIFI_AP_CONNECTED_BIT);
            break;
        }
        case WIFI_EVENT_AP_STADISCONNECTED:
        {
            ESP_LOGI(TAG, "AP: STA disconnected");
            wifi_event_ap_stadisconnected_t *event = (wifi_event_ap_stadisconnected_t *)event_data;
            ESP_LOGI(TAG, "WiFi AP " MACSTR " leave, AID=%d", MAC2STR(event->mac), event->aid);
            xEventGroupClearBits(wifi_event_group, WIFI_AP_CONNECTED_BIT);
            xEventGroupSetBits(wifi_event_group, WIFI_AP_DISCONNECTED_BIT);
            break;
        }
        case WIFI_EVENT_STA_START:
        {
            ESP_LOGI(TAG, "STA start");
            s_retry_count = 0;
            esp_wifi_connect();
            break;
        }
        case WIFI_EVENT_STA_CONNECTED:
        {
            ESP_LOGI(TAG, "STA associated (L2 connected)");
            esp_event_post(NETWORK_EVENTS,
                           NETWORK_EVENT_STA_CONNECTED,
                           NULL,
                           0,
                           portMAX_DELAY);
            break;
        }
        case WIFI_EVENT_STA_DISCONNECTED:
        {
            xEventGroupClearBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
            xEventGroupSetBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);

            wifi_event_sta_disconnected_t *ev = (wifi_event_sta_disconnected_t *)event_data;
            ESP_LOGW(TAG, "STA disconnected, reason=%d", ev ? ev->reason : -1);

            esp_event_post(NETWORK_EVENTS,
                           NETWORK_EVENT_STA_DISCONNECTED,
                           ev,
                           ev ? sizeof(*ev) : 0,
                           portMAX_DELAY);

            if (s_retry_count < s_retry_max)
            {
                esp_err_t err = esp_wifi_connect();
                if (err == ESP_OK)
                {
                    s_retry_count++;
                    ESP_LOGI(TAG, "Retrying connection (%d/%d)", s_retry_count, s_retry_max);
                }
                else
                {
                    ESP_LOGW(TAG, "esp_wifi_connect failed (%s)", esp_err_to_name(err));
                }
            }
            else
            {
                ESP_LOGE(TAG, "Max retries reached");
            }
            break;
        }
        default:
            break;
        }
    }
    else if (event_base == IP_EVENT)
    {
        if (event_id == IP_EVENT_STA_GOT_IP)
        {
            ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
            ESP_LOGI(TAG, "WiFi STA got ip: " IPSTR, IP2STR(&event->ip_info.ip));
            xEventGroupClearBits(wifi_event_group, WIFI_STA_DISCONNECTED_BIT);
            xEventGroupSetBits(wifi_event_group, WIFI_STA_CONNECTED_BIT);
            s_retry_count = 0;

            esp_event_post(NETWORK_EVENTS,
                           NETWORK_EVENT_STA_GOT_IP,
                           &event->ip_info,
                           sizeof(event->ip_info),
                           portMAX_DELAY);
        }
        else if (event_id == IP_EVENT_STA_LOST_IP)
        {
            ESP_LOGW(TAG, "STA lost IP");
            esp_event_post(NETWORK_EVENTS,
                           NETWORK_EVENT_STA_LOST_IP,
                           NULL,
                           0,
                           portMAX_DELAY);
        }
    }
}

// -----------------------------------------------------------------------------
// Config STA/AP
// -----------------------------------------------------------------------------
static void sta_set_config(void)
{
    ESP_LOGI(TAG, "sta_set_config");

    if (!wifi_get_enabled())
        return;

    wifi_config_t wifi_config = {0};
    wifi_config.sta.pmf_cfg.capable = true;
    wifi_config.sta.pmf_cfg.required = false;

    char ssid_buf[SSID_BUF_SZ] = {0};
    char pass_buf[PASS_BUF_SZ] = {0};
    wifi_get_ssid(ssid_buf);
    wifi_get_password(pass_buf);

    size_t ssid_len = strnlen(ssid_buf, SSID_MAX_LEN);
    memcpy(wifi_config.sta.ssid, ssid_buf, ssid_len);

    size_t pass_len = strnlen(pass_buf, 63);
    memcpy(wifi_config.sta.password, pass_buf, pass_len);
    if (pass_len <= 63)
        wifi_config.sta.password[pass_len] = '\0';

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

static void ap_set_config(void)
{
    ESP_LOGI(TAG, "ap_set_config");

    wifi_config_t wifi_ap_config = {0};
    wifi_ap_config.ap.max_connection = 1;
    wifi_ap_config.ap.authmode = WIFI_AUTH_OPEN;

    uint8_t mac[6];
    esp_wifi_get_mac(WIFI_IF_AP, mac);
    snprintf((char *)wifi_ap_config.ap.ssid, sizeof(wifi_ap_config.ap.ssid),
             AP_SSID, mac[3], mac[4], mac[5]);

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_ap_config));
}

// -----------------------------------------------------------------------------
// Arranque STA
// -----------------------------------------------------------------------------
static void sta_try_start(void)
{
    ESP_LOGI(TAG, "sta_try_start");

    sta_set_config();
    if (wifi_get_enabled())
    {
        ESP_LOGI(TAG, "Starting STA");
        esp_err_t e = esp_wifi_start();
        if (e != ESP_OK && e != ESP_ERR_WIFI_CONN)
        {
            ESP_LOGW(TAG, "esp_wifi_start returned %s", esp_err_to_name(e));
        }
        xEventGroupSetBits(wifi_event_group, WIFI_STA_MODE_BIT);
    }
}

// -----------------------------------------------------------------------------
// API pública
// -----------------------------------------------------------------------------
void wifi_ini(void)
{
    ESP_LOGI(TAG, "Wifi init");

    // garante storage pronto (não assume NVS handle aberto aqui)
    esp_err_t se = storage_service_init();
    if (se != ESP_OK)
        ESP_LOGW(TAG, "storage_service_init failed: %s", esp_err_to_name(se));

    wifi_event_group = xEventGroupCreate();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();

    ap_netif = esp_netif_create_default_wifi_ap();
    sta_netif = esp_netif_create_default_wifi_sta();

    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));

    uint8_t mac[6];
    esp_wifi_get_mac(WIFI_IF_STA, mac);
    char chargeid[16];
    snprintf(chargeid, sizeof(chargeid), MDNS_SSID, 0);

    ESP_ERROR_CHECK(esp_netif_set_hostname(sta_netif, chargeid));
    ESP_ERROR_CHECK(esp_netif_set_hostname(ap_netif, chargeid));

    ESP_ERROR_CHECK(mdns_init());
    ESP_ERROR_CHECK(mdns_hostname_set(chargeid));
    ESP_ERROR_CHECK(mdns_instance_name_set("EVSE controller"));

    sta_try_start();
}

esp_netif_t *wifi_get_sta_netif(void) { return sta_netif; }
esp_netif_t *wifi_get_ap_netif(void) { return ap_netif; }

esp_err_t wifi_set_config(bool enabled, const char *ssid, const char *password)
{
    ESP_LOGI(TAG, "wifi_set_config(enabled=%d)", enabled);

    // Validação
    if (enabled)
    {
        if (ssid && (strlen(ssid) == 0 || strlen(ssid) > SSID_MAX_LEN))
        {
            ESP_LOGE(TAG, "SSID out of range");
            return ESP_ERR_INVALID_ARG;
        }
        if (!ssid)
        {
            char cur_ssid[SSID_BUF_SZ] = {0};
            wifi_get_ssid(cur_ssid);
            if (strlen(cur_ssid) == 0)
            {
                ESP_LOGE(TAG, "Required SSID");
                return ESP_ERR_INVALID_ARG;
            }
        }

        if (password)
        {
            size_t lp = strlen(password);
            if (lp != 0 && (lp < 8 || lp > 63))
            {
                ESP_LOGE(TAG, "Password length must be 8..63");
                return ESP_ERR_INVALID_ARG;
            }
        }
    }

    // Persiste via storage_service
    esp_err_t err = store_set_u8_best_effort(NVS_NAMESPACE, NVS_ENABLED, enabled ? 1 : 0);
    if (err != ESP_OK)
        return err;

    if (ssid)
    {
        err = store_set_str_best_effort(NVS_NAMESPACE, NVS_SSID, ssid);
        if (err != ESP_OK)
            return err;
    }

    if (password)
    {
        err = store_set_str_best_effort(NVS_NAMESPACE, NVS_PASSWORD, password);
        if (err != ESP_OK)
            return err;
    }

    // Força persistência (para sobreviver a reboot imediato)
    (void)store_flush_best_effort();

    // Reinicia modo
    ESP_LOGI(TAG, "Stopping AP/STA");
    xEventGroupClearBits(wifi_event_group, WIFI_AP_MODE_BIT | WIFI_STA_MODE_BIT);
    esp_err_t e = esp_wifi_stop();
    if (e != ESP_OK && e != ESP_ERR_WIFI_NOT_INIT && e != ESP_ERR_WIFI_STOP_STATE)
    {
        ESP_LOGW(TAG, "esp_wifi_stop returned %s", esp_err_to_name(e));
    }

    sta_try_start();
    return ESP_OK;
}

uint16_t wifi_scan(wifi_scan_ap_t *scan_aps)
{
    ESP_LOGI(TAG, "wifi_scan");

    if (!scan_aps)
        return 0;

    uint16_t number = WIFI_SCAN_SCAN_LIST_SIZE;
    wifi_ap_record_t ap_info[WIFI_SCAN_SCAN_LIST_SIZE];
    uint16_t ap_count = 0;
    memset(ap_info, 0, sizeof(ap_info));

    esp_err_t err = esp_wifi_scan_start(NULL, true);
    if (err != ESP_OK)
    {
        ESP_LOGW(TAG, "esp_wifi_scan_start failed (%s)", esp_err_to_name(err));
        return 0;
    }

    err = esp_wifi_scan_get_ap_records(&number, ap_info);
    if (err != ESP_OK)
    {
        ESP_LOGW(TAG, "esp_wifi_scan_get_ap_records failed (%s)", esp_err_to_name(err));
        return 0;
    }

    err = esp_wifi_scan_get_ap_num(&ap_count);
    if (err != ESP_OK)
    {
        ESP_LOGW(TAG, "esp_wifi_scan_get_ap_num failed (%s)", esp_err_to_name(err));
        return 0;
    }

    ESP_LOGI(TAG, "wifi_scan --- %d", ap_count);

    for (int i = 0; (i < WIFI_SCAN_SCAN_LIST_SIZE) && (i < ap_count); i++)
    {
        snprintf(scan_aps[i].ssid, sizeof(scan_aps[i].ssid), "%s", (const char *)ap_info[i].ssid);
        scan_aps[i].rssi = ap_info[i].rssi;
        scan_aps[i].auth = ap_info[i].authmode != WIFI_AUTH_OPEN;
    }

    return ap_count;
}

bool wifi_get_enabled(void)
{
    uint8_t value = 0;
    esp_err_t e = storage_get_u8_sync(NVS_NAMESPACE, NVS_ENABLED, &value, STORE_TO);
    if (e == ESP_ERR_NOT_FOUND)
        return false;
    if (e != ESP_OK)
    {
        ESP_LOGW(TAG, "storage_get_u8_sync(enabled) failed (%s), assuming disabled", esp_err_to_name(e));
        return false;
    }
    return (value != 0);
}

void wifi_get_ssid(char *value)
{
    if (!value)
        return;
    (void)store_get_str_safe(NVS_NAMESPACE, NVS_SSID, value, SSID_BUF_SZ);
}

void wifi_get_password(char *value)
{
    if (!value)
        return;
    (void)store_get_str_safe(NVS_NAMESPACE, NVS_PASSWORD, value, PASS_BUF_SZ);
}

void wifi_ap_start(void)
{
    ESP_LOGI(TAG, "Starting AP");

    esp_event_post(NETWORK_EVENTS, NETWORK_EVENT_AP_STARTED, NULL, 0, portMAX_DELAY);

    xEventGroupClearBits(wifi_event_group, WIFI_STA_MODE_BIT);
    esp_wifi_stop();

    ap_set_config();
    esp_err_t e = esp_wifi_start();
    if (e != ESP_OK && e != ESP_ERR_WIFI_CONN)
    {
        ESP_LOGW(TAG, "esp_wifi_start (AP) returned %s", esp_err_to_name(e));
    }

    xEventGroupSetBits(wifi_event_group, WIFI_AP_MODE_BIT);
}

void wifi_ap_stop(void)
{
    ESP_LOGI(TAG, "Stopping AP");

    esp_event_post(NETWORK_EVENTS, NETWORK_EVENT_AP_STOP, NULL, 0, portMAX_DELAY);

    xEventGroupClearBits(wifi_event_group, WIFI_AP_MODE_BIT);
    esp_wifi_stop();

    sta_try_start();
}

bool wifi_is_ap(void)
{
    if (!wifi_event_group)
        return false;

    EventBits_t bits = xEventGroupGetBits(wifi_event_group);
    return (bits & WIFI_AP_MODE_BIT) != 0;
}