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

static const char *TAG = "WPS_EXAMPLE";

// Funktion, um WPS zu starten (z.B. durch Button-Interrupt aufgerufen)
void start_wps_process()
{
    ESP_LOGI(TAG, "Starting WPS...");
    // esp_wifi_wps_config_t wps_config = WPS_CONFIG_INIT_DEFAULT(WPS_TYPE_PBC);
    // ESP_ERROR_CHECK(esp_wifi_wps_enable(&wps_config));
    // ESP_ERROR_CHECK(esp_wifi_wps_start(0)); // Start WPS indefinitely (handle timeout via event)
}

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)
    {
        switch (event_id)
        {
        case WIFI_EVENT_STA_START:
            ESP_LOGI(TAG, "WIFI_EVENT_STA_START: Wi-Fi station started.");
            // Option 1: Start WPS direkt hier
            // start_wps_process();
            // Option 2: Warten auf externen Trigger (z.B. Button), siehe start_wps_process()
            // Optional: Versuchen, sich normal zu verbinden, falls Zugangsdaten gespeichert sind
            // esp_wifi_connect();
            break;

        case WIFI_EVENT_STA_CONNECTED:
            ESP_LOGI(TAG, "WIFI_EVENT_STA_CONNECTED");
            // Falls verbunden (z.B. aus Flash), WPS deaktivieren, falls es noch lief
            // esp_wifi_wps_disable();
            break;

        case WIFI_EVENT_STA_DISCONNECTED:
            ESP_LOGI(TAG, "WIFI_EVENT_STA_DISCONNECTED");
            // Eventuell normalen Verbindungsversuch starten oder auf WPS-Trigger warten
            // esp_wifi_connect(); // Oder: Warte auf Button für WPS
            break;

        case WIFI_EVENT_STA_WPS_ER_SUCCESS:
            ESP_LOGI(TAG, "WIFI_EVENT_STA_WPS_ER_SUCCESS");
            // WPS erfolgreich, Zugangsdaten wurden empfangen.
            // Der Wi-Fi Stack versucht nun automatisch, sich zu verbinden.
            // WPS deaktivieren.
            ESP_ERROR_CHECK(esp_wifi_wps_disable());
            // Optional: Zugangsdaten auslesen und speichern, falls nötig (normalerweise nicht erforderlich, da der Stack sie intern nutzt)
            break;

        case WIFI_EVENT_STA_WPS_ER_FAILED:
            ESP_LOGI(TAG, "WIFI_EVENT_STA_WPS_ER_FAILED");
            ESP_ERROR_CHECK(esp_wifi_wps_disable());
            // Hier Fehlerbehandlung: Info an User, evtl. erneuten Start ermöglichen
            break;

        case WIFI_EVENT_STA_WPS_ER_TIMEOUT:
            ESP_LOGI(TAG, "WIFI_EVENT_STA_WPS_ER_TIMEOUT");
            ESP_ERROR_CHECK(esp_wifi_wps_disable());
            // Hier Fehlerbehandlung: Info an User, evtl. erneuten Start ermöglichen
            break;

        case WIFI_EVENT_STA_WPS_ER_PIN:
            ESP_LOGI(TAG, "WIFI_EVENT_STA_WPS_ER_PIN");
            // Relevant für PIN-Modus
            // wifi_event_sta_wps_er_pin_t* event = (wifi_event_sta_wps_er_pin_t*) event_data;
            // ESP_LOGI(TAG, "WPS PIN: %.*s", event->pin_code_len, event->pin_code); // Beispiel: ESP32 generiert PIN
            break;

        default:
            break;
        }
    }
    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 address: " IPSTR, IP2STR(&event->ip_info.ip));
        // Verbindung erfolgreich hergestellt
    }
}

void wifi_init_sta_wps(void)
{
    // 1. NVS initialisieren
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND)
    {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    // 2. TCP/IP Stack initialisieren
    ESP_ERROR_CHECK(esp_netif_init());

    // 3. Event Loop erstellen
    ESP_ERROR_CHECK(esp_event_loop_create_default());

    // 4. Default Wi-Fi Station Netif erstellen
    esp_netif_create_default_wifi_sta();

    // 5. Wi-Fi Treiber initialisieren
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    // 6. Event Handler registrieren
    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));

    // 7. Wi-Fi Modus auf Station setzen
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));

    // 8. Wi-Fi starten (löst WIFI_EVENT_STA_START aus)
    ESP_ERROR_CHECK(esp_wifi_start());

    ESP_LOGI(TAG, "Wi-Fi Initialisierung abgeschlossen.");
    ESP_LOGI(TAG, "Bereit für WPS Trigger (z.B. Button-Druck oder automatischen Start in STA_START).");
}