/* HTTP Restful API Server

   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.
*/
#include <string.h>
#include <fcntl.h>
#include "esp_http_server.h"
#include "esp_chip_info.h"
#include "esp_random.h"
#include "esp_log.h"
#include "esp_vfs.h"
#include "cJSON.h"
#include "rest.h"
#include "evse_api.h"
#include "cJSON.h"
#include "esp_log.h"
#include "esp_http_server.h"
#include "auth.h"

static const char *REST_TAG = "esp-rest";
#define REST_CHECK(a, str, goto_tag, ...)                                              \
    do                                                                                 \
    {                                                                                  \
        if (!(a))                                                                      \
        {                                                                              \
            ESP_LOGE(REST_TAG, "%s(%d): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
            goto goto_tag;                                                             \
        }                                                                              \
    } while (0)

#define FILE_PATH_MAX (ESP_VFS_PATH_MAX + 128)
#define SCRATCH_BUFSIZE (10240)

typedef struct rest_server_context {
    char base_path[ESP_VFS_PATH_MAX + 1];
    char scratch[SCRATCH_BUFSIZE];
} rest_server_context_t;

#define CHECK_FILE_EXTENSION(filename, ext) (strcasecmp(&filename[strlen(filename) - strlen(ext)], ext) == 0)

// Estruturas para armazenar as configurações
static struct {
    bool enabled;
    char ssid[128];
    char password[128];
} wifi_config = {false, "", ""};

static struct {
    bool enabled;
    char host[256];
    int port;
    char username[128];
    char password[128];
    char topic[128];
} mqtt_config = {false, "", 1883, "", "", ""};

// Estrutura para armazenar as configurações OCPP em memória
static struct {
    char url[256];
    char chargeBoxId[128];
    char certificate[256];
    char privateKey[256];
} ocpp_config = {"", "", "", ""};

// Estrutura para armazenar as configurações de energia
static struct {
    int currentLimit;
    int powerLimit;
    int energyLimit;
    int chargingTimeLimit;
    int temperatureLimit;
} settings_config = {0, 0, 0, 0, 0};

static struct {
    char username[128];
} users[10] = {{"admin"}, {"user1"}};
static int num_users = 2; // Contador de usuários cadastrados


// Set HTTP response content type according to file extension
static esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filepath)
{
    const char *type = "text/plain";
    if (CHECK_FILE_EXTENSION(filepath, ".html")) {
        type = "text/html";
    } else if (CHECK_FILE_EXTENSION(filepath, ".js")) {
        type = "application/javascript";
    } else if (CHECK_FILE_EXTENSION(filepath, ".css")) {
        type = "text/css";
    } else if (CHECK_FILE_EXTENSION(filepath, ".png")) {
        type = "image/png";
    } else if (CHECK_FILE_EXTENSION(filepath, ".ico")) {
        type = "image/x-icon";
    } else if (CHECK_FILE_EXTENSION(filepath, ".svg")) {
        type = "text/xml";
    }
    return httpd_resp_set_type(req, type);
}

/* Send HTTP response with the contents of the requested file */
static esp_err_t rest_common_get_handler(httpd_req_t *req)
{
    char filepath[FILE_PATH_MAX];

    rest_server_context_t *rest_context = (rest_server_context_t *)req->user_ctx;
    strlcpy(filepath, rest_context->base_path, sizeof(filepath));
    if (req->uri[strlen(req->uri) - 1] == '/') {
        strlcat(filepath, "/index.html", sizeof(filepath));
    } else {
        strlcat(filepath, req->uri, sizeof(filepath));
    }
    int fd = open(filepath, O_RDONLY, 0);
    if (fd == -1) {
        ESP_LOGW(REST_TAG, "Failed to open file : %s, redirecting to index", filepath);
        /* Try to serve index.html for SPA routing */
        strlcpy(filepath, rest_context->base_path, sizeof(filepath));
        strlcat(filepath, "/index.html", sizeof(filepath));
        fd = open(filepath, O_RDONLY, 0);
        if (fd == -1) {
            ESP_LOGE(REST_TAG, "Failed to open index file : %s", filepath);
            httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File not found");
            return ESP_FAIL;
        }
    }

    set_content_type_from_file(req, filepath);

    char *chunk = rest_context->scratch;
    ssize_t read_bytes;
    do {
        /* Read file in chunks into the scratch buffer */
        read_bytes = read(fd, chunk, SCRATCH_BUFSIZE);
        if (read_bytes == -1) {
            ESP_LOGE(REST_TAG, "Failed to read file : %s", filepath);
        } else if (read_bytes > 0) {
            /* Send the buffer contents as HTTP response chunk */
            if (httpd_resp_send_chunk(req, chunk, read_bytes) != ESP_OK) {
                close(fd);
                ESP_LOGE(REST_TAG, "File sending failed!");
                /* Abort sending file */
                httpd_resp_sendstr_chunk(req, NULL);
                /* Respond with 500 Internal Server Error */
                httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to send file");
                return ESP_FAIL;
            }
        }
    } while (read_bytes > 0);
    /* Close file after sending complete */
    close(fd);
    ESP_LOGI(REST_TAG, "File sending complete");
    /* Respond with an empty chunk to signal HTTP response completion */
    httpd_resp_send_chunk(req, NULL, 0);
    return ESP_OK;
}

// Manipulador para o endpoint GET /api/v1/config/electrical
static esp_err_t electrical_config_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON com as configurações de rede elétrica
    cJSON *config = cJSON_CreateObject();
    cJSON *monitor = cJSON_CreateObject();
    cJSON_AddStringToObject(monitor, "voltage", "230");
    cJSON_AddStringToObject(monitor, "current", "10");
    cJSON_AddStringToObject(monitor, "quality", "1");
    cJSON_AddItemToObject(config, "monitor", monitor);
    cJSON_AddBoolToObject(config, "alerts", true);
    
    // Adicionar mais configurações (security, loadBalancing, solar) no objeto config
    // ...
    
    // Enviar a resposta
    const char *config_str = cJSON_Print(config);
    httpd_resp_sendstr(req, config_str);

    // Liberar memória
    free((void *)config_str);
    cJSON_Delete(config);

    return ESP_OK;
}


// Manipulador para o endpoint POST /api/v1/config/electrical
static esp_err_t electrical_config_post_handler(httpd_req_t *req)
{
    char buf[512];
    int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
    if (len <= 0) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Request body is empty");
        return ESP_FAIL;
    }
    buf[len] = '\0'; // Garantir que a string esteja terminada

    // Parse JSON recebido
    cJSON *json = cJSON_Parse(buf);
    if (json == NULL) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
        return ESP_FAIL;
    }

    // Processar os dados recebidos e atualizar as configurações (monitor, alerts, etc.)
    // Exemplo de configuração:
    cJSON *monitor = cJSON_GetObjectItem(json, "monitor");
    if (monitor) {
        // Atualizar configurações do monitor
        // ...
    }

    // Atualizar outras configurações...

    // Responder com sucesso
    httpd_resp_sendstr(req, "Configuração gravada com sucesso!");

    cJSON_Delete(json);

    return ESP_OK;
}


// Manipulador para o endpoint /api/v1/config/load-balancing
static esp_err_t config_load_balancing_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON de configuração
    cJSON *config = cJSON_CreateObject();

    // Configuração de load balancing
    cJSON_AddBoolToObject(config, "enabled", true); // Exemplo: load balancing ativado
    cJSON_AddNumberToObject(config, "maxChargingCurrent", 32); // Exemplo: corrente máxima de 32A

    // Lista de dispositivos disponíveis
    cJSON *devices = cJSON_CreateArray();
    cJSON_AddItemToArray(devices, cJSON_CreateString("Device 1")); // Exemplo de dispositivo
    cJSON_AddItemToArray(devices, cJSON_CreateString("Device 2")); // Outro exemplo de dispositivo
    cJSON_AddItemToObject(config, "devices", devices);

    // Convertendo para string e enviando a resposta
    const char *config_str = cJSON_Print(config);
    httpd_resp_sendstr(req, config_str);

    // Liberando a memória
    free((void *)config_str);
    cJSON_Delete(config);

    return ESP_OK;
}
// Manipulador para o endpoint GET /api/v1/ocpp (Status do OCPP)
static esp_err_t ocpp_status_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON de status
    cJSON *status = cJSON_CreateObject();
    cJSON_AddStringToObject(status, "status", "connected");  // Status de exemplo, você pode adaptar conforme sua lógica

    // Convertendo para string e enviando a resposta
    const char *status_str = cJSON_Print(status);
    httpd_resp_sendstr(req, status_str);

    // Liberando a memória
    free((void *)status_str);
    cJSON_Delete(status);

    return ESP_OK;
}

// Manipulador para o endpoint GET /api/v1/config/ocpp (Configuração OCPP)
static esp_err_t config_ocpp_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON com as configurações do OCPP
    cJSON *config = cJSON_CreateObject();
    cJSON_AddStringToObject(config, "url", ocpp_config.url);
    cJSON_AddStringToObject(config, "chargeBoxId", ocpp_config.chargeBoxId);
    cJSON_AddStringToObject(config, "certificate", ocpp_config.certificate);
    cJSON_AddStringToObject(config, "privateKey", ocpp_config.privateKey);

    // Convertendo para string e enviando a resposta
    const char *config_str = cJSON_Print(config);
    httpd_resp_sendstr(req, config_str);

    // Liberando a memória
    free((void *)config_str);
    cJSON_Delete(config);

    return ESP_OK;
}

// Manipulador para o endpoint POST /api/v1/config/ocpp (Salvar configuração OCPP)
static esp_err_t config_ocpp_post_handler(httpd_req_t *req)
{
    char buf[512];  // Buffer para armazenar a requisição
    int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
    if (len <= 0) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid request body");
        return ESP_FAIL;
    }
    buf[len] = '\0'; // Garantir que a string esteja terminada

    // Parse JSON recebido
    cJSON *json = cJSON_Parse(buf);
    if (json == NULL) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
        return ESP_FAIL;
    }

    // Atualizando as configurações OCPP
    cJSON *url = cJSON_GetObjectItem(json, "url");
    if (url) strlcpy(ocpp_config.url, url->valuestring, sizeof(ocpp_config.url));

    cJSON *chargeBoxId = cJSON_GetObjectItem(json, "chargeBoxId");
    if (chargeBoxId) strlcpy(ocpp_config.chargeBoxId, chargeBoxId->valuestring, sizeof(ocpp_config.chargeBoxId));

    cJSON *certificate = cJSON_GetObjectItem(json, "certificate");
    if (certificate) strlcpy(ocpp_config.certificate, certificate->valuestring, sizeof(ocpp_config.certificate));

    cJSON *privateKey = cJSON_GetObjectItem(json, "privateKey");
    if (privateKey) strlcpy(ocpp_config.privateKey, privateKey->valuestring, sizeof(ocpp_config.privateKey));

    cJSON_Delete(json);

    // Responder com uma mensagem de sucesso
    httpd_resp_sendstr(req, "Configuração OCPP atualizada com sucesso");

    return ESP_OK;
}

// Manipulador para o endpoint POST /api/v1/config/settings
static esp_err_t config_settings_post_handler(httpd_req_t *req)
{
    char buf[512];  // Buffer para armazenar a requisição
    int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
    if (len <= 0) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid request body");
        return ESP_FAIL;
    }
    buf[len] = '\0'; // Garantir que a string esteja terminada

    // Parse JSON recebido
    cJSON *json = cJSON_Parse(buf);
    if (json == NULL) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
        return ESP_FAIL;
    }

    // Atualizando as configurações
    cJSON *currentLimit = cJSON_GetObjectItem(json, "currentLimit");
    if (currentLimit) 
        evse_set_max_charging_current(currentLimit->valueint);
    //settings_config.currentLimit = currentLimit->valueint;

    cJSON *powerLimit = cJSON_GetObjectItem(json, "powerLimit");
    if (powerLimit) settings_config.powerLimit = powerLimit->valueint;

    cJSON *energyLimit = cJSON_GetObjectItem(json, "energyLimit");
    if (energyLimit) settings_config.energyLimit = energyLimit->valueint;

    cJSON *chargingTimeLimit = cJSON_GetObjectItem(json, "chargingTimeLimit");
    if (chargingTimeLimit) settings_config.chargingTimeLimit = chargingTimeLimit->valueint;

    cJSON *temperatureLimit = cJSON_GetObjectItem(json, "temperatureLimit");
    if (temperatureLimit) 
        evse_set_temp_threshold(temperatureLimit->valueint);
    
    //settings_config.temperatureLimit = temperatureLimit->valueint;

    cJSON_Delete(json);

    // Responder com uma mensagem de sucesso
    httpd_resp_sendstr(req, "Configurações de energia atualizadas com sucesso");

    return ESP_OK;
}


// Manipulador para o endpoint GET /api/v1/config/settings
static esp_err_t config_settings_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON para enviar as configurações atuais
    cJSON *config = cJSON_CreateObject();

    
    //cJSON_AddNumberToObject(config, "maxCurrentLimit", evse_get_max_charging_current());
    cJSON_AddNumberToObject(config, "currentLimit", evse_get_max_charging_current());
    cJSON_AddNumberToObject(config, "powerLimit", settings_config.powerLimit);
    cJSON_AddNumberToObject(config, "energyLimit", settings_config.energyLimit);
    cJSON_AddNumberToObject(config, "chargingTimeLimit", settings_config.chargingTimeLimit);
    cJSON_AddNumberToObject(config, "temperatureLimit", evse_get_temp_threshold());

    // Convertendo para string e enviando a resposta
    const char *config_str = cJSON_Print(config);
    httpd_resp_sendstr(req, config_str);

    // Liberando a memória
    free((void *)config_str);
    cJSON_Delete(config);

    return ESP_OK;
}


// Manipulador para o endpoint GET /api/v1/dashboard
static esp_err_t dashboard_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON com os dados do Dashboard
    cJSON *dashboard = cJSON_CreateObject();

    // Status do sistema
    cJSON_AddStringToObject(dashboard, "status", "Ativo");

    // Carregadores (exemplo)
    cJSON *chargers = cJSON_CreateArray();
    cJSON *charger1 = cJSON_CreateObject();
    cJSON_AddNumberToObject(charger1, "id", 1);
    cJSON_AddStringToObject(charger1, "status", "Ativo");
    cJSON_AddNumberToObject(charger1, "current", 12);
    cJSON_AddNumberToObject(charger1, "power", 2200);
    cJSON_AddItemToArray(chargers, charger1);

    cJSON_AddItemToObject(dashboard, "chargers", chargers);

    // Consumo de energia
    cJSON_AddNumberToObject(dashboard, "energyConsumed", 50.3);

    // Tempo de carregamento
    cJSON_AddNumberToObject(dashboard, "chargingTime", 120);

    // Alertas
    cJSON *alerts = cJSON_CreateArray();
    cJSON_AddItemToArray(alerts, cJSON_CreateString("Aviso: Carregador 1 está com erro."));
    cJSON_AddItemToObject(dashboard, "alerts", alerts);

    // Convertendo para string e enviando a resposta
    const char *dashboard_str = cJSON_Print(dashboard);
    httpd_resp_sendstr(req, dashboard_str);

    // Liberando a memória
    free((void *)dashboard_str);
    cJSON_Delete(dashboard);

    return ESP_OK;
}


static esp_err_t config_wifi_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON com as configurações de Wi-Fi
    cJSON *config = cJSON_CreateObject();
    cJSON_AddBoolToObject(config, "enabled", wifi_config.enabled);
    cJSON_AddStringToObject(config, "ssid", wifi_config.ssid);
    cJSON_AddStringToObject(config, "password", wifi_config.password);

    // Convertendo para string e enviando a resposta
    const char *config_str = cJSON_Print(config);
    httpd_resp_sendstr(req, config_str);

    // Liberando a memória
    free((void *)config_str);
    cJSON_Delete(config);

    return ESP_OK;
}

/* Manipulador para o endpoint POST /api/v1/config/wifi */
static esp_err_t config_wifi_post_handler(httpd_req_t *req)
{
    char buf[512];  // Buffer para armazenar a requisição
    int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
    if (len <= 0) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid request body");
        return ESP_FAIL;
    }
    buf[len] = '\0'; // Garantir que a string esteja terminada

    // Parse JSON recebido
    cJSON *json = cJSON_Parse(buf);
    if (json == NULL) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
        return ESP_FAIL;
    }

    // Atualizando as configurações Wi-Fi
    cJSON *enabled = cJSON_GetObjectItem(json, "enabled");
    if (enabled) wifi_config.enabled = enabled->valueint;

    cJSON *ssid = cJSON_GetObjectItem(json, "ssid");
    if (ssid) strlcpy(wifi_config.ssid, ssid->valuestring, sizeof(wifi_config.ssid));

    cJSON *password = cJSON_GetObjectItem(json, "password");
    if (password) strlcpy(wifi_config.password, password->valuestring, sizeof(wifi_config.password));

    cJSON_Delete(json);

    // Responder com uma mensagem de sucesso
    httpd_resp_sendstr(req, "Configuração Wi-Fi atualizada com sucesso");

    return ESP_OK;
}

/* Manipulador para o endpoint GET /api/v1/config/mqtt */
static esp_err_t config_mqtt_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON com as configurações de MQTT
    cJSON *config = cJSON_CreateObject();
    cJSON_AddBoolToObject(config, "enabled", mqtt_config.enabled);
    cJSON_AddStringToObject(config, "host", mqtt_config.host);
    cJSON_AddNumberToObject(config, "port", mqtt_config.port);
    cJSON_AddStringToObject(config, "username", mqtt_config.username);
    cJSON_AddStringToObject(config, "password", mqtt_config.password);
    cJSON_AddStringToObject(config, "topic", mqtt_config.topic);

    // Convertendo para string e enviando a resposta
    const char *config_str = cJSON_Print(config);
    httpd_resp_sendstr(req, config_str);

    // Liberando a memória
    free((void *)config_str);
    cJSON_Delete(config);

    return ESP_OK;
}

/* Manipulador para o endpoint POST /api/v1/config/mqtt */
static esp_err_t config_mqtt_post_handler(httpd_req_t *req)
{
    char buf[512];  // Buffer para armazenar a requisição
    int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
    if (len <= 0) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid request body");
        return ESP_FAIL;
    }
    buf[len] = '\0'; // Garantir que a string esteja terminada

    // Parse JSON recebido
    cJSON *json = cJSON_Parse(buf);
    if (json == NULL) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
        return ESP_FAIL;
    }

    // Atualizando as configurações MQTT
    cJSON *enabled = cJSON_GetObjectItem(json, "enabled");
    if (enabled) mqtt_config.enabled = enabled->valueint;

    cJSON *host = cJSON_GetObjectItem(json, "host");
    if (host) strlcpy(mqtt_config.host, host->valuestring, sizeof(mqtt_config.host));

    cJSON *port = cJSON_GetObjectItem(json, "port");
    if (port) mqtt_config.port = port->valueint;

    cJSON *username = cJSON_GetObjectItem(json, "username");
    if (username) strlcpy(mqtt_config.username, username->valuestring, sizeof(mqtt_config.username));

    cJSON *password = cJSON_GetObjectItem(json, "password");
    if (password) strlcpy(mqtt_config.password, password->valuestring, sizeof(mqtt_config.password));

    cJSON *topic = cJSON_GetObjectItem(json, "topic");
    if (topic) strlcpy(mqtt_config.topic, topic->valuestring, sizeof(mqtt_config.topic));

    cJSON_Delete(json);

    // Responder com uma mensagem de sucesso
    httpd_resp_sendstr(req, "Configuração MQTT atualizada com sucesso");

    return ESP_OK;
}

// GET /api/v1/config/auth-methods
static esp_err_t config_auth_methods_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    cJSON *config = cJSON_CreateObject();
    cJSON_AddBoolToObject(config, "RFID", auth_is_enabled());
    cJSON_AddBoolToObject(config, "App", false);
    cJSON_AddBoolToObject(config, "Password", false);

    char *config_str = cJSON_PrintUnformatted(config);
    httpd_resp_sendstr(req, config_str);

    free(config_str);
    cJSON_Delete(config);

    return ESP_OK;
}

// POST /api/v1/config/auth-methods
static esp_err_t config_auth_methods_post_handler(httpd_req_t *req)
{
    char buf[512];
    int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
    if (len <= 0) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid request body");
        return ESP_FAIL;
    }
    buf[len] = '\0';

    cJSON *json = cJSON_Parse(buf);
    if (!json) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON");
        return ESP_FAIL;
    }

    cJSON *RFID = cJSON_GetObjectItem(json, "RFID");
    if (cJSON_IsBool(RFID)) {
        auth_set_enabled(cJSON_IsTrue(RFID));
    }

    /*

    cJSON *App = cJSON_GetObjectItem(json, "App");
    if (cJSON_IsBool(App)) {
        auth_methods.App = cJSON_IsTrue(App);
    }

    cJSON *Password = cJSON_GetObjectItem(json, "Password");
    if (cJSON_IsBool(Password)) {
        auth_methods.Password = cJSON_IsTrue(Password);
    }*/

    cJSON_Delete(json);

    httpd_resp_sendstr(req, "Configurações de autenticação atualizadas com sucesso");
    return ESP_OK;
}



// Manipulador para o endpoint GET /api/v1/config/users
static esp_err_t config_users_get_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");

    // Criar objeto JSON com a lista de usuários
    cJSON *config = cJSON_CreateObject();
    cJSON *users_list = cJSON_CreateArray();

    for (int i = 0; i < num_users; i++) {
        cJSON *user = cJSON_CreateObject();
        cJSON_AddStringToObject(user, "username", users[i].username);
        cJSON_AddItemToArray(users_list, user);
    }

    cJSON_AddItemToObject(config, "users", users_list);

    // Convertendo para string e enviando a resposta
    const char *config_str = cJSON_Print(config);
    httpd_resp_sendstr(req, config_str);

    // Liberando a memória
    free((void *)config_str);
    cJSON_Delete(config);

    return ESP_OK;
}


// Manipulador para o endpoint POST /api/v1/config/users
static esp_err_t config_users_post_handler(httpd_req_t *req)
{
    char buf[128];  // Buffer para armazenar o nome do novo usuário
    int len = httpd_req_recv(req, buf, sizeof(buf) - 1);
    if (len <= 0) {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid request body");
        return ESP_FAIL;
    }
    buf[len] = '\0'; // Garantir que a string esteja terminada

    // Adicionar o novo usuário
    if (num_users < 10) {
        strlcpy(users[num_users].username, buf, sizeof(users[num_users].username));
        num_users++;
        httpd_resp_sendstr(req, "Usuário adicionado com sucesso");
    } else {
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Máximo de usuários atingido");
    }

    return ESP_OK;
}


// Manipulador para o endpoint DELETE /api/v1/config/users/{username}
static esp_err_t config_users_delete_handler(httpd_req_t *req)
{
    char username[128];  // Nome do usuário a ser removido
    if (httpd_req_get_url_query_str(req, username, sizeof(username)) == ESP_OK) {
        // Verificar e remover o usuário
        for (int i = 0; i < num_users; i++) {
            if (strcmp(users[i].username, username) == 0) {
                // Remover o usuário
                for (int j = i; j < num_users - 1; j++) {
                    users[j] = users[j + 1];
                }
                num_users--;
                httpd_resp_sendstr(req, "Usuário removido com sucesso");
                return ESP_OK;
            }
        }
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Usuário não encontrado");
    }
    return ESP_FAIL;
}



esp_err_t rest_init(const char *base_path)
{

    /*
    REST_CHECK(base_path, "wrong base path", err);
    rest_server_context_t *rest_context = calloc(1, sizeof(rest_server_context_t));
    REST_CHECK(rest_context, "No memory for rest context", err_start);
    strlcpy(rest_context->base_path, base_path, sizeof(rest_context->base_path));

    httpd_handle_t server = NULL;
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();
    config.max_uri_handlers = 30;  // Ajuste conforme necessário
    config.uri_match_fn = httpd_uri_match_wildcard;

    ESP_LOGI(REST_TAG, "Starting HTTP Server");
    REST_CHECK(httpd_start(&server, &config) == ESP_OK, "Start server failed", err_start);

    // Registrar manipuladores de URI para as configurações
    httpd_uri_t config_load_balancing_get_uri = {
        .uri = "/api/v1/config/load-balancing",
        .method = HTTP_GET,
        .handler = config_load_balancing_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_load_balancing_get_uri);

    // URI handler for fetching OCPP status
    httpd_uri_t ocpp_status_get_uri = {
        .uri = "/api/v1/ocpp",
        .method = HTTP_GET,
        .handler = ocpp_status_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &ocpp_status_get_uri);

    // URI handler for fetching OCPP config
    httpd_uri_t config_ocpp_get_uri = {
        .uri = "/api/v1/config/ocpp",
        .method = HTTP_GET,
        .handler = config_ocpp_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_ocpp_get_uri);

    // URI handler for posting OCPP config
    httpd_uri_t config_ocpp_post_uri = {
        .uri = "/api/v1/config/ocpp",
        .method = HTTP_POST,
        .handler = config_ocpp_post_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_ocpp_post_uri);

    // Manipulador para o endpoint POST /api/v1/config/settings
    httpd_uri_t config_settings_post_uri = {
        .uri = "/api/v1/config/settings",
        .method = HTTP_POST,
        .handler = config_settings_post_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_settings_post_uri);

    // Manipulador para o endpoint GET /api/v1/config/settings
    httpd_uri_t config_settings_get_uri = {
        .uri = "/api/v1/config/settings",
        .method = HTTP_GET,
        .handler = config_settings_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_settings_get_uri);

    // Manipulador para o endpoint GET /api/v1/dashboard
    httpd_uri_t dashboard_get_uri = {
        .uri = "/api/v1/dashboard",
        .method = HTTP_GET,
        .handler = dashboard_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &dashboard_get_uri);

    // Register URI Handlers for electrical configuration
    httpd_uri_t electrical_config_get_uri = {
        .uri = "/api/v1/config/electrical",
        .method = HTTP_GET,
        .handler = electrical_config_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &electrical_config_get_uri);

    httpd_uri_t electrical_config_post_uri = {
        .uri = "/api/v1/config/electrical",
        .method = HTTP_POST,
        .handler = electrical_config_post_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &electrical_config_post_uri);

    // URI handler for getting Wi-Fi config
    httpd_uri_t config_wifi_get_uri = {
        .uri = "/api/v1/config/wifi",
        .method = HTTP_GET,
        .handler = config_wifi_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_wifi_get_uri);

    // URI handler for posting Wi-Fi config
    httpd_uri_t config_wifi_post_uri = {
        .uri = "/api/v1/config/wifi",
        .method = HTTP_POST,
        .handler = config_wifi_post_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_wifi_post_uri);

    // URI handler for getting MQTT config
    httpd_uri_t config_mqtt_get_uri = {
        .uri = "/api/v1/config/mqtt",
        .method = HTTP_GET,
        .handler = config_mqtt_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_mqtt_get_uri);

    // URI handler for posting MQTT config
    httpd_uri_t config_mqtt_post_uri = {
        .uri = "/api/v1/config/mqtt",
        .method = HTTP_POST,
        .handler = config_mqtt_post_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_mqtt_post_uri);

    // Registrar manipuladores para as configurações de autenticação
    httpd_uri_t config_auth_methods_get_uri = {
        .uri = "/api/v1/config/auth-methods",
        .method = HTTP_GET,
        .handler = config_auth_methods_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_auth_methods_get_uri);

    httpd_uri_t config_auth_methods_post_uri = {
        .uri = "/api/v1/config/auth-methods",
        .method = HTTP_POST,
        .handler = config_auth_methods_post_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_auth_methods_post_uri);

    // Registrar manipuladores para as configurações de usuários
    httpd_uri_t config_users_get_uri = {
        .uri = "/api/v1/config/users",
        .method = HTTP_GET,
        .handler = config_users_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_users_get_uri);

    httpd_uri_t config_users_post_uri = {
        .uri = "/api/v1/config/users",
        .method = HTTP_POST,
        .handler = config_users_post_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_users_post_uri);

    httpd_uri_t config_users_delete_uri = {
        .uri = "/api/v1/config/users",
        .method = HTTP_DELETE,
        .handler = config_users_delete_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &config_users_delete_uri);

    // URI handler for getting web server files
    httpd_uri_t common_get_uri = {
        .uri = "/",
        .method = HTTP_GET,
        .handler = rest_common_get_handler,
        .user_ctx = rest_context
    };
    httpd_register_uri_handler(server, &common_get_uri);
    */
    return ESP_OK;
}