/* Scan Example

   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/

/*
    This example shows how to scan for available set of APs.
*/
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "driver/gpio.h"
#include "esp_wifi.h"
#include "esp_log.h"
#include "esp_event.h"
#include "nvs_flash.h"

#define DEFAULT_SCAN_LIST_SIZE 7

#define LED0_GPIO GPIO_NUM_5
#define LED1_GPIO GPIO_NUM_18
#define LED2_GPIO GPIO_NUM_19
#define LED3_GPIO GPIO_NUM_21
#define LED4_GPIO GPIO_NUM_22

static void print_auth_mode(int authmode);
static void print_cipher_type(int pairwise_cipher, int group_cipher);
void wifi_scan_and_connect();
void controlar_gpios(int valor_rssi);

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_CONNECTED) {
        printf("Conectado a la red WiFi\n");
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        printf("Desconectado de la red WiFi\n");
    }
}

/* Initialize Wi-Fi as sta and set scan method */
static void wifi_scan(void)
{
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_t *sta_netif = esp_netif_create_default_wifi_sta();
    assert(sta_netif);

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

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

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_start());
    esp_wifi_scan_start(NULL, true);
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&number, ap_info));
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_num(&ap_count));
    for (int i = 0; i < number; i++) {
        printf("SSID \t%s RSSI Inicial %d", ap_info[i].ssid, ap_info[i].rssi);
    }

}

void app_main(void)
{
    // Initialize NVS
    esp_err_t ret = nvs_flash_init();
    wifi_ap_record_t ap_info;
    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 );

    wifi_scan();
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler,NULL , NULL));
    wifi_scan_and_connect();  

    while(1){
      esp_wifi_sta_get_ap_info(&ap_info);
      controlar_gpios(ap_info.rssi);
      printf("RSSI: %d\n", ap_info.rssi);
      vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

static void print_auth_mode(int authmode)
{
    switch (authmode) {
    case WIFI_AUTH_OPEN:
        printf("Authmode \tWIFI_AUTH_OPEN\n");
        break;
    case WIFI_AUTH_WEP:
        printf("Authmode \tWIFI_AUTH_WEP\n");
        break;
    case WIFI_AUTH_WPA_PSK:
        printf("Authmode \tWIFI_AUTH_WPA_PSK\n");
        break;
    case WIFI_AUTH_WPA2_PSK:
        printf("Authmode \tWIFI_AUTH_WPA2_PSK\n");
        break;
    case WIFI_AUTH_WPA_WPA2_PSK:
        printf("Authmode \tWIFI_AUTH_WPA_WPA2_PSK\n");
        break;
    case WIFI_AUTH_WPA3_PSK:
        printf("Authmode \tWIFI_AUTH_WPA3_PSK\n");
        break;
    case WIFI_AUTH_WPA2_WPA3_PSK:
        printf("Authmode \tWIFI_AUTH_WPA2_WPA3_PSK\n");
        break;
    default:
        printf("Authmode \tWIFI_AUTH_UNKNOWN\n");
        break;
    }
}

static void print_cipher_type(int pairwise_cipher, int group_cipher)
{
    switch (pairwise_cipher) {
    case WIFI_CIPHER_TYPE_NONE:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_NONE\n");
        break;
    case WIFI_CIPHER_TYPE_WEP40:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_WEP40\n");
        break;
    case WIFI_CIPHER_TYPE_WEP104:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_WEP104\n");
        break;
    case WIFI_CIPHER_TYPE_TKIP:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_TKIP\n");
        break;
    case WIFI_CIPHER_TYPE_CCMP:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_CCMP\n");
        break;
    case WIFI_CIPHER_TYPE_TKIP_CCMP:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_TKIP_CCMP\n");
        break;
    case WIFI_CIPHER_TYPE_AES_CMAC128:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_AES_CMAC128\n");
        break;
    case WIFI_CIPHER_TYPE_SMS4:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_SMS4\n");
        break;
    default:
        printf("Pairwise Cipher \tWIFI_CIPHER_TYPE_UNKNOWN\n");
        break;
    }

    switch (group_cipher) {
    case WIFI_CIPHER_TYPE_NONE:
        printf("Group Cipher \tWIFI_CIPHER_TYPE_NONE\n");
        break;
    case WIFI_CIPHER_TYPE_WEP40:
        printf("Group Cipher \tWIFI_CIPHER_TYPE_WEP40\n");
        break;
    case WIFI_CIPHER_TYPE_WEP104:
        printf("Group Cipher \tWIFI_CIPHER_TYPE_WEP104\n");
        break;
    case WIFI_CIPHER_TYPE_TKIP:
        printf("Group Cipher \tWIFI_CIPHER_TYPE_TKIP\n");
        break;
    case WIFI_CIPHER_TYPE_CCMP:
        printf("Group Cipher \tWIFI_CIPHER_TYPE_CCMP\n");
        break;
    case WIFI_CIPHER_TYPE_TKIP_CCMP:
        printf("Group Cipher \tWIFI_CIPHER_TYPE_TKIP_CCMP\n");
        break;
    case WIFI_CIPHER_TYPE_SMS4:
        printf("Group Cipher \tWIFI_CIPHER_TYPE_SMS4\n");
        break;
    default:
        printf("Group Cipher \tWIFI_CIPHER_TYPE_UNKNOWN\n");
        break;
    }
}

void connect_to_wifi(const char *ssid, const char *password) {
    wifi_config_t wifi_config = {
        .sta = {
            .ssid = "",
            .password = "",
        },
    };
    strcpy((char*)wifi_config.sta.ssid, ssid);
    strcpy((char*)wifi_config.sta.password, password);

    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
    ESP_ERROR_CHECK(esp_wifi_connect());

    
}

void wifi_scan_and_connect() {
    connect_to_wifi("Wokwi-GUEST", "");
}

void controlar_gpios(int valor_rssi) {
    if (valor_rssi >= -100 && valor_rssi <= -50) {
        gpio_set_direction(LED0_GPIO, GPIO_MODE_OUTPUT);
        gpio_set_direction(LED1_GPIO, GPIO_MODE_OUTPUT);
        gpio_set_direction(LED2_GPIO, GPIO_MODE_OUTPUT);
        gpio_set_direction(LED3_GPIO, GPIO_MODE_OUTPUT);
        gpio_set_direction(LED4_GPIO, GPIO_MODE_OUTPUT);

        // Determinar qué pines GPIO deben estar en alto según el valor de RSSI
        if (valor_rssi >= -50) {
            gpio_set_level(LED0_GPIO, 1);
            gpio_set_level(LED1_GPIO, 1);
            gpio_set_level(LED2_GPIO, 1);
            gpio_set_level(LED3_GPIO, 1);
            gpio_set_level(LED4_GPIO, 1);
        } else if (valor_rssi >= -60) {
            gpio_set_level(LED0_GPIO, 1);
            gpio_set_level(LED1_GPIO, 1);
            gpio_set_level(LED2_GPIO, 1);
            gpio_set_level(LED3_GPIO, 1);
            gpio_set_level(LED4_GPIO, 0);
        } else if (valor_rssi >= -70) {
            gpio_set_level(LED0_GPIO, 1);
            gpio_set_level(LED1_GPIO, 1);
            gpio_set_level(LED2_GPIO, 1);
            gpio_set_level(LED3_GPIO, 0);
            gpio_set_level(LED4_GPIO, 0);
        } else if (valor_rssi >= -80) {
            gpio_set_level(LED0_GPIO, 1);
            gpio_set_level(LED1_GPIO, 1);
            gpio_set_level(LED2_GPIO, 0);
            gpio_set_level(LED3_GPIO, 0);
            gpio_set_level(LED4_GPIO, 0);
        } else {
            gpio_set_level(LED0_GPIO, 1);
            gpio_set_level(LED1_GPIO, 0);
            gpio_set_level(LED2_GPIO, 0);
            gpio_set_level(LED3_GPIO, 0);
            gpio_set_level(LED4_GPIO, 0);
        }
    } 
}