//
// Created by erki on 07/01/24.
//

#include "wifi_provisioner.hpp"

#include <cstring>
#include "esp_wifi.h"
#include "esp_mac.h"
#include "esp_log.h"

#include <etl/string.h>

#define TRY(x) ({ \
  const auto& _x = (x); \
  if (!_x) {       \
    return std::unexpected(_x.error());     \
  }               \
  _x.value();               \
})

#define TRY_ESP(x) ({ \
  const esp_err_t& _x = (x); \
  if (_x != ESP_OK)    \
    return std::unexpected(_x); \
  _x;                 \
})

#define EXAMPLE_ESP_WIFI_SSID      "ESP_TEST"
#define EXAMPLE_ESP_WIFI_PASS      "1234567891"
#define EXAMPLE_ESP_WIFI_CHANNEL   5
#define EXAMPLE_MAX_STA_CONN       5

extern const char index_start[] asm("_binary_index_html_start");
extern const char index_end[] asm("_binary_index_html_end");

namespace
{

const char* NVS_WIFI_NAMESPACE = "wifi_prov";
const char* NVS_WIFI_IS_INITIALIZED = "is_inited";

const char *TAG = "wifi softAP";

ssize_t indexHtmlLength()
{
  return std::distance(index_start, index_end);
}

void wifiEventHandler_(void* arg, esp_event_base_t event_base,
                       int32_t event_id, void* event_data)
{
  if (event_id == WIFI_EVENT_AP_STACONNECTED) {
    wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data;
    ESP_LOGI(TAG, "station join, AID=%d",
             event->aid);
  } else if (event_id == WIFI_EVENT_AP_STADISCONNECTED) {
    wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
    ESP_LOGI(TAG, "station leave, AID=%d",
             event->aid);
  }
}

esp_err_t rootGetHandler_(httpd_req_t* req)
{
  httpd_resp_set_type(req, "text/html");
  httpd_resp_send(req, index_start, indexHtmlLength());
  return ESP_OK;
}

esp_err_t rootPostHandler_(httpd_req_t* req)
{
  etl::string<1024> content;

  content.initialize_free_space();
  const std::size_t size = MIN(req->content_len, content.max_size() - 1);

  if (const int ret = httpd_req_recv(req, content.data_end(), size);
      ret <= 0)
  {
    if (ret == HTTPD_SOCK_ERR_TIMEOUT)
      httpd_resp_send_408(req);

    return ESP_FAIL;
  }

  content.trim_to_terminator();

  etl::string<100> header;
  if (const auto err = httpd_req_get_hdr_value_str(req, "Content-Type", header.data(), header.max_size() - 1);
      err != ESP_OK)
  {
    ESP_LOGE(TAG, "Error reading content header.");
    return ESP_FAIL;
  }

  //httpd_query_key_value
  ESP_LOGI(TAG, "Data from post: %s, %s", header.data(), content.data());

  const char resp[] = "URI POST Response";
  httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN);
  return ESP_OK;
}

}

WifiProvisioner::WifiProvisioner()
{
  esp_err_t err = ESP_OK;
  file_handle_ = nvs::open_nvs_handle(NVS_WIFI_NAMESPACE, NVS_READWRITE, &err);

  ESP_ERROR_CHECK(err);

  err = file_handle_->get_item(NVS_WIFI_IS_INITIALIZED, wifi_initialized_);

  if (err != ESP_OK)
  {
    ESP_ERROR_CHECK(initializeNvsNamespace_());
  }
}

std::expected<void, esp_err_t> WifiProvisioner::startProvisioning()
{
  TRY(initializeWifiAp_());

  http_server_ = TRY(initializeCaptivePortal_());

  return {};
}

esp_err_t WifiProvisioner::initializeNvsNamespace_()
{
  esp_err_t err = file_handle_->set_item(NVS_WIFI_IS_INITIALIZED, false);

  if (err != ESP_OK)
    return err;

  err = file_handle_->commit();

  return err;
}

std::expected<void, esp_err_t> WifiProvisioner::initializeWifiAp_()
{
  TRY_ESP(esp_netif_init());
  TRY_ESP(esp_event_loop_create_default());
  esp_netif_create_default_wifi_ap();

  wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
  TRY_ESP(esp_wifi_init(&config));

  TRY_ESP(esp_event_handler_instance_register(
          WIFI_EVENT, ESP_EVENT_ANY_ID, &wifiEventHandler_, this, nullptr
          ));

  //https://github.com/espressif/esp-idf/blob/5524b692ee5d04d7a1000eb0c41640746fc67f3c/examples/wifi/getting_started/softAP/main/softap_example_main.c
  wifi_config_t wifi_config = {
          .ap = {
                  .ssid = EXAMPLE_ESP_WIFI_SSID,
                  .password = EXAMPLE_ESP_WIFI_PASS,
                  .ssid_len = std::uint8_t(strlen(EXAMPLE_ESP_WIFI_SSID)),
                  .channel = EXAMPLE_ESP_WIFI_CHANNEL,
#ifdef CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT
                  .authmode = WIFI_AUTH_WPA3_PSK,
#else /* CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT */
                  .authmode = WIFI_AUTH_WPA2_PSK,
#endif
                  .ssid_hidden = 0,
                  .max_connection = EXAMPLE_MAX_STA_CONN,
                  .pmf_cfg = {
                          .required = true,
                  },
#ifdef CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT
                  .sae_pwe_h2e = WPA3_SAE_PWE_BOTH,
#endif
          }
  };

  if (strlen(EXAMPLE_ESP_WIFI_PASS) == 0)
    wifi_config.ap.authmode = WIFI_AUTH_OPEN;

  TRY_ESP(esp_wifi_set_mode(WIFI_MODE_AP));
  TRY_ESP(esp_wifi_set_config(WIFI_IF_AP, &wifi_config));
  TRY_ESP(esp_wifi_start());

  return {};
}

std::expected<httpd_handle_t, esp_err_t> WifiProvisioner::initializeCaptivePortal_()
{
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  httpd_handle_t server = nullptr;

  TRY_ESP(httpd_start(&server, &config));

  static httpd_uri_t uri_main = {
    .uri = "/",
    .method = HTTP_GET,
    .handler = rootGetHandler_,
    .user_ctx = this
  };

  static httpd_uri_t uri_post = {
    .uri = "/configure",
    .method = HTTP_POST,
    .handler = rootPostHandler_,
    .user_ctx = this
  };

  if (const auto err = httpd_register_uri_handler(server, &uri_main);
      err != ESP_OK)
  {
    httpd_stop(server);
    return std::unexpected(err);
  }

  if (const auto err = httpd_register_uri_handler(server, &uri_post);
      err != ESP_OK)
  {
    httpd_stop(server);
    return std::unexpected(err);
  }

  return server;
}