Chapter 36: Managing Multiple WiFi Networks

// Example structure for storing credentials in NVS
typedef struct {
    uint8_t ssid[33];     // Max SSID length 32 + null terminator
    uint8_t password[65]; // Max password length 64 + null terminator
    // We could add wifi_auth_mode_t auth_mode; if needed
} stored_wifi_config_t;

# CMakeLists.txt (inside main component)
idf_component_register(SRCS "main.c"
                    INCLUDE_DIRS "."
                    REQUIRES nvs_flash esp_wifi esp_event esp_netif esp_log freertos)

// main.c
#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_netif.h"

static const char *TAG = "WIFI_MULTI";
static const char *NVS_NAMESPACE = "wifi_creds";

#define MAX_STORED_NETWORKS 5

// Structure for storing credentials
typedef struct {
    uint8_t ssid[33];     // Max SSID length 32 + null terminator
    uint8_t password[65]; // Max password length 64 + null terminator
    // Add wifi_auth_mode_t auth_mode if needed for different security types
} stored_wifi_config_t;

// --- NVS Helper Functions ---

// Function to save a network profile to NVS at a specific index
esp_err_t save_wifi_config_to_nvs(uint8_t index, const stored_wifi_config_t *config) {
    if (index >= MAX_STORED_NETWORKS) {
        ESP_LOGE(TAG, "Index %d out of bounds (max %d)", index, MAX_STORED_NETWORKS - 1);
        return ESP_ERR_INVALID_ARG;
    }

    nvs_handle_t nvs_handle;
    esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Error (%s) opening NVS handle!", esp_err_to_name(err));
        return err;
    }

    char key[10]; // "net_X" + null
    snprintf(key, sizeof(key), "net_%d", index);

    err = nvs_set_blob(nvs_handle, key, config, sizeof(stored_wifi_config_t));
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Error (%s) writing NVS key %s", esp_err_to_name(err), key);
    } else {
        ESP_LOGI(TAG, "Saved config for %s to NVS key %s", config->ssid, key);
        err = nvs_commit(nvs_handle); // Commit changes
        if (err != ESP_OK) {
            ESP_LOGE(TAG, "NVS commit failed!");
        }
    }

    nvs_close(nvs_handle);
    return err;
}

// Function to load a network profile from NVS from a specific index
esp_err_t load_wifi_config_from_nvs(uint8_t index, stored_wifi_config_t *config) {
     if (index >= MAX_STORED_NETWORKS) {
        ESP_LOGE(TAG, "Index %d out of bounds (max %d)", index, MAX_STORED_NETWORKS - 1);
        return ESP_ERR_INVALID_ARG;
    }

    nvs_handle_t nvs_handle;
    esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READONLY, &nvs_handle);
     if (err != ESP_OK) {
        // If namespace doesn't exist yet, it's not an error, just means no creds saved
        if (err == ESP_ERR_NVS_NOT_FOUND) {
             ESP_LOGI(TAG, "NVS namespace '%s' not found. No credentials saved yet.", NVS_NAMESPACE);
             return ESP_ERR_NVS_NOT_FOUND; // Indicate nothing loaded
        }
        ESP_LOGE(TAG, "Error (%s) opening NVS handle!", esp_err_to_name(err));
        return err;
    }

    char key[10];
    snprintf(key, sizeof(key), "net_%d", index);

    size_t required_size = sizeof(stored_wifi_config_t);
    err = nvs_get_blob(nvs_handle, key, config, &required_size);

    if (err == ESP_OK) {
        if (required_size != sizeof(stored_wifi_config_t)) {
             ESP_LOGW(TAG, "NVS blob size mismatch for key %s. Expected %d, got %d.", key, sizeof(stored_wifi_config_t), required_size);
             // Handle potential data corruption or version mismatch if needed
             err = ESP_FAIL; // Treat as error
        } else {
            ESP_LOGI(TAG, "Loaded config for %s from NVS key %s", config->ssid, key);
        }
    } else if (err == ESP_ERR_NVS_NOT_FOUND) {
        ESP_LOGI(TAG, "NVS key %s not found.", key);
        // Not necessarily an error, just means this index is empty
    } else {
        ESP_LOGE(TAG, "Error (%s) reading NVS key %s", esp_err_to_name(err), key);
    }

    nvs_close(nvs_handle);
    return err;
}

// --- Example Usage: Saving some dummy credentials ---
void save_dummy_credentials(void) {
    stored_wifi_config_t net0 = {0};
    strncpy((char*)net0.ssid, "MyHomeNetwork", sizeof(net0.ssid)-1);
    strncpy((char*)net0.password, "HomePassword123", sizeof(net0.password)-1);
    save_wifi_config_to_nvs(0, &net0);

    stored_wifi_config_t net1 = {0};
    strncpy((char*)net1.ssid, "MyOfficeNetwork", sizeof(net1.ssid)-1);
    strncpy((char*)net1.password, "OfficeKeySecure", sizeof(net1.password)-1);
    save_wifi_config_to_nvs(1, &net1);

    // Add more networks up to MAX_STORED_NETWORKS-1 if desired
    ESP_LOGI(TAG, "Dummy credentials saved (run this once or manage via other means).");
}

// main.c (continued)

// Event group to signal WiFi connection status
static EventGroupHandle_t s_wifi_event_group;
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1

// WiFi Event Handler
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_LOGI(TAG, "WIFI_EVENT_STA_START: Initiating connection scan...");
        // Start the connection logic (which includes scanning)
        // We will call a dedicated function for this later
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        wifi_event_sta_disconnected_t* event = (wifi_event_sta_disconnected_t*) event_data;
        ESP_LOGW(TAG, "WIFI_EVENT_STA_DISCONNECTED: Reason %d. Setting FAIL bit.", event->reason);
        xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
        // Optionally trigger a retry mechanism here or in the main connection logic
    } 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, "IP_EVENT_STA_GOT_IP: Got IP:" IPSTR, IP2STR(&event->ip_info.ip));
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

// Initialize WiFi Station
static void wifi_init_sta(void) {
    s_wifi_event_group = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init()); // Initialize TCP/IP stack

    ESP_ERROR_CHECK(esp_event_loop_create_default()); // Create default event loop
    esp_netif_create_default_wifi_sta(); // Create default STA network interface

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); // Default config
    ESP_ERROR_CHECK(esp_wifi_init(&cfg)); // Initialize WiFi driver

    // Register event handlers
    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,
                                                        &wifi_event_handler,
                                                        NULL,
                                                        &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
                                                        IP_EVENT_STA_GOT_IP,
                                                        &wifi_event_handler,
                                                        NULL,
                                                        &instance_got_ip));

    // Set WiFi mode to Station
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));

    // Start WiFi driver tasks
    ESP_ERROR_CHECK(esp_wifi_start());

    ESP_LOGI(TAG, "wifi_init_sta finished.");
    // Connection attempts will be triggered by WIFI_EVENT_STA_START event
}

// main.c (continued)

// Function to attempt connection using a loaded profile
static bool attempt_connection(const stored_wifi_config_t *profile) {
    wifi_config_t wifi_config = { 0 }; // Initialize fully
    strncpy((char*)wifi_config.sta.ssid, (char*)profile->ssid, sizeof(wifi_config.sta.ssid) -1);
    strncpy((char*)wifi_config.sta.password, (char*)profile->password, sizeof(wifi_config.sta.password) -1);
    wifi_config.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK; // Assuming WPA2 for simplicity, load from profile if stored
    wifi_config.sta.scan_method = WIFI_FAST_SCAN; // Or WIFI_ALL_CHANNEL_SCAN
    wifi_config.sta.sort_method = WIFI_CONNECT_AP_BY_SIGNAL; // Let driver pick best BSSID if multiple match SSID
    // wifi_config.sta.pmf_cfg = ... // Configure PMF if needed

    ESP_LOGI(TAG, "Attempting to connect to SSID: %s", profile->ssid);

    // Clear previous connection attempt results
    xEventGroupClearBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT);

    // Set configuration and connect
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
    esp_err_t ret = esp_wifi_connect();

    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "esp_wifi_connect failed: %s", esp_err_to_name(ret));
        return false;
    }

    // Wait for connection or failure event
    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
            pdFALSE, // Clear bits on exit: No (we check which bit was set)
            pdFALSE, // Wait for EITHER bit: Yes
            pdMS_TO_TICKS(20000)); // Timeout (e.g., 20 seconds)

    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG, "Successfully connected to SSID: %s", profile->ssid);
        return true;
    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGW(TAG, "Failed to connect to SSID: %s (received disconnect event)", profile->ssid);
        // Disconnect explicitly to clean up before trying next network
        esp_wifi_disconnect();
        // Short delay before trying next network to allow driver state to settle
        vTaskDelay(pdMS_TO_TICKS(500));
        return false;
    } else {
        ESP_LOGW(TAG, "Failed to connect to SSID: %s (timeout)", profile->ssid);
        // Disconnect explicitly if timed out during connection attempt
         esp_wifi_disconnect();
         vTaskDelay(pdMS_TO_TICKS(500));
        return false;
    }
}


// Main connection manager task/function
void connect_to_best_network(void) {
    ESP_LOGI(TAG, "Starting connection manager...");

    stored_wifi_config_t loaded_profiles[MAX_STORED_NETWORKS];
    uint8_t num_loaded = 0;

    // 1. Load all potential profiles from NVS
    for (uint8_t i = 0; i < MAX_STORED_NETWORKS; i++) {
        if (load_wifi_config_from_nvs(i, &loaded_profiles[num_loaded]) == ESP_OK) {
            // Check if SSID is not empty (basic validity check)
            if (strlen((char*)loaded_profiles[num_loaded].ssid) > 0) {
                 num_loaded++;
            } else {
                ESP_LOGW(TAG, "Loaded empty profile from index %d, skipping.", i);
            }
        }
    }

    if (num_loaded == 0) {
        ESP_LOGE(TAG, "No valid WiFi profiles found in NVS.");
        // Handle error: maybe enter provisioning mode, sleep, etc.
        return;
    }
    ESP_LOGI(TAG, "Loaded %d profiles from NVS.", num_loaded);


    // 2. Scan for available networks (optional for pure order-based, but good practice)
    ESP_LOGI(TAG, "Starting WiFi scan...");
    wifi_scan_config_t scan_config = {
        .ssid = NULL,
        .bssid = NULL,
        .channel = 0,
        .show_hidden = false, // Set true if needed
        .scan_type = WIFI_SCAN_TYPE_ACTIVE,
        .scan_time.active.min = 100, // ms per channel
        .scan_time.active.max = 150, // ms per channel
    };
    ESP_ERROR_CHECK(esp_wifi_scan_start(&scan_config, true)); // Blocking scan

    uint16_t ap_count = 0;
    esp_wifi_scan_get_ap_num(&ap_count);
    ESP_LOGI(TAG, "Scan finished, found %d access points.", ap_count);

    if (ap_count == 0) {
        ESP_LOGW(TAG, "No networks found in scan. Cannot connect.");
        // Retry scan later?
        return;
    }

    wifi_ap_record_t *ap_list = (wifi_ap_record_t *)malloc(ap_count * sizeof(wifi_ap_record_t));
    if (ap_list == NULL) {
        ESP_LOGE(TAG, "Failed to allocate memory for scan results");
        return;
    }
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&ap_count, ap_list));


    // 3. Match, Prioritize (Order-Based), and Attempt Connection
    bool connected = false;
    for (uint8_t i = 0; i < num_loaded; i++) { // Iterate through loaded profiles in order
        ESP_LOGI(TAG, "Checking stored profile %d: SSID '%s'", i, loaded_profiles[i].ssid);

        // Check if this profile's SSID was found in the scan results
        bool found_in_scan = false;
        for (uint16_t j = 0; j < ap_count; j++) {
            if (strcmp((char*)loaded_profiles[i].ssid, (char*)ap_list[j].ssid) == 0) {
                ESP_LOGI(TAG, "  -> SSID '%s' found in scan results (RSSI: %d).", ap_list[j].ssid, ap_list[j].rssi);
                found_in_scan = true;
                break; // Found it, no need to check further in scan results for this profile
            }
        }

        if (found_in_scan) {
            // Attempt connection using this profile
            if (attempt_connection(&loaded_profiles[i])) {
                connected = true;
                break; // Success! Stop trying other networks.
            } else {
                ESP_LOGW(TAG, "Connection attempt failed for profile %d ('%s'). Trying next.", i, loaded_profiles[i].ssid);
            }
        } else {
             ESP_LOGI(TAG, "  -> SSID '%s' not found in current scan.", loaded_profiles[i].ssid);
        }
    }

    // Free scan results memory
    free(ap_list);

    // 4. Final Status
    if (!connected) {
        ESP_LOGE(TAG, "Failed to connect to any of the stored and available networks.");
        // Implement retry logic or other failure handling here
    } else {
        ESP_LOGI(TAG, "Connection process complete. Device is connected.");
        // The IP_EVENT_STA_GOT_IP handler already signaled success via the event group bit.
    }
}

// main.c (continued)

void app_main(void)
{
    // Initialize NVS
    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);

    ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");

    // --- IMPORTANT ---
    // Uncomment the following line ONLY if you need to save the dummy credentials
    // for the first time. Comment it out for subsequent runs.
    // In a real application, manage credentials through a user interface.
    // save_dummy_credentials();
    // --- IMPORTANT ---


    // Initialize WiFi
    wifi_init_sta();

    // Now, wait for the WIFI_EVENT_STA_START event, which will trigger
    // the actual connection attempts via the handler.
    // For this example structure, we can directly call our manager function
    // after wifi_start() or trigger it from the event handler.
    // Calling it directly here for simplicity, assuming wifi_start() is synchronous enough
    // for the driver to be ready. A more robust approach might use a task
    // signaled by the WIFI_EVENT_STA_START event.

    // Let's refine: The event handler is simple, let's call connect_to_best_network
    // from app_main after wifi_init_sta() finishes. The WIFI_EVENT_STA_START
    // event isn't strictly needed to *trigger* the connection in this flow,
    // but the handler is still essential for disconnect/connect events.

    // Start the process to connect to the best available network
    connect_to_best_network();

    // Keep main task running (or do other things)
    while(1) {
        vTaskDelay(pdMS_TO_TICKS(10000)); // Idle loop
    }
}