// SPDX-License-Identifier: Apache-2.0
// Copyright chargebyte GmbH and Contributors to EVerest

#include <gtest/gtest.h>
#include <thread>

#include "../data/DataStore.hpp"
#include "../helpers/ErrorHandler.hpp"
#include "../helpers/JsonRpcUtils.hpp"
#include "../helpers/RequestHandlerDummy.hpp"
#include "../helpers/WebSocketTestClient.hpp"
#include "../rpc/RpcHandler.hpp"
#include "../server/WebsocketServer.hpp"

using namespace server;
using namespace rpc;
using namespace json_rpc_utils;

class RpcHandlerTest : public ::testing::Test {
protected:
    int test_port = 8080;
    void SetUp() override {
        // Start the WebSocket server
        m_websocket_server = std::make_unique<server::WebSocketServer>(false, test_port, "lo");
        lws_set_log_level(LLL_ERR | LLL_WARN, NULL);

        // Create RpcHandler instance. Move the transport interfaces and request handler to the RpcHandler
        std::vector<std::shared_ptr<server::TransportInterface>> transport_interfaces;
        request_handler = std::make_unique<RequestHandlerDummy>(data_store);
        transport_interfaces.push_back(std::shared_ptr<server::TransportInterface>(std::move(m_websocket_server)));
        m_rpc_handler =
            std::make_unique<RpcHandler>(std::move(transport_interfaces), data_store, std::move(request_handler));
        m_rpc_handler->start_server();
        initialize_data_store();
    }

    void TearDown() override {
        m_rpc_handler->stop_server();
    }

    void initialize_data_store() {
        // Set up the data store with test data
        RPCDataTypes::ChargerInfoObj charger_info;
        charger_info.firmware_version = "1.0.0";
        charger_info.model = "Test Charger";
        charger_info.serial = "123456789";
        charger_info.vendor = "Test Vendor";
        data_store.chargerinfo.set_data(charger_info);
        data_store.everest_version = "2025.1.0";
        // Properly initialize EVSE objects
        data_store.evses.emplace_back(std::make_unique<data::DataStoreEvse>());
    }

    void send_req_and_validate_res(WebSocketTestClient& client, const nlohmann::json& request,
                                   const nlohmann::json& expected_response,
                                   bool (*cmp_f)(const nlohmann::json&, const nlohmann::json&) = nullptr) {
        // Send the request
        client.send(request.dump());
        // Wait for the response
        std::string data = client.wait_for_data(std::chrono::seconds(1));
        // Check if the response is not empty
        ASSERT_FALSE(data.empty());
        nlohmann::json response = nlohmann::json::parse(data);
        // Check if the response is valid
        if (cmp_f != nullptr) {
            // Compare the response with the expected response using the provided comparison function
            bool res = cmp_f(response, expected_response);
            if (!res) {
                // If the comparison fails, print the response and expected response for debugging
                EVLOG_error << "Expected equality of these values: response: " << response.dump();
                EVLOG_error << "Expected response: " << expected_response.dump();
            }
            ASSERT_TRUE(res);
        } else {
            // Compare the response with the expected response
            ASSERT_EQ(response, expected_response);
        }
    }

    std::unique_ptr<server::WebSocketServer> m_websocket_server;
    std::unique_ptr<rpc::RpcHandler> m_rpc_handler;

    // Condition variable to wait for response
    std::condition_variable cv;
    std::mutex cv_mutex;

    // Data store object used to manage and access charger-related data, including EVSEs, connectors, and charger info.
    data::DataStoreCharger data_store;
    // Dummy request handler. Needed to create the responses of synchronous requests
    std::unique_ptr<request_interface::RequestHandlerInterface> request_handler;
};

// Test: Connect to WebSocket server and check if API.Hello timeout occurs
TEST_F(RpcHandlerTest, ApiHelloTimeout) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Wait for the client hello timeout
    EVLOG_info << "Waiting for client hello timeout...";
    std::this_thread::sleep_for(std::chrono::seconds(CLIENT_HELLO_TIMEOUT) + std::chrono::milliseconds(100));

    // Check if the client is still connected
    ASSERT_FALSE(client.is_connected());
}

// Test: Connect to WebSocket server and send API.Hello request
TEST_F(RpcHandlerTest, ApiHelloReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up the expected response
    RPCDataTypes::HelloResObj result;
    result.authentication_required = false;
    result.api_version = API_VERSION;
    result.charger_info = data_store.chargerinfo.get_data().value();
    result.everest_version = data_store.everest_version;

    nlohmann::json expected_response = {{"jsonrpc", JSON_RPC_SPEC_VERSION}, {"result", result}, {"id", 1}};

    // Send Api.Hello request
    client.send_api_hello_req();
    // Wait for the response
    std::string data = client.wait_for_data(std::chrono::seconds(1));
    // Check if the response is not empty
    ASSERT_FALSE(data.empty());
    // Check if the response is valid
    nlohmann::json response = nlohmann::json::parse(data);
    ASSERT_EQ(response, expected_response);
    // Check if the client is still connected
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));
}

// Test: Connect to WebSocket server and send EVSEInfo request
TEST_F(RpcHandlerTest, ChargePointGetEVSEInfosReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up the data store with test data
    RPCDataTypes::ChargePointGetEVSEInfosResObj result; // Expected response
    data_store.evses.emplace_back(std::make_unique<data::DataStoreEvse>());
    data_store.evses.emplace_back(std::make_unique<data::DataStoreEvse>());
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1;
    evse_info.available_connectors.emplace_back();
    evse_info.available_connectors[0].index = 1;
    evse_info.available_connectors[0].type = types::json_rpc_api::ConnectorTypeEnum::cCCS2;
    evse_info.available_connectors.emplace_back();
    evse_info.available_connectors[1].index = 2;
    evse_info.available_connectors[1].type = types::json_rpc_api::ConnectorTypeEnum::cCCS1;
    evse_info.description = "Test EVSE 1";

    result.error = RPCDataTypes::ResponseErrorEnum::NoError; ///< No error

    // Set up request and expected response
    nlohmann::json charge_point_get_evse_infos_req = create_json_rpc_request("ChargePoint.GetEVSEInfos", {}, 1);
    nlohmann::json expected_error_no_data = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorNoDataAvailable)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send ChargePoint.GetEVSEInfos request and validate response, no data available
    send_req_and_validate_res(client, charge_point_get_evse_infos_req, expected_error_no_data,
                              is_key_value_in_json_rpc_result);
    // Set up the data store with test data
    data_store.evses[0]->evseinfo.set_data(evse_info);
    result.infos.push_back(evse_info);
    evse_info.index = 2;
    evse_info.description = "Test EVSE 2";
    data_store.evses[1]->evseinfo.set_data(evse_info);
    result.infos.push_back(evse_info);
    // Set up expected response
    nlohmann::json expected_response = create_json_rpc_response(result, 1);
    // Send ChargePoint.GetEVSEInfos request and validate response
    send_req_and_validate_res(client, charge_point_get_evse_infos_req, expected_response);
}

// Test: Connect to WebSocket server and send ChargePoint.GetActiveErrors request
TEST_F(RpcHandlerTest, ChargePointGetActiveErrorsReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1; ///< Unique identifier
    evse_info.available_connectors.emplace_back();
    evse_info.available_connectors[0].index = 1;
    evse_info.available_connectors[0].type = types::json_rpc_api::ConnectorTypeEnum::cCCS2;
    evse_info.description = "Test EVSE 1";
    data_store.evses[0]->evseinfo.set_data(evse_info);
    // Add a second EVSE with a different index
    data_store.evses.emplace_back(std::make_unique<data::DataStoreEvse>());
    evse_info.index = 2; ///< Unique identifier
    evse_info.description = "Test EVSE 2";
    data_store.evses[1]->evseinfo.set_data(evse_info);
    // Set up the EVSE status for both EVSEs
    RPCDataTypes::EVSEStatusObj evse_status1, evse_status2;
    evse_status1.error_present = false;
    evse_status2.error_present = false;
    data_store.evses[0]->evsestatus.set_data(evse_status1);
    data_store.evses[1]->evsestatus.set_data(evse_status2);

    types::json_rpc_api::ErrorObj error0, error1, error2;
    error0.origin.evse_index = 1;
    error0.origin.connector_index = 0;
    error0.origin.module_id = "evse_1";
    error0.origin.implementation_id = "board_support";
    error0.message = "Test error message";
    error0.description = "Test error description";
    error0.uuid = "6db8758b-194d-48e1-99af-c8f0b1d2e3f3";
    error0.severity = types::json_rpc_api::Severity::Low;
    error0.timestamp = "2025-01-01T12:00:00Z";
    error0.type = "TestErrorType";

    error1.origin.evse_index = 2;
    error1.origin.connector_index = 1;
    error1.origin.module_id = "evse_2";
    error1.origin.implementation_id = "board_support";
    error1.message = "Test error message";
    error1.description = "Test error description";
    error1.uuid = "7db8758b-194d-48e1-99af-c8f0b1d2e3f4";
    error1.severity = types::json_rpc_api::Severity::Medium;
    error1.timestamp = "2025-01-01T12:00:00Z";
    error1.type = "TestErrorType";

    error2.origin.evse_index = 2;
    error2.origin.connector_index = 1;
    error2.origin.module_id = "evse_2";
    error2.origin.implementation_id = "board_support";
    error2.message = "Another test error message";
    error2.description = "Another test error description";
    error2.uuid = "8db8758b-194d-48e1-99af-c8f0b1d2e3f5";
    error2.severity = types::json_rpc_api::Severity::High;
    error2.timestamp = "2025-01-01T12:00:01Z";
    error2.type = "AnotherTestErrorType";

    // Set up the data store with test data
    RPCDataTypes::ChargePointGetActiveErrorsResObj result; // Expected response
    result.active_errors.push_back(error1);
    result.active_errors.push_back(error2);
    result.error = RPCDataTypes::ResponseErrorEnum::NoError; ///< No error
    // Set up request and expected response
    nlohmann::json charge_point_get_active_errors_req = create_json_rpc_request("ChargePoint.GetActiveErrors", {}, 1);
    nlohmann::json expected_response = create_json_rpc_response(result, 1);
    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Raise the error in the data store for the first EVSE
    helpers::handle_error_raised(data_store, error0);
    // Check if the error is set to present in the EVSE status
    auto tmp_evse_store_1 = data_store.get_evse_store(1);
    ASSERT_TRUE(tmp_evse_store_1 != nullptr);
    ASSERT_TRUE(tmp_evse_store_1->evsestatus.get_data().value().error_present);
    // Clear the error in the data store for the first EVSE
    helpers::handle_error_cleared(data_store, error0);
    // Check if the error is cleared in the EVSE status
    ASSERT_FALSE(tmp_evse_store_1->evsestatus.get_data().value().error_present);
    // Raise the second error in the data store for the second EVSE
    helpers::handle_error_raised(data_store, error1);
    helpers::handle_error_raised(data_store, error2);
    // Check if error is set to present in the EVSE status
    ASSERT_FALSE(tmp_evse_store_1->evsestatus.get_data().value().error_present);
    auto tmp_evse_store_2 = data_store.get_evse_store(2);
    ASSERT_TRUE(tmp_evse_store_2 != nullptr);
    ASSERT_TRUE(tmp_evse_store_2->evsestatus.get_data().value().error_present);
    // Send ChargePoint.GetActiveErrors request and validate response
    send_req_and_validate_res(client, charge_point_get_active_errors_req, expected_response);
    // Clear the errors for the second EVSE
    helpers::handle_error_cleared(data_store, error1);
    // Check if the error is still present in the EVSE status
    ASSERT_TRUE(tmp_evse_store_2->evsestatus.get_data().value().error_present);
    // Clear the second error
    helpers::handle_error_cleared(data_store, error2);
    // Check if error is cleared in the EVSE status
    ASSERT_FALSE(tmp_evse_store_1->evsestatus.get_data().value().error_present);
    ASSERT_FALSE(tmp_evse_store_2->evsestatus.get_data().value().error_present);
}

// Test: Connect to WebSocket server and send EVSE.Infos request with valid and invalid index
TEST_F(RpcHandlerTest, EvseGetEVSEInfosReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_get_evse_infos_req_1 = create_json_rpc_request("EVSE.GetInfo", {{"evse_index", 1}}, 1);
    nlohmann::json evse_get_evse_infos_req_2 = create_json_rpc_request("EVSE.GetInfo", {{"evse_index", 2}}, 1);
    nlohmann::json evse_get_infos_req_invalid_index = create_json_rpc_request("EVSE.GetInfo", {{"evse_index", 99}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1; ///< Unique identifier
    evse_info.available_connectors.emplace_back();
    evse_info.available_connectors[0].index = 1;
    evse_info.available_connectors[0].type = types::json_rpc_api::ConnectorTypeEnum::cCCS2;
    evse_info.available_connectors.emplace_back();
    evse_info.available_connectors[1].index = 2;
    evse_info.available_connectors[1].type = types::json_rpc_api::ConnectorTypeEnum::cCCS1;
    evse_info.description = "Test EVSE 1";
    data_store.evses[0]->evseinfo.set_data(evse_info);

    // Expected response 1
    RPCDataTypes::EVSEGetInfoResObj result_1;
    result_1.info = evse_info;
    result_1.error = RPCDataTypes::ResponseErrorEnum::NoError; ///< No error

    // Set up the second EVSE info
    evse_info.index = 2;
    evse_info.available_connectors[0].type = types::json_rpc_api::ConnectorTypeEnum::cType2;
    evse_info.available_connectors[1].type = types::json_rpc_api::ConnectorTypeEnum::sType2;
    data_store.evses.emplace_back(std::make_unique<data::DataStoreEvse>());
    data_store.evses[1]->evseinfo.set_data(evse_info);

    // Set up the expected responses
    nlohmann::json expected_response_index_1 = create_json_rpc_response(result_1, 1);

    // Expected response 2
    RPCDataTypes::EVSEGetInfoResObj result_2;
    result_2.info = evse_info;
    result_2.error = RPCDataTypes::ResponseErrorEnum::NoError; ///< No error
    nlohmann::json expected_response_index_2 = create_json_rpc_response(result_2, 1);

    // Expected error object in case of invalid ID
    nlohmann::json expected_error = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.GetEVSEInfos request 1 and validate response
    send_req_and_validate_res(client, evse_get_evse_infos_req_1, expected_response_index_1);
    // Send EVSE.GetEVSEInfos request 2 and validate response
    send_req_and_validate_res(client, evse_get_evse_infos_req_2, expected_response_index_2);
    // Send EVSE.GetEVSEInfos request with invalid ID and validate response
    send_req_and_validate_res(client, evse_get_infos_req_invalid_index, expected_error,
                              is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send Evse.GetStatusReq request with valid and invalid index
TEST_F(RpcHandlerTest, EvseGetStatusReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));
    // Set up the requests
    nlohmann::json evse_get_status_req_valid_index = create_json_rpc_request("EVSE.GetStatus", {{"evse_index", 1}}, 1);
    nlohmann::json evse_get_status_req_invalid_index =
        create_json_rpc_request("EVSE.GetStatus", {{"evse_index", 99}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1; ///< Unique identifier
    data_store.evses[0]->evseinfo.set_data(evse_info);

    RPCDataTypes::EVSEStatusObj evse_status;
    evse_status.charged_energy_wh = 123.45;
    evse_status.discharged_energy_wh = 123.45;
    evse_status.charging_duration_s = 600;
    evse_status.charging_allowed = true;
    evse_status.available = true;
    evse_status.active_connector_index = 1;
    evse_status.error_present = false;
    evse_status.charge_protocol = types::json_rpc_api::ChargeProtocolEnum::ISO15118; ///< charge_protocol
    evse_status.state = types::json_rpc_api::EVSEStateEnum::Charging;
    evse_status.ac_charge_status.emplace().evse_active_phase_count = 3;

    // Set up the expected responses
    RPCDataTypes::EVSEGetStatusResObj res_valid_id;
    res_valid_id.status = evse_status;
    res_valid_id.error = RPCDataTypes::ResponseErrorEnum::NoError;
    nlohmann::json expected_error_no_data = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorNoDataAvailable)}};
    nlohmann::json res_obj_invalid_index = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};
    nlohmann::json expected_response = create_json_rpc_response(res_valid_id, 1);

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.GetStatus request with valid ID, but no data available
    send_req_and_validate_res(client, evse_get_status_req_valid_index, expected_error_no_data,
                              is_key_value_in_json_rpc_result);
    // Set the EVSE status in the data store
    data_store.evses[0]->evsestatus.set_data(evse_status);
    // Send EVSE.GetStatus request with valid ID
    send_req_and_validate_res(client, evse_get_status_req_valid_index, expected_response);
    // Send EVSE.GetStatus request with invalid ID
    send_req_and_validate_res(client, evse_get_status_req_invalid_index, res_obj_invalid_index,
                              is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send EVSE.GetHardwareCapabilities request with valid and invalid index
TEST_F(RpcHandlerTest, EvseGetHardwareCapabilitiesReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_get_hardware_capabilities_req_valid_index =
        create_json_rpc_request("EVSE.GetHardwareCapabilities", {{"evse_index", 1}}, 1);
    nlohmann::json evse_get_hardware_capabilities_req_invalid_index =
        create_json_rpc_request("EVSE.GetHardwareCapabilities", {{"evse_index", 99}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1;
    data_store.evses[0]->evseinfo.set_data(evse_info);

    RPCDataTypes::EVSEGetHardwareCapabilitiesResObj result;
    result.error = RPCDataTypes::ResponseErrorEnum::NoError;
    result.hardware_capabilities.max_current_A_export = 32.0;
    result.hardware_capabilities.max_current_A_import = 16.0;
    result.hardware_capabilities.max_phase_count_export = 3;
    result.hardware_capabilities.max_phase_count_import = 3;
    result.hardware_capabilities.min_current_A_export = 6.0;
    result.hardware_capabilities.min_current_A_import = 6.0;
    result.hardware_capabilities.min_phase_count_export = 1;
    result.hardware_capabilities.min_phase_count_import = 1;
    result.hardware_capabilities.phase_switch_during_charging = true;

    // Set up the expected responses
    nlohmann::json expected_response = create_json_rpc_response(result, 1);
    nlohmann::json expected_error_no_data = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorNoDataAvailable)}};
    nlohmann::json expected_error_invalid_index = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));

    // Send EVSE.GetHardwareCapabilities request with valid ID, but no hardware capabilities available
    send_req_and_validate_res(client, evse_get_hardware_capabilities_req_valid_index, expected_error_no_data,
                              is_key_value_in_json_rpc_result);
    // Set the hardware capabilities in the data store
    data_store.evses[0]->hardwarecapabilities.set_data(result.hardware_capabilities);
    // Send EVSE.GetHardwareCapabilities request with valid ID
    send_req_and_validate_res(client, evse_get_hardware_capabilities_req_valid_index, expected_response);
    // Send EVSE.GetHardwareCapabilities request with invalid ID
    send_req_and_validate_res(client, evse_get_hardware_capabilities_req_invalid_index, expected_error_invalid_index,
                              is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send EVSE.SetChargingAllowed request with valid and invalid index
TEST_F(RpcHandlerTest, EvseSetChargingAllowedReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_set_charging_allowed_req_valid_index =
        create_json_rpc_request("EVSE.SetChargingAllowed", {{"evse_index", 1}, {"charging_allowed", true}}, 1);
    nlohmann::json evse_set_charging_allowed_req_valid_index_false =
        create_json_rpc_request("EVSE.SetChargingAllowed", {{"evse_index", 1}, {"charging_allowed", false}}, 1);
    nlohmann::json evse_set_charging_allowed_req_invalid_index =
        create_json_rpc_request("EVSE.SetChargingAllowed", {{"evse_index", 99}, {"charging_allowed", true}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1;
    data_store.evses[0]->evseinfo.set_data(evse_info);

    RPCDataTypes::EVSEStatusObj evse_status;
    evse_status.available = false;
    data_store.evses[0]->evsestatus.set_data(evse_status);

    // Set up the expected responses
    types::json_rpc_api::ErrorResObj result{RPCDataTypes::ResponseErrorEnum::NoError};
    nlohmann::json expected_response = create_json_rpc_response(result, 1);
    nlohmann::json expected_error = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.SetChargingAllowed request with valid ID
    send_req_and_validate_res(client, evse_set_charging_allowed_req_valid_index, expected_response);
    // Check if the EVSE status is updated
    ASSERT_TRUE(data_store.evses[0]->evsestatus.get_data().has_value());
    ASSERT_TRUE(data_store.evses[0]->evsestatus.get_data().value().charging_allowed);
    // Send EVSE.SetChargingAllowed request with valid ID and false
    send_req_and_validate_res(client, evse_set_charging_allowed_req_valid_index_false, expected_response);
    // Check if the EVSE status is updated
    ASSERT_TRUE(data_store.evses[0]->evsestatus.get_data().has_value());
    ASSERT_FALSE(data_store.evses[0]->evsestatus.get_data().value().charging_allowed);

    // Send EVSE.SetChargingAllowed request with invalid ID
    send_req_and_validate_res(client, evse_set_charging_allowed_req_invalid_index, expected_error,
                              is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send EVSE.MeterData request with valid and invalid index
TEST_F(RpcHandlerTest, EvseMeterDataReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_meter_data_req_valid_index =
        create_json_rpc_request("EVSE.GetMeterData", {{"evse_index", 1}}, 1);
    nlohmann::json evse_meter_data_req_invalid_index =
        create_json_rpc_request("EVSE.GetMeterData", {{"evse_index", 99}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1;
    data_store.evses[0]->evseinfo.set_data(evse_info);

    // Configure meter data, but do not set it in the data store
    RPCDataTypes::MeterDataObj meter_data{};
    meter_data.energy_Wh_import.total = 123.45;
    meter_data.timestamp = "2025-06-10T09:51:56Z";

    // Set up the expected responses
    types::json_rpc_api::EVSEGetMeterDataResObj result{{meter_data}, RPCDataTypes::ResponseErrorEnum::NoError};
    nlohmann::json expected_response_no_error = create_json_rpc_response(result, 1);
    nlohmann::json expected_error_no_data = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorNoDataAvailable)}};
    nlohmann::json expected_error_invalid_index = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.MeterData request with valid ID, but no meter data available
    send_req_and_validate_res(client, evse_meter_data_req_valid_index, expected_error_no_data,
                              is_key_value_in_json_rpc_result);

    // Set the meter data in the data store
    data_store.evses[0]->meterdata.set_data(meter_data);

    // Send EVSE.MeterData request with valid ID and meter data available
    send_req_and_validate_res(client, evse_meter_data_req_valid_index, expected_response_no_error);

    // Send EVSE.MeterData request with invalid ID
    send_req_and_validate_res(client, evse_meter_data_req_invalid_index, expected_error_invalid_index,
                              is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send EVSE.SetACCharging request with valid and invalid index
TEST_F(RpcHandlerTest, EvseSetACChargingReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_set_ac_charging_req_valid_index = create_json_rpc_request(
        "EVSE.SetACCharging",
        {{"evse_index", 1}, {"charging_allowed", true}, {"max_current", 12.3}, {"phase_count", 3}}, 1);

    // As long as the method is not implemented, we expect an error response that the method is not implemented
    nlohmann::json expected_res = create_json_rpc_error_response(-32601, "method not found: EVSE.SetACCharging", 1);

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.SetACCharging request with valid ID
    client.send(evse_set_ac_charging_req_valid_index.dump());
    // Wait for the response
    std::string received_data = client.wait_for_data(std::chrono::seconds(1), false);
    // Check if the response is valid
    nlohmann::json response = nlohmann::json::parse(received_data);
    ASSERT_EQ(response, expected_res);
}

// Test: Connect to WebSocket server and send EVSE.SetACChargingCurrent request with valid and invalid index
TEST_F(RpcHandlerTest, EvseSetACChargingCurrentReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_set_ac_charging_current_req_valid_index =
        create_json_rpc_request("EVSE.SetACChargingCurrent", {{"evse_index", 1}, {"max_current", 12.3}}, 1);
    nlohmann::json evse_set_ac_charging_current_req_invalid_index =
        create_json_rpc_request("EVSE.SetACChargingCurrent", {{"evse_index", 99}, {"max_current", 12.3}}, 1);
    nlohmann::json evse_set_ac_charging_current_req_invalid_max_current =
        create_json_rpc_request("EVSE.SetACChargingCurrent", {{"evse_index", 1}, {"max_current", 15.0}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info{};
    evse_info.index = 1;
    data_store.evses[0]->evseinfo.set_data(evse_info);

    RPCDataTypes::EVSEStatusObj evse_status{};
    evse_status.charging_allowed = true;
    data_store.evses[0]->evsestatus.set_data(evse_status);
    data_store.evses[0]->evsestatus.set_ac_charge_param_evse_max_current(12.3);

    // Set up the expected responses
    types::json_rpc_api::ErrorResObj result{RPCDataTypes::ResponseErrorEnum::NoError};
    nlohmann::json expected_response = create_json_rpc_response(result, 1);
    nlohmann::json expected_error_invalid_index = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};
    nlohmann::json expected_error_invalid_current = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorValuesNotApplied)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.SetACChargingCurrent request with valid ID
    send_req_and_validate_res(client, evse_set_ac_charging_current_req_valid_index, expected_response);

    // Send EVSE.SetACChargingCurrent request with invalid ID
    send_req_and_validate_res(client, evse_set_ac_charging_current_req_invalid_index, expected_error_invalid_index,
                              is_key_value_in_json_rpc_result);

    // Send EVSE.SetACChargingCurrent request with invalid AC charging current
    send_req_and_validate_res(client, evse_set_ac_charging_current_req_invalid_max_current,
                              expected_error_invalid_current, is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send EVSE.SetACChargingPhaseCount request with valid and invalid index
TEST_F(RpcHandlerTest, EvseSetACChargingPhaseCountReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_set_ac_charging_phase_count_req_valid_index =
        create_json_rpc_request("EVSE.SetACChargingPhaseCount", {{"evse_index", 1}, {"phase_count", 3}}, 1);
    nlohmann::json evse_set_ac_charging_phase_count_req_invalid_index =
        create_json_rpc_request("EVSE.SetACChargingPhaseCount", {{"evse_index", 99}, {"phase_count", 3}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1;
    data_store.evses[0]->evseinfo.set_data(evse_info);

    RPCDataTypes::EVSEStatusObj evse_status;
    evse_status.available = false;
    evse_status.ac_charge_param.emplace();
    evse_status.ac_charge_param->evse_max_current = 12.3;
    data_store.evses[0]->evsestatus.set_data(evse_status);

    RPCDataTypes::EVSEGetHardwareCapabilitiesResObj hw_cap;
    hw_cap.error = RPCDataTypes::ResponseErrorEnum::NoError;
    hw_cap.hardware_capabilities.max_current_A_export = 32.0;
    hw_cap.hardware_capabilities.max_current_A_import = 16.0;
    hw_cap.hardware_capabilities.max_phase_count_export = 3;
    hw_cap.hardware_capabilities.max_phase_count_import = 3;
    hw_cap.hardware_capabilities.min_current_A_export = 6.0;
    hw_cap.hardware_capabilities.min_current_A_import = 6.0;
    hw_cap.hardware_capabilities.min_phase_count_export = 1;
    hw_cap.hardware_capabilities.min_phase_count_import = 1;
    hw_cap.hardware_capabilities.phase_switch_during_charging = true;
    data_store.evses[0]->hardwarecapabilities.set_data(hw_cap.hardware_capabilities);

    // Set up the expected responses
    types::json_rpc_api::ErrorResObj result{RPCDataTypes::ResponseErrorEnum::NoError};
    nlohmann::json expected_response = create_json_rpc_response(result, 1);
    nlohmann::json expected_error = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.SetACChargingPhaseCount request with valid ID
    send_req_and_validate_res(client, evse_set_ac_charging_phase_count_req_valid_index, expected_response);
    // Send EVSE.SetACChargingPhaseCount request with invalid ID
    send_req_and_validate_res(client, evse_set_ac_charging_phase_count_req_invalid_index, expected_error,
                              is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send EVSE.SetACChargingPhaseCount request with invalid phases and disabled
// phase switching
TEST_F(RpcHandlerTest, EvseSetACChargingPhaseCountReqBadCases) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_set_ac_charging_phase_count_req_valid_phase_count =
        create_json_rpc_request("EVSE.SetACChargingPhaseCount", {{"evse_index", 1}, {"phase_count", 1}}, 1);
    nlohmann::json evse_set_ac_charging_phase_count_req_invalid_phase_count =
        create_json_rpc_request("EVSE.SetACChargingPhaseCount", {{"evse_index", 1}, {"phase_count", 2}}, 1);
    nlohmann::json evse_set_ac_charging_phase_count_req_out_of_range =
        create_json_rpc_request("EVSE.SetACChargingPhaseCount", {{"evse_index", 1}, {"phase_count", 3}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1;
    data_store.evses[0]->evseinfo.set_data(evse_info);

    RPCDataTypes::EVSEStatusObj evse_status;
    evse_status.available = false;
    evse_status.ac_charge_param.emplace();
    evse_status.ac_charge_param->evse_max_current = 12.3;
    evse_status.ac_charge_status.emplace();
    evse_status.ac_charge_status->evse_active_phase_count = 1;
    data_store.evses[0]->evsestatus.set_data(evse_status);

    RPCDataTypes::EVSEGetHardwareCapabilitiesResObj hw_cap;
    hw_cap.error = RPCDataTypes::ResponseErrorEnum::NoError;
    hw_cap.hardware_capabilities.max_current_A_export = 32.0;
    hw_cap.hardware_capabilities.max_current_A_import = 16.0;
    hw_cap.hardware_capabilities.max_phase_count_export = 1;
    hw_cap.hardware_capabilities.max_phase_count_import = 1;
    hw_cap.hardware_capabilities.min_current_A_export = 6.0;
    hw_cap.hardware_capabilities.min_current_A_import = 6.0;
    hw_cap.hardware_capabilities.min_phase_count_export = 1;
    hw_cap.hardware_capabilities.min_phase_count_import = 1;
    hw_cap.hardware_capabilities.phase_switch_during_charging = false;
    data_store.evses[0]->hardwarecapabilities.set_data(hw_cap.hardware_capabilities);

    // Set up the expected responses
    types::json_rpc_api::ErrorResObj result{RPCDataTypes::ResponseErrorEnum::NoError};
    nlohmann::json expected_no_error = create_json_rpc_response(result, 1);
    nlohmann::json expected_invalid_param = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidParameter)}};
    nlohmann::json expected_error_out_of_range = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorOutOfRange)}};
    nlohmann::json expected_error_operation_not_supported = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorOperationNotSupported)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.SetACChargingPhaseCount request with phase count. This should not lead to an error, because
    // an initialization of the phase count should be still possible.
    send_req_and_validate_res(client, evse_set_ac_charging_phase_count_req_valid_phase_count, expected_no_error);

    // Try to switch phase count although phase switching is not allowed (phase_switch_during_charging == false)
    send_req_and_validate_res(client, evse_set_ac_charging_phase_count_req_invalid_phase_count,
                              expected_error_operation_not_supported, is_key_value_in_json_rpc_result);

    // Send EVSE.SetACChargingPhaseCount request with phase count out of range
    // Enable phase switching, because otherwise it returns an ErrorOperationNotSupported error
    hw_cap.hardware_capabilities.phase_switch_during_charging = true;
    data_store.evses[0]->hardwarecapabilities.set_data(hw_cap.hardware_capabilities);
    send_req_and_validate_res(client, evse_set_ac_charging_phase_count_req_out_of_range, expected_error_out_of_range,
                              is_key_value_in_json_rpc_result);

    // Invalid phase count error occurs when phase_count is configured to 2
    hw_cap.hardware_capabilities.max_phase_count_export = 3;
    data_store.evses[0]->hardwarecapabilities.set_data(hw_cap.hardware_capabilities);
    send_req_and_validate_res(client, evse_set_ac_charging_phase_count_req_invalid_phase_count, expected_invalid_param,
                              is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send EVSE.SetDCCharging request with valid and invalid index
TEST_F(RpcHandlerTest, EvseSetDCChargingReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_set_dc_charging_req_valid_index = create_json_rpc_request(
        "EVSE.SetDCCharging", {{"evse_index", 1}, {"charging_allowed", true}, {"max_power", 12.3}}, 1);

    // As long as the method is not implemented, we expect an error response that the method is not implemented
    nlohmann::json expected_res = create_json_rpc_error_response(-32601, "method not found: EVSE.SetDCCharging", 1);
    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.SetDCCharging request with valid ID
    client.send(evse_set_dc_charging_req_valid_index.dump());
    // Wait for the response
    std::string received_data = client.wait_for_data(std::chrono::seconds(1), false);
    // Check if the response is valid
    nlohmann::json response = nlohmann::json::parse(received_data);
    ASSERT_EQ(response, expected_res);
}

// Test: Connect to WebSocket server and send EVSE.SetDCChargingPower request with valid and invalid index
TEST_F(RpcHandlerTest, EvseSetDCChargingPowerReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_set_dc_charging_power_req_valid_index =
        create_json_rpc_request("EVSE.SetDCChargingPower", {{"evse_index", 1}, {"max_power", 12.3}}, 1);
    nlohmann::json evse_set_dc_charging_power_req_invalid_index =
        create_json_rpc_request("EVSE.SetDCChargingPower", {{"evse_index", 99}, {"max_power", 12.3}}, 1);

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1;
    data_store.evses[0]->evseinfo.set_data(evse_info);

    RPCDataTypes::EVSEStatusObj evse_status;
    evse_status.available = false;
    evse_status.dc_charge_param.emplace();
    data_store.evses[0]->evsestatus.set_data(evse_status);

    // Set up the expected responses
    types::json_rpc_api::ErrorResObj result{RPCDataTypes::ResponseErrorEnum::NoError};
    nlohmann::json expected_response = create_json_rpc_response(result, 1);
    nlohmann::json expected_error = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.SetDCChargingPower request with valid ID
    send_req_and_validate_res(client, evse_set_dc_charging_power_req_valid_index, expected_response);
    // Send EVSE.SetDCChargingPower request with invalid ID
    send_req_and_validate_res(client, evse_set_dc_charging_power_req_invalid_index, expected_error,
                              is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send EVSE.EnableConnector request with valid and invalid index
TEST_F(RpcHandlerTest, EvseEnableConnectorReq) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Set up requests
    nlohmann::json evse_enable_connector_req_valid_index = create_json_rpc_request(
        "EVSE.EnableConnector", {{"evse_index", 1}, {"enable", true}, {"priority", 1}, {"connector_index", 1}}, 1);
    nlohmann::json evse_enable_connector_req_invalid_index = create_json_rpc_request(
        "EVSE.EnableConnector", {{"evse_index", 99}, {"enable", true}, {"priority", 1}, {"connector_index", 1}}, 1);
    nlohmann::json evse_enable_connector_req_invalid_connector_index = create_json_rpc_request(
        "EVSE.EnableConnector", {{"evse_index", 1}, {"enable", true}, {"priority", 1}, {"connector_index", 99}}, 1);

    // Set up the expected responses
    types::json_rpc_api::ErrorResObj result{RPCDataTypes::ResponseErrorEnum::NoError};
    nlohmann::json expected_response = create_json_rpc_response(result, 1);
    nlohmann::json expected_error = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidEVSEIndex)}};

    nlohmann::json expected_error_invalid_connector_index = {
        {"error", response_error_enum_to_string(RPCDataTypes::ResponseErrorEnum::ErrorInvalidConnectorIndex)}};

    // Set up the data store with test data
    RPCDataTypes::EVSEInfoObj evse_info;
    evse_info.index = 1;
    evse_info.available_connectors.emplace_back();
    evse_info.available_connectors[0].index = 1;
    evse_info.available_connectors[0].type = types::json_rpc_api::ConnectorTypeEnum::cCCS2;
    data_store.evses[0]->evseinfo.set_data(evse_info);

    RPCDataTypes::EVSEStatusObj evse_status;
    evse_status.available = false;
    data_store.evses[0]->evsestatus.set_data(evse_status);

    // Send Api.Hello request
    client.send_api_hello_req();
    client.wait_for_data(std::chrono::seconds(1));
    // Send EVSE.EnableConnector request with valid ID
    send_req_and_validate_res(client, evse_enable_connector_req_valid_index, expected_response);
    // Send EVSE.EnableConnector request with invalid ID
    send_req_and_validate_res(client, evse_enable_connector_req_invalid_index, expected_error,
                              is_key_value_in_json_rpc_result);
    // Send EVSE.EnableConnector request with invalid connector ID
    send_req_and_validate_res(client, evse_enable_connector_req_invalid_connector_index,
                              expected_error_invalid_connector_index, is_key_value_in_json_rpc_result);
}

// Test: Connect to WebSocket server and send invalid request
TEST_F(RpcHandlerTest, InvalidRequest) {
    WebSocketTestClient client("localhost", test_port);
    ASSERT_TRUE(client.connect());
    ASSERT_TRUE(client.wait_until_connected(std::chrono::milliseconds(100)));

    // Send Api.Hello request
    client.send_api_hello_req();
    // Wait for the response
    client.wait_for_data(std::chrono::seconds(1));
    // Send invalid request
    nlohmann::json invalid_request = create_json_rpc_request("API.InvalidMethod", {}, 1);
    // Expected response
    nlohmann::json expected_response = create_json_rpc_error_response(-32601, "method not found: API.InvalidMethod", 1);
    // Send invalid request
    client.send(invalid_request.dump());
    // Wait for the response
    std::string received_data = client.wait_for_data(std::chrono::seconds(1), false);
    // Check if the response is not empty
    ASSERT_FALSE(received_data.empty());
    // Check if the response is valid
    nlohmann::json response = nlohmann::json::parse(received_data);
    ASSERT_EQ(response, expected_response);
}