#include "wifi_manager.hpp"
#include <esp_log.h>
#include <esp_netif.h>
#include <esp_event.h>
#include <nvs_flash.h>
#include <string.h>

static const char *TAG = "wifi_manager";

WiFiManager WiFiManager::instance;

WiFiManager& WiFiManager::getInstance()
{
    return instance;
}

void WiFiManager::init(const char* ssid, const char* password)
{
    ESP_LOGI(TAG, "Initializing WiFi with SSID: %s", ssid);
    
    // Step 1: Initialize NVS (needed for WiFi storage)
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_LOGI(TAG, "Erasing NVS flash...");
        nvs_flash_erase();
        ret = nvs_flash_init();
    }
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "NVS flash init failed: %s", esp_err_to_name(ret));
        return;
    }
    
    // Step 2: Create event loop (needed for WiFi events)
    ret = esp_event_loop_create_default();
    if (ret != ESP_OK && ret != ESP_ERR_INVALID_STATE) {
        ESP_LOGE(TAG, "Event loop creation failed: %s", esp_err_to_name(ret));
        return;
    }
    
    // Step 3: Initialize network interface (needed for WiFi)
    ret = esp_netif_init();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "NetIF init failed: %s", esp_err_to_name(ret));
        return;
    }
    
    // Step 4: Create default WiFi station interface
    esp_netif_t *sta_netif = esp_netif_create_default_wifi_sta();
    if (!sta_netif) {
        ESP_LOGE(TAG, "Failed to create default WiFi station interface");
        return;
    }
    
    // Step 5: Initialize WiFi driver
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ret = esp_wifi_init(&cfg);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "WiFi init failed: %s", esp_err_to_name(ret));
        return;
    }
    
    // Step 6: Set WiFi configuration
    wifi_config_t wifi_config = {};
    strncpy((char*)wifi_config.sta.ssid, ssid, sizeof(wifi_config.sta.ssid) - 1);
    strncpy((char*)wifi_config.sta.password, password, sizeof(wifi_config.sta.password) - 1);
    wifi_config.sta.scan_method = WIFI_ALL_CHANNEL_SCAN;
    wifi_config.sta.sort_method = WIFI_CONNECT_AP_BY_SIGNAL;
    wifi_config.sta.threshold.rssi = -127;
    
    ret = esp_wifi_set_mode(WIFI_MODE_STA);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Set WiFi mode failed: %s", esp_err_to_name(ret));
        return;
    }
    
    ret = esp_wifi_set_config(WIFI_IF_STA, &wifi_config);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Set WiFi config failed: %s", esp_err_to_name(ret));
        return;
    }
    
    ESP_LOGI(TAG, "WiFi manager initialized successfully");
}

void WiFiManager::connect()
{
    ESP_LOGI(TAG, "Connecting to WiFi...");
    
    // Register event handlers
    esp_err_t ret = esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &WiFiManager::eventHandler, nullptr);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to register WiFi event handler: %s", esp_err_to_name(ret));
        return;
    }
    
    ret = esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &WiFiManager::eventHandler, nullptr);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to register IP event handler: %s", esp_err_to_name(ret));
        return;
    }
    
    ret = esp_wifi_start();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "WiFi start failed: %s", esp_err_to_name(ret));
        return;
    }
    
    ESP_LOGI(TAG, "WiFi start initiated");
}

void WiFiManager::disconnect()
{
    if (esp_wifi_stop() == ESP_OK) {
        connected = false;
        ESP_LOGI(TAG, "WiFi disconnected");
    }
}

bool WiFiManager::isConnected() const
{
    return connected;
}

const char* WiFiManager::getIpAddress() const
{
    return ip_address;
}

void WiFiManager::eventHandler(void* arg, esp_event_base_t event_base,
                               int32_t event_id, void* event_data)
{
    WiFiManager& self = getInstance();
    
    if (event_base == WIFI_EVENT) {
        if (event_id == WIFI_EVENT_STA_START) {
            ESP_LOGI(TAG, "WiFi started, requesting connection...");
            esp_err_t conn_ret = esp_wifi_connect();
            if (conn_ret != ESP_OK) {
                ESP_LOGE(TAG, "esp_wifi_connect failed on STA_START: %s", esp_err_to_name(conn_ret));
            }
        } else if (event_id == WIFI_EVENT_STA_DISCONNECTED) {
            ESP_LOGW(TAG, "WiFi disconnected, retrying...");
            self.connected = false;
            esp_err_t conn_ret = esp_wifi_connect();
            if (conn_ret != ESP_OK) {
                ESP_LOGE(TAG, "esp_wifi_connect retry failed: %s", esp_err_to_name(conn_ret));
            }
        }
    } 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;
            uint32_t ip = event->ip_info.ip.addr;
            snprintf(self.ip_address, sizeof(self.ip_address), 
                    "%u.%u.%u.%u", 
                    (unsigned int)((ip) & 0xFF),
                    (unsigned int)((ip >> 8) & 0xFF),
                    (unsigned int)((ip >> 16) & 0xFF),
                    (unsigned int)((ip >> 24) & 0xFF));
            self.connected = true;
            ESP_LOGI(TAG, "WiFi connected! IP: %s", self.ip_address);
        }
    }
}