//
// 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>
#include <cJSON.h>

#include "esp_expected.hpp"

#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* TAG = "ParamProvisioner";
const char* NVS_IS_INITED = "_is_inited";

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);

  ESP_LOGI(TAG, "Post handler.");

  if (const int ret = httpd_req_recv(req, content.data_end(), size);
      ret <= 0)
  {
    ESP_LOGE(TAG, "Error, socket timeout.");
    if (ret == HTTPD_SOCK_ERR_TIMEOUT)
      httpd_resp_send_408(req);

    return ESP_FAIL;
  }

  content.trim_to_terminator();

  auto dispatch_error = [req](const char* error_str)
    {
      ESP_LOGE(TAG, "Request error: %s", error_str);
      auto json_root = CJsonPtr(cJSON_CreateObject());
      cJSON_AddStringToObject(json_root.get(), "response_str", error_str);
      auto response_str = CJsonStrPtr(cJSON_Print(json_root.get()));

      httpd_resp_set_status(req, "400 Bad Request");
      httpd_resp_set_type(req, HTTPD_TYPE_JSON);
      httpd_resp_sendstr(req, response_str.get());
    };

  etl::string<100> content_type;
  content_type.initialize_free_space();
  if (const auto err = httpd_req_get_hdr_value_str(req, "Content-Type", content_type.data_end(), content_type.available() - 1);
      err != ESP_OK)
  {
    dispatch_error("Cannot parse header.");
    return ESP_FAIL;
  }

  content_type.trim_to_terminator();

  if (content_type != "application/json")
  {
    ESP_LOGE(TAG, "Invalid content-type header: %s", content_type.c_str());
    dispatch_error("Invalid Content-Type header.");
    return ESP_FAIL;
  }

  auto json_object = CJsonPtr(cJSON_Parse(content.c_str()));
  if (!json_object || !cJSON_IsArray(json_object.get()))
  {
    dispatch_error("Invalid JSON sent.");
    return ESP_FAIL;
  }

  auto* provisioner = static_cast<WifiProvisioner*>(req->user_ctx);
  std::expected<void, const char*> result = provisioner->tryConfigureParameters(std::move(json_object));

  if (result)
  {
    httpd_resp_set_type(req, HTTPD_TYPE_JSON);

    auto json_root = CJsonPtr(cJSON_CreateObject());
    cJSON_AddStringToObject(json_root.get(), "response_str", "Configuration successful. ESP rebooting.");
    auto response_str = CJsonStrPtr(cJSON_Print(json_root.get()));
    httpd_resp_sendstr(req, response_str.get());

    ESP_LOGI(TAG, "Post successful.");

    return ESP_OK;
  }
  else
  {
    dispatch_error(result.error());
    return ESP_FAIL;
  }
}

esp_err_t parametersGetHandler_(httpd_req_t* req)
{
  auto* provisioner = static_cast<WifiProvisioner*>(req->user_ctx);
  CJsonPtr data = provisioner->getParameterObjects();
  cJSON* raw_data = data.get();

  auto stringified = CJsonStrPtr(cJSON_Print(raw_data));

  if (!stringified)
  {
    httpd_resp_send_500(req);
    return ESP_FAIL;
  }

  httpd_resp_set_type(req, "application/json");
  httpd_resp_send(req, stringified.get(), HTTPD_RESP_USE_STRLEN);

  return ESP_OK;
}

}

std::expected<WifiProvisioner::Parameter::Value, esp_err_t> WifiProvisioner::Parameter::tryReadAndAssignValue(nvs::NVSHandle* file_handle)
{
  if (type == Type::INT)
  {
    std::int32_t value = 0;
    TRY_ESP(file_handle->get_item(nvs_name.c_str(), value));
    data = value;

    return data;
  }
  else if (type == Type::FLOAT)
  {
    std::int32_t value_raw = 0;
    TRY_ESP(file_handle->get_item(nvs_name.c_str(), value_raw));
    data = std::bit_cast<float>(value_raw);

    return data;
  }
  else if (type == Type::STRING)
  {
    etl::string<100> value;
    value.initialize_free_space();

    TRY_ESP(file_handle->get_string(nvs_name.c_str(), value.data(), value.size() - 1));
    value.trim_to_terminator();

    data = value;

    return data;
  }

  return ESP_FAIL;
}

std::expected<WifiProvisioner::Parameter::Value, const char*> WifiProvisioner::Parameter::tryValidateAndAssign(cJSON* object)
{
  if (!cJSON_IsObject(object))
    return std::unexpected("Invalid parameter JSON.");

  const cJSON* in_nvs_name = cJSON_GetObjectItem(object, "nvs_name");
  if (!cJSON_IsString(in_nvs_name))
    return std::unexpected("Invalid parameter JSON.");

  if (cJSON_GetStringValue(in_nvs_name) != nvs_name)
    return std::unexpected("Mismatching parameter nvs_name. Invalid sequence or invalid parameter.");

  const cJSON* in_value = cJSON_GetObjectItem(object, "value");
  if (type == Type::INT || type == Type::FLOAT)
  {
    if (!cJSON_IsNumber(in_value))
      return std::unexpected("Mismatching or missing parameter value.");

    const double json_value = cJSON_GetNumberValue(in_value);
    if (type == Type::INT)
      return {data = Value{std::int32_t(json_value)}};
    else
      return {data = Value{float(json_value)}};
  }
  else
  {
    if (!cJSON_IsString(in_value))
      return std::unexpected("Mismatching or missing parameter value.");

    const char* json_value = cJSON_GetStringValue(in_value);
    return {data = Value{json_value}};
  }
}

WifiProvisioner::WifiProvisioner(const char* settings_namespace, etl::delegate<void (const etl::vector<Parameter, 10>&)> success_cb)
  : success_cb_(success_cb)
{
  esp_err_t err = ESP_OK;
  file_handle_ = nvs::open_nvs_handle(settings_namespace, NVS_READWRITE, &err);

  ESP_ERROR_CHECK(err);

  err = file_handle_->get_item(NVS_IS_INITED, settings_initialized_);

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

WifiProvisioner::~WifiProvisioner()
{
  if (http_server_)
  {
    httpd_stop(http_server_);
  }

  if (esp_netif_)
  {
     esp_wifi_stop();
     esp_wifi_deinit();

     esp_netif_destroy_default_wifi(esp_netif_);
     esp_event_loop_delete_default();
  }
}

bool WifiProvisioner::parametersAreConfigured()
{
  if (!settings_initialized_)
    return false;

  if (params_.empty())
    return false;

  for (auto& param : params_)
  {
    if (const auto value = param.tryReadAndAssignValue(file_handle_.get());
        !value.has_value())
    {
      settings_initialized_ = false;
      file_handle_->set_item(NVS_IS_INITED, settings_initialized_);
      file_handle_->commit();

      return false;
    }
  }

  return true;
}

void WifiProvisioner::clearSettings()
{
  if (!settings_initialized_)
    return;

  settings_initialized_ = false;
  ESP_ERROR_CHECK(file_handle_->set_item(NVS_IS_INITED, settings_initialized_));
  ESP_ERROR_CHECK(file_handle_->commit());
}

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

  http_server_ = TRY(initializeCaptivePortal_());

  return {};
}

const etl::vector<WifiProvisioner::Parameter, 10>& WifiProvisioner::getParameters()
{
  if (!settings_initialized_)
    abortWithError("WifiProvisioner read parameters without initialization.");

  return params_;
}

std::expected<WifiProvisioner::Parameter, std::error_code> WifiProvisioner::getParameter(const etl::string<15>& name)
{
  if (!settings_initialized_)
    return std::unexpected{std::make_error_code(std::errc::not_connected)};

  for (const auto& param : params_)
  {
    if (param.nvs_name == name)
      return param;
  }

  return std::unexpected{std::make_error_code(std::errc::invalid_argument)};
}

std::expected<void, std::error_code> WifiProvisioner::addParameter(const char* name, const char* nvs_name, const Parameter::Type type)
{
  if (params_.full())
    return std::unexpected(std::make_error_code(std::errc::not_enough_memory));

  auto new_param = Parameter(name, nvs_name, type);
  params_.push_back(new_param);

  return {};
}

CJsonPtr WifiProvisioner::getParameterObjects() const
{
  auto root = CJsonPtr(cJSON_CreateArray());

  for (const Parameter& param : params_)
  {
    cJSON* element = cJSON_CreateObject();
    cJSON_AddStringToObject(element, "name", param.name.c_str());
    cJSON_AddStringToObject(element, "nvs_name", param.nvs_name.c_str());
    cJSON_AddNumberToObject(element, "type", int(param.type));

    cJSON_AddItemToArray(root.get(), element);
  }

  return root;
}

std::expected<void, const char*> WifiProvisioner::tryConfigureParameters(CJsonPtr json_root)
{
  if (params_.size() != cJSON_GetArraySize(json_root.get()))
    return std::unexpected("Mismatching parameters array sizes.");

  cJSON* entry = nullptr;
  int i = 0;
  cJSON_ArrayForEach(entry, json_root)
  {
    auto& param = params_[i];
    TRY(param.tryValidateAndAssign(entry));

    i++;
  }

  const auto& result = writeAndCommitParameters_();
  if (!result.has_value())
    return std::unexpected(esp_err_to_name(result.error()));

  if (settings_initialized_ && success_cb_)
    success_cb_(params_);

  return {};
}

esp_err_t WifiProvisioner::initializeNvsNamespace_()
{
  esp_err_t err = file_handle_->set_item(NVS_IS_INITED, 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_ = 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
  };

  static httpd_uri_t uri_get_params = {
    .uri = "/parameters",
    .method = HTTP_GET,
    .handler = parametersGetHandler_,
    .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);
  }

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

  return server;
}

std::expected<void, esp_err_t> WifiProvisioner::writeAndCommitParameters_()
{
  for (const auto& param : params_)
  {
    if (param.type == Parameter::Type::INT)
    {
      TRY_ESP(file_handle_->set_item(param.nvs_name.c_str(), std::get<std::int32_t>(param.data)));
    }
    else if (param.type == Parameter::Type::FLOAT)
    {
      const auto temporary = std::bit_cast<std::int32_t>(std::get<float>(param.data));
      TRY_ESP(file_handle_->set_item(param.nvs_name.c_str(), temporary));
    }
    else
    {
      const auto temporary = std::get<etl::string<100>>(param.data);
      TRY_ESP(file_handle_->set_string(param.nvs_name.c_str(), temporary.c_str()));
    }
  }

  TRY_ESP(file_handle_->set_item(NVS_IS_INITED, true));
  TRY_ESP(file_handle_->commit());

  settings_initialized_ = true;

  return {};
}