#include "app.hpp"
#include "bmcweb_config.h"

#include "async_resp.hpp"
#include "http_response.hpp"
#include "nlohmann/json.hpp"
#include "systems.hpp"
#include "snapshot_fixture.hpp"

#include <memory>
#include <vector>

#include <gmock/gmock.h> // IWYU pragma: keep
#include <gtest/gtest.h> // IWYU pragma: keep

// IWYU pragma: no_include <gtest/gtest-message.h>
// IWYU pragma: no_include <gtest/gtest-test-part.h>
// IWYU pragma: no_include "gtest/gtest_pred_impl.h"
// IWYU pragma: no_include <gmock/gmock-matchers.h>
// IWYU pragma: no_include <gtest/gtest-matchers.h>

namespace redfish
{
namespace
{

using ::dbus::utility::DbusVariantType;
using ::managedStore::KeyType;
using ::managedStore::ManagedObjectStoreContext;
using ::managedStore::ManagedType;
using ::managedStore::SimulateFailedAsyncPostDbusCallThreadSafeAction;
using ::managedStore::SimulateSuccessfulAsyncPostDbusCallThreadSafeAction;
using ::managedStore::ValueType;
using ::testing::An;
using ::testing::_;

TEST(HandlerSystemTest, VerifyCreateResetActionInfoResponse)
{
    auto shareAsyncResp = std::make_shared<bmcweb::AsyncResp>();

    createResetActionInfoResponse(shareAsyncResp, "test");
    nlohmann::json& json = shareAsyncResp->res.jsonValue;
    EXPECT_EQ(json["@odata.id"], "/redfish/v1/Systems/test/ResetActionInfo");
    EXPECT_EQ(json["@odata.type"], "#ActionInfo.v1_1_2.ActionInfo");
    EXPECT_EQ(json["Name"], "Reset Action Info");
    EXPECT_EQ(json["Id"], "ResetActionInfo");

    nlohmann::json::array_t parameters;
    nlohmann::json::object_t parameter;

    parameter["Name"] = "ResetType";
    parameter["Required"] = true;
    parameter["DataType"] = "String";
    parameter["Delay"] = "Number";
    nlohmann::json::array_t allowableValues;
    allowableValues.emplace_back("On");
    allowableValues.emplace_back("ForceOff");
    allowableValues.emplace_back("ForceOn");
    allowableValues.emplace_back("ForceRestart");
    allowableValues.emplace_back("GracefulRestart");
    allowableValues.emplace_back("GracefulShutdown");
    allowableValues.emplace_back("PowerCycle");
    allowableValues.emplace_back("Nmi");
    allowableValues.emplace_back("ReallyGracefulShutDownTechDebt");
    parameter["AllowableValues"] = std::move(allowableValues);
    parameters.emplace_back(std::move(parameter));

    nlohmann::json::object_t delayParameter;
    delayParameter["Name"] = "Delay";
    delayParameter["Required"] = false;
    delayParameter["DataType"] = "Number";
    parameters.emplace_back(std::move(delayParameter));
    EXPECT_EQ(json["Parameters"], parameters);
}

TEST(GetSystemResetCommandFromInputTest, TestOnAndForceOnReturnCorrectly)
{
    SystemResetCommand systemResetCommandOn = GetSystemResetCommandFromInput("On");
    EXPECT_EQ(systemResetCommandOn.command, "xyz.openbmc_project.State.Host.Transition.On");
    EXPECT_TRUE(systemResetCommandOn.hostCommand);
    EXPECT_TRUE(systemResetCommandOn.validCommand);

    SystemResetCommand systemResetCommandForceOn = GetSystemResetCommandFromInput("ForceOn");
    EXPECT_EQ(systemResetCommandForceOn.command, "xyz.openbmc_project.State.Host.Transition.On");
    EXPECT_TRUE(systemResetCommandForceOn.hostCommand);
    EXPECT_TRUE(systemResetCommandForceOn.validCommand);
}

TEST(GetSystemResetCommandFromInputTest, TestForceOffReturnCorrectly)
{
    SystemResetCommand systemResetCommandOn = GetSystemResetCommandFromInput("ForceOff");
    EXPECT_EQ(systemResetCommandOn.command, "xyz.openbmc_project.State.Chassis.Transition.Off");
    EXPECT_FALSE(systemResetCommandOn.hostCommand);
    EXPECT_TRUE(systemResetCommandOn.validCommand);
}

TEST(GetSystemResetCommandFromInputTest, TestForceRestartReturnCorrectly)
{
    SystemResetCommand systemResetCommandOn = GetSystemResetCommandFromInput("ForceRestart");
    EXPECT_EQ(systemResetCommandOn.command, "xyz.openbmc_project.State.Host.Transition.ForceWarmReboot");
    EXPECT_TRUE(systemResetCommandOn.hostCommand);
    EXPECT_TRUE(systemResetCommandOn.validCommand);
}

TEST(GetSystemResetCommandFromInputTest, TestGracefulShutdownReturnCorrectly)
{
    SystemResetCommand systemResetCommandOn = GetSystemResetCommandFromInput("GracefulShutdown");
    EXPECT_EQ(systemResetCommandOn.command, "xyz.openbmc_project.State.Host.Transition.Off");
    EXPECT_TRUE(systemResetCommandOn.hostCommand);
    EXPECT_TRUE(systemResetCommandOn.validCommand);
}

TEST(GetSystemResetCommandFromInputTest, TestGracefulRestartReturnCorrectly)
{
    SystemResetCommand systemResetCommandOn = GetSystemResetCommandFromInput("GracefulRestart");
    EXPECT_EQ(systemResetCommandOn.command, "xyz.openbmc_project.State.Host.Transition.GracefulWarmReboot");
    EXPECT_TRUE(systemResetCommandOn.hostCommand);
    EXPECT_TRUE(systemResetCommandOn.validCommand);
}

TEST(GetSystemResetCommandFromInputTest, TestPowerCycleReturnCorrectly)
{
    SystemResetCommand systemResetCommandOn = GetSystemResetCommandFromInput("PowerCycle");
    EXPECT_EQ(systemResetCommandOn.command, "xyz.openbmc_project.State.Host.Transition.Reboot");
    EXPECT_TRUE(systemResetCommandOn.hostCommand);
    EXPECT_TRUE(systemResetCommandOn.validCommand);
}

TEST(GetSystemResetCommandFromInputTest, TestReallyGracefulShutDownTechDebtReturnCorrectly)
{
    SystemResetCommand systemResetCommandOn = GetSystemResetCommandFromInput("ReallyGracefulShutDownTechDebt");
    EXPECT_EQ(systemResetCommandOn.command, "xyz.openbmc_project.State.Host.Transition.ReallyGracefulShutDown");
    EXPECT_TRUE(systemResetCommandOn.hostCommand);
    EXPECT_TRUE(systemResetCommandOn.validCommand);
}

TEST(GetSystemResetCommandFromInputTest, TestInvalidInput)
{
    SystemResetCommand systemResetCommandOn = GetSystemResetCommandFromInput("SomeInvalidInput");
    EXPECT_FALSE(systemResetCommandOn.validCommand);
}

TEST(GetSystemSuffixHelperTest, TestAllInputs)
{
    // Empty, invalid strings
    EXPECT_EQ("", getSystemSuffix(""));
    EXPECT_EQ("", getSystemSuffix("asdf"));
    EXPECT_EQ("", getSystemSuffix("syste"));
    // Valid Systems/
    EXPECT_EQ("", getSystemSuffix("system"));
    EXPECT_EQ("1", getSystemSuffix("system1"));
    EXPECT_EQ("13", getSystemSuffix("system13"));
    EXPECT_EQ("FUTURE", getSystemSuffix("systemFUTURE"));
}

TEST(HandlerSystemTest, HelpersValuesEnable)
{
    auto shareAsyncResp = std::make_shared<bmcweb::AsyncResp>();
    nlohmann::json& json = shareAsyncResp->res.jsonValue;

    json["MemorySummary"]["Status"]["State"] = "Disabled";
    json["ProcessorSummary"]["Count"] = 1;
    json["ProcessorSummary"]["Status"]["State"] = "Disabled";

    updateDimmProperties(shareAsyncResp, true);
    modifyCpuPresenceState(shareAsyncResp, true);
    modifyCpuFunctionalState(shareAsyncResp, true);

    EXPECT_EQ(json["MemorySummary"]["Status"]["State"], "Enabled");
    EXPECT_EQ(json["ProcessorSummary"]["Count"], 2);
    EXPECT_EQ(json["ProcessorSummary"]["Status"]["State"], "Enabled");
}

TEST_F(SnapshotFixture, PostSystemResetAsNMIOnDBusCallFailed){
    EXPECT_CALL(*managedStore::GetManagedObjectStore(),
                PostDbusCallToIoContextThreadSafe(_, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(),
                "xyz.openbmc_project.Control.Host.NMI", "/xyz/openbmc_project/control/host0/nmi",
                "xyz.openbmc_project.Control.Host.NMI", "NMI"))
        .Times(1)
        .WillOnce(SimulateFailedAsyncPostDbusCallThreadSafeAction::
                    SimulateFailedAsyncPostDbusCall());

    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"Nmi\"}"), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::internal_server_error);
}

TEST_F(SnapshotFixture, PostSystemResetAsNMIOnDBusCallSuccess){
    EXPECT_CALL(*managedStore::GetManagedObjectStore(),
                PostDbusCallToIoContextThreadSafe(_, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(),
                "xyz.openbmc_project.Control.Host.NMI", "/xyz/openbmc_project/control/host0/nmi",
                "xyz.openbmc_project.Control.Host.NMI", "NMI"))
        .Times(1)
        .WillOnce(SimulateSuccessfulAsyncPostDbusCallThreadSafeAction::
                    SimulateSuccessfulAsyncPostDbusCall());

    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"Nmi\"}"), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST_F(SnapshotFixture, PostSystemResetSingleSystemHostResetOnFail){
    EXPECT_CALL(*managedStore::GetManagedObjectStore(),
                PostDbusCallToIoContextThreadSafe(_, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(),
                "xyz.openbmc_project.State.Host", "/xyz/openbmc_project/state/host0",
                "org.freedesktop.DBus.Properties", "Set", "xyz.openbmc_project.State.Host", "RequestedHostTransition",
                dbus::utility::DbusVariantType("xyz.openbmc_project.State.Host.Transition.On")))
        .Times(1)
        .WillOnce(SimulateFailedAsyncPostDbusCallThreadSafeAction::
                    SimulateFailedAsyncPostDbusCall());

    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"ForceOn\"}"), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::internal_server_error);
}

TEST_F(SnapshotFixture, PostSystemResetSingleSystemHostResetOnSuccess){
    EXPECT_CALL(*managedStore::GetManagedObjectStore(),
                PostDbusCallToIoContextThreadSafe(_, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(),
                "xyz.openbmc_project.State.Host", "/xyz/openbmc_project/state/host0",
                "org.freedesktop.DBus.Properties", "Set", "xyz.openbmc_project.State.Host", "RequestedHostTransition",
                dbus::utility::DbusVariantType("xyz.openbmc_project.State.Host.Transition.On")))
        .Times(1)
        .WillOnce(SimulateSuccessfulAsyncPostDbusCallThreadSafeAction::
                    SimulateSuccessfulAsyncPostDbusCall());

    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"ForceOn\"}"), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST_F(SnapshotFixture, PostSystemResetSingleSystemChassisResetOnFail){
    EXPECT_CALL(*managedStore::GetManagedObjectStore(),
                PostDbusCallToIoContextThreadSafe(_, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(),
                "xyz.openbmc_project.State.Chassis", "/xyz/openbmc_project/state/chassis0",
                "org.freedesktop.DBus.Properties", "Set", "xyz.openbmc_project.State.Chassis", "RequestedPowerTransition",
                dbus::utility::DbusVariantType("xyz.openbmc_project.State.Chassis.Transition.Off")))
        .Times(1)
        .WillOnce(SimulateFailedAsyncPostDbusCallThreadSafeAction::
                    SimulateFailedAsyncPostDbusCall());

    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"ForceOff\"}"), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::internal_server_error);
}

TEST_F(SnapshotFixture, PostSystemResetSingleSystemChassisResetOnSuccess){
    EXPECT_CALL(*managedStore::GetManagedObjectStore(),
                PostDbusCallToIoContextThreadSafe(_, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(),
                "xyz.openbmc_project.State.Chassis", "/xyz/openbmc_project/state/chassis0",
                "org.freedesktop.DBus.Properties", "Set", "xyz.openbmc_project.State.Chassis", "RequestedPowerTransition",
                dbus::utility::DbusVariantType("xyz.openbmc_project.State.Chassis.Transition.Off")))
        .Times(1)
        .WillOnce(SimulateSuccessfulAsyncPostDbusCallThreadSafeAction::
                    SimulateSuccessfulAsyncPostDbusCall());

    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"ForceOff\"}"), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST_F(SnapshotFixture, CheckComputerSystemHostStateSingleHost)
{
    KeyType key(
        ManagedType::kManagedProperty, "xyz.openbmc_project.State.Host",
        sdbusplus::message::object_path("/xyz/openbmc_project/state/host0"),
        "xyz.openbmc_project.State.Host", "CurrentHostState");
    const std::array<std::tuple<std::string, std::string, std::string>, 6>
        testCases{
            {{"xyz.openbmc_project.State.Host.HostState.Running", "On",
              "Enabled"},
             {"xyz.openbmc_project.State.Host.HostState.Quiesced", "On",
              "Quiesced"},
             {"xyz.openbmc_project.State.Host.HostState.DiagnosticMode", "On",
              "InTest"},
             {"xyz.openbmc_project.State.Host.HostState.TransitioningToRunning",
              "PoweringOn", "Starting"},
             {"xyz.openbmc_project.State.Host.HostState.TransitioningToOff",
              "PoweringOff", "Disabled"},
             {"xyz.openbmc_project.State.Host.HostState.OtherDummy", "Off",
              "Disabled"}}};
    for (auto testCase : testCases)
    {
        const auto [currentHostState, powerState, status] = testCase;
        DbusVariantType targetState = currentHostState;
        std::shared_ptr<ValueType> mockHostStateValue =
            managedStore::MockManagedStoreTest::CreateValueType(
                std::move(targetState));
        ASSERT_TRUE(
            managedStore::GetManagedObjectStore()
                ->upsertMockObjectIntoManagedStore(key, mockHostStateValue)
                .ok());
        handleComputerSystem(share_async_resp_, "", "system", false);

        RunIoUntilDone();

        nlohmann::json& json = share_async_resp_->res.jsonValue;
        EXPECT_TRUE(json.contains("PowerState"));
        EXPECT_TRUE(json.contains("Status"));
        EXPECT_EQ(json["PowerState"], powerState);
        EXPECT_TRUE(json["Status"].contains("State"));
        EXPECT_EQ(json["Status"]["State"], status);
    }
}

TEST_F(SnapshotFixture, PostSystemResetSingleSystemChassisResetOnSuccessDelay){
    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"ForceOff\", \"Delay\":1} "), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
    EXPECT_EQ(share_async_resp_->res.jsonValue["ResetString"],
         "systemd-run --on-active=1 --timer-property=AccuracySec=100ms -- "
         "curl -d {\"ResetType\":\"ForceOff\"} -H Content-Type: application/json "
         "-X POST localhost:80/redfish/v1/Systems/system/Actions/ComputerSystem.Reset");
}

TEST_F(SnapshotFixture, PostSystemResetSingleSystemChassisResetOnFailTimeDelay){
    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"ForceOff\", \"Delay\":901} "), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(),boost::beast::http::status::bad_request);
}

TEST_F(SnapshotFixture, PostSystemResetSingleSystemChassisResetOnFailTypeDelay){
    handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"PleaseReset\", \"Delay\":1} "), share_async_resp_, "system");

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(),boost::beast::http::status::bad_request);
}

TEST_F(SnapshotFixture, HandleGetSystemBootGuestOSInfo)
{
    handleGetSystemBootGuestOSInfo(app_, CreateRequest(""), share_async_resp_,
                                   "system2");
    RunIoUntilDone();

    nlohmann::json& json = share_async_resp_->res.jsonValue;
    EXPECT_EQ(json["@odata.id"],
              "/redfish/v1/System/system2/Oem/Google/BootGuestOSActionInfo");
}

TEST_F(SnapshotFixture, handleGetBareMetalInstanceBase)
{
    handleGetBareMetalInstance(app_, CreateRequest(""), share_async_resp_,
                               "system1");
    RunIoUntilDone();

    nlohmann::json& json = share_async_resp_->res.jsonValue;
    EXPECT_EQ(json["@odata.id"],
              "/redfish/v1/Systems/system1/Oem/Google/BareMetalInstance");
    EXPECT_EQ(json["@odata.type"],
              "#GoogleBareMetalInstance.v1_0_0.GoogleBareMetalInstance");
}

} // namespace
} // namespace redfish