#include "google/google_service_nvme.hpp"

#include <systemd/sd-bus.h>

#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <system_error>  // NOLINT
#include <tuple>
#include <utility>
#include <vector>

#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "absl/functional/any_invocable.h"
#include "app.hpp"
#include "http_request.hpp"
#include "async_resp.hpp"
#include "dbus_utility.hpp"
#include <nlohmann/json.hpp>
#include "managed_store.hpp"
#include "managed_store_types.hpp"
#include "test/g3/mock_managed_store.hpp"
#include "test/g3/mock_managed_store_test.hpp"
#include "sdbusplus/message.hpp"
#include "sdbusplus/message/native_types.hpp"
#include "sdbusplus/test/sdbus_mock.hpp"

namespace crow::google_api {
namespace {

using ::managedStore::KeyType;
using ::managedStore::ManagedType;
using ::testing::_;
using ::testing::An;
using ::testing::MakePolymorphicAction;
using ::testing::NiceMock;
using ::testing::PolymorphicAction;
using ::testing::Return;

constexpr std::string_view kNvmeId = "nvme_0";
constexpr std::string_view kControllerId = "controller_0";
constexpr std::string_view kControllerPath =
    "/xyz/openbmc_project/inventory/system/board/nvme_0/controller_0";
constexpr std::string_view kNvmePath =
    "/xyz/openbmc_project/inventory/system/board/nvme_0";

class GoogleServiceNvmeTest : public ::managedStore::MockManagedStoreTest {
 protected:
  GoogleServiceNvmeTest() : app_(true) {
    share_async_resp_ = std::make_shared<bmcweb::AsyncResp>();
  }

  void SetUp() override {
    ::managedStore::MockManagedStoreTest::SetUp();

    // Mock NVMe Controller object
    KeyType nvmeKey(ManagedType::kManagedSubtree,
                    "/xyz/openbmc_project/inventory", 0,
                    {"xyz.openbmc_project.Inventory.Item.Drive"});

    dbus::utility::MapperGetSubTreeResponse subtree = {
        {std::string(kNvmePath),
         {{"xyz.openbmc_project.Inventory.Item.Drive",
           {"xyz.openbmc_project.Inventory.Item.Drive"}}}}};

    EXPECT_TRUE(
        dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
            managedStore::GetManagedObjectStore())
            ->upsertMockObjectIntoManagedStore(
                nvmeKey,
                managedStore::MockManagedStoreTest::CreateValueType(subtree))
            .ok());

    // Mock Drive Protocol
    KeyType protocolKey(ManagedType::kManagedProperty,
                        "xyz.openbmc_project.Inventory.Item.Drive",
                        sdbusplus::message::object_path(std::string(kNvmePath)),
                        "xyz.openbmc_project.Inventory.Item.Drive", "Protocol");

    dbus::utility::DbusVariantType protocolVariant = std::string(
        "xyz.openbmc_project.Inventory.Item.Drive.DriveProtocol.NVMe");
    EXPECT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                    managedStore::GetManagedObjectStore())
                    ->upsertMockObjectIntoManagedStore(
                        protocolKey,
                        managedStore::MockManagedStoreTest::CreateValueType(
                            protocolVariant))
                    .ok());

    // Mock storage controller association
    KeyType storageControllerKey(
        ManagedType::kManagedProperty, "xyz.openbmc_project.ObjectMapper",
        sdbusplus::message::object_path(std::string(kNvmePath) +
                                        "/storage_controller"),
        "xyz.openbmc_project.Association", "endpoints");

    std::vector<std::string> endpoints = {std::string(kControllerPath)};
    dbus::utility::DbusVariantType endpointsVariant = endpoints;

    EXPECT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                    managedStore::GetManagedObjectStore())
                    ->upsertMockObjectIntoManagedStore(
                        storageControllerKey,
                        managedStore::MockManagedStoreTest::CreateValueType(
                            endpointsVariant))
                    .ok());

    // Mock Lockdown Interface
    KeyType lockdownKey(ManagedType::kManagedMapperObject,
                        std::string(kControllerPath),
                        {"xyz.openbmc_project.NVMe.Lockdown"});
    dbus::utility::MapperGetObject lockdownObject = {
        {"xyz.openbmc_project.NVMe.Lockdown",
         {{"xyz.openbmc_project.NVMe.Lockdown", {}}}}};

    EXPECT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                    managedStore::GetManagedObjectStore())
                    ->upsertMockObjectIntoManagedStore(
                        lockdownKey,
                        managedStore::MockManagedStoreTest::CreateValueType(
                            lockdownObject))
                    .ok());
  }

  crow::Request CreateRequest(std::string_view body) {
    std::error_code ec;
    boost::beast::http::request<boost::beast::http::string_body> beastReq;
    beastReq.method(boost::beast::http::verb::post);
    beastReq.target(
        "/google/v1/NVMe/nvme_0/Controllers/controller_0/Actions/"
        "NVMeController.LockdownInband");
    beastReq.set(boost::beast::http::field::content_type, "application/json");
    beastReq.body() = std::string(body);
    beastReq.prepare_payload();
    return crow::Request(beastReq, ec);
  }

  std::shared_ptr<bmcweb::AsyncResp> share_async_resp_;
  App app_;
};

class SimulateSuccessfulAsyncPostDbusCallThreadSafeWithMsgAndValueAction {
  const std::tuple<uint32_t, uint32_t, uint32_t, std::string, uint32_t> value_;

 public:
  explicit SimulateSuccessfulAsyncPostDbusCallThreadSafeWithMsgAndValueAction(
      const std::tuple<uint32_t, uint32_t, uint32_t, std::string, uint32_t>&
          value)
      : value_(value) {}

  template <typename Result, typename ArgumentTuple>
  Result Perform(const ArgumentTuple& args) const {
    auto callback = std::make_shared<absl::AnyInvocable<void(
        const boost::system::error_code&, const sdbusplus::message_t&,
        const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                         uint32_t>&)>>(
        std::move(std::get<1>(const_cast<ArgumentTuple&>(args))));
    managedStore::GetManagedObjectStore()->GetIoContext().post(
        [callback, val = value_]() mutable {
          // Mock sdbus message
          auto sdbus = std::make_shared<NiceMock<sdbusplus::SdBusMock>>();
          EXPECT_CALL(*sdbus, sd_bus_message_ref(_))
              .WillRepeatedly(Return(nullptr));
          EXPECT_CALL(*sdbus, sd_bus_message_get_error(_))
              .WillRepeatedly(Return(nullptr));

          sdbusplus::message_t msg(nullptr, sdbus.get());

          std::move (*callback)(boost::system::error_code(), msg, val);
        });
  }

  static PolymorphicAction<
      SimulateSuccessfulAsyncPostDbusCallThreadSafeWithMsgAndValueAction>
  SimulateSuccessfulAsyncPostDbusCallWithMsgAndValue(
      const std::tuple<uint32_t, uint32_t, uint32_t, std::string, uint32_t>&
          value) {
    return MakePolymorphicAction(
        SimulateSuccessfulAsyncPostDbusCallThreadSafeWithMsgAndValueAction(
            value));
  }
};

TEST_F(GoogleServiceNvmeTest, LockdownInbandProhibitFalse) {
  EXPECT_CALL(
      *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore()),
      PostDbusCallToIoContextThreadSafe(
          _,
          An<absl::AnyInvocable<void(
              const boost::system::error_code&, const sdbusplus::message_t&,
              const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                               uint32_t>&)>&&>(),
          "xyz.openbmc_project.NVMe.Lockdown", std::string(kControllerPath),
          "xyz.openbmc_project.NVMe.Lockdown", "LockdownInband", 0,
          std::vector<uint8_t>{}, std::vector<uint8_t>{},
          std::vector<uint8_t>{}))
      .Times(1)
      .WillOnce(
          SimulateSuccessfulAsyncPostDbusCallThreadSafeWithMsgAndValueAction::
              SimulateSuccessfulAsyncPostDbusCallWithMsgAndValue(
                  std::make_tuple(uint32_t{0}, uint32_t{0}, uint32_t{0},
                                  std::string{""}, uint32_t{0})));

  crow::Request req = CreateRequest(R"({"Prohibit": false})");

  handleGoogleNvmeControllerLockdownInband(app_, req, share_async_resp_,
                                           std::string(kNvmeId),
                                           std::string(kControllerId));

  RunIoUntilDone();

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

TEST_F(GoogleServiceNvmeTest, LockdownInbandProhibitTrue) {
  EXPECT_CALL(
      *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore()),
      PostDbusCallToIoContextThreadSafe(
          _,
          An<absl::AnyInvocable<void(
              const boost::system::error_code&, const sdbusplus::message_t&,
              const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                               uint32_t>&)>&&>(),
          "xyz.openbmc_project.NVMe.Lockdown", std::string(kControllerPath),
          "xyz.openbmc_project.NVMe.Lockdown", "LockdownInband", 1,
          std::vector<uint8_t>{}, std::vector<uint8_t>{},
          std::vector<uint8_t>{}))
      .Times(1)
      .WillOnce(
          SimulateSuccessfulAsyncPostDbusCallThreadSafeWithMsgAndValueAction::
              SimulateSuccessfulAsyncPostDbusCallWithMsgAndValue(
                  std::make_tuple(0, 0, 0, "", 0)));

  crow::Request req = CreateRequest(R"({"Prohibit": true})");

  handleGoogleNvmeControllerLockdownInband(app_, req, share_async_resp_,
                                           std::string(kNvmeId),
                                           std::string(kControllerId));

  RunIoUntilDone();

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

TEST_F(GoogleServiceNvmeTest, LockdownInbandWithAdminCmds) {
  std::vector<uint8_t> expectedAdminCmds = {0x1, 0x2, 0x3};

  EXPECT_CALL(
      *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore()),
      PostDbusCallToIoContextThreadSafe(
          _,
          An<absl::AnyInvocable<void(
              const boost::system::error_code&, const sdbusplus::message_t&,
              const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                               uint32_t>&)>&&>(),
          "xyz.openbmc_project.NVMe.Lockdown", std::string(kControllerPath),
          "xyz.openbmc_project.NVMe.Lockdown", "LockdownInband", 0,
          expectedAdminCmds, std::vector<uint8_t>{}, std::vector<uint8_t>{}))
      .Times(1)
      .WillOnce(
          SimulateSuccessfulAsyncPostDbusCallThreadSafeWithMsgAndValueAction::
              SimulateSuccessfulAsyncPostDbusCallWithMsgAndValue(
                  std::make_tuple(0, 0, 0, "", 0)));

  crow::Request req =
      CreateRequest(R"({"Prohibit": false, "AdminCmds": [1, 2, 3]})");

  handleGoogleNvmeControllerLockdownInband(app_, req, share_async_resp_,
                                           std::string(kNvmeId),
                                           std::string(kControllerId));

  RunIoUntilDone();

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

TEST_F(GoogleServiceNvmeTest, LockdownInbandAllParams) {
  std::vector<uint8_t> expectedAdminCmds = {0xA};
  std::vector<uint8_t> expectedFeatures = {0xB, 0xC};
  std::vector<uint8_t> expectedLogPages = {0xD};

  EXPECT_CALL(
      *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore()),
      PostDbusCallToIoContextThreadSafe(
          _,
          An<absl::AnyInvocable<void(
              const boost::system::error_code&, const sdbusplus::message_t&,
              const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                               uint32_t>&)>&&>(),
          "xyz.openbmc_project.NVMe.Lockdown", std::string(kControllerPath),
          "xyz.openbmc_project.NVMe.Lockdown", "LockdownInband", 1,
          expectedAdminCmds, expectedFeatures, expectedLogPages))
      .Times(1)
      .WillOnce(
          SimulateSuccessfulAsyncPostDbusCallThreadSafeWithMsgAndValueAction::
              SimulateSuccessfulAsyncPostDbusCallWithMsgAndValue(
                  std::make_tuple(0, 0, 0, "", 0)));

  crow::Request req = CreateRequest(
      R"({"Prohibit": true, "AdminCmds": [10], "Features": [11, 12], "LogPages": [13]})");

  handleGoogleNvmeControllerLockdownInband(app_, req, share_async_resp_,
                                           std::string(kNvmeId),
                                           std::string(kControllerId));

  RunIoUntilDone();

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

TEST_F(GoogleServiceNvmeTest, LockdownInbandDbusError) {
  NiceMock<sdbusplus::SdBusMock> sdbus;
  ::sd_bus_error err = SD_BUS_ERROR_NULL;
  err.name = "org.freedesktop.DBus.Error.Failed";
  err.message = "D-Bus call failed";

  EXPECT_CALL(sdbus, sd_bus_message_get_error(_)).WillRepeatedly(Return(&err));
  EXPECT_CALL(sdbus, sd_bus_message_ref(_)).WillRepeatedly(Return(nullptr));

  sdbusplus::message_t msg(nullptr, &sdbus);

  EXPECT_CALL(
      *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore()),
      PostDbusCallToIoContextThreadSafe(
          _,
          An<absl::AnyInvocable<void(
              const boost::system::error_code&, const sdbusplus::message_t&,
              const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                               uint32_t>&)>&&>(),
          _, _, _, _, _, _, _, _))
      .Times(1)
      .WillOnce([msg](auto&&, auto&& callback, auto&&...) mutable {
        auto callback_in = std::make_shared<absl::AnyInvocable<void(
            const boost::system::error_code&, const sdbusplus::message_t&,
            const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                             uint32_t>&)>>(
            std::forward<decltype(callback)>(callback));
        managedStore::GetManagedObjectStore()->GetIoContext().post(
            [callback_in, msg]() mutable {
              std::move (*callback_in)(boost::system::error_code(), msg, {});
            });
      });

  crow::Request req = CreateRequest(R"({"Prohibit": false})");

  handleGoogleNvmeControllerLockdownInband(app_, req, share_async_resp_,
                                           std::string(kNvmeId),
                                           std::string(kControllerId));

  RunIoUntilDone();

  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::internal_server_error);
  EXPECT_EQ(share_async_resp_->res.jsonValue["error"]["message"],
            "D-Bus call failed");
}

TEST_F(GoogleServiceNvmeTest, LockdownInbandBoostError) {
  NiceMock<sdbusplus::SdBusMock> sdbus;
  EXPECT_CALL(sdbus, sd_bus_message_get_error(_))
      .WillRepeatedly(Return(nullptr));
  EXPECT_CALL(sdbus, sd_bus_message_ref(_)).WillRepeatedly(Return(nullptr));

  sdbusplus::message_t msg(nullptr, &sdbus);

  EXPECT_CALL(
      *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore()),
      PostDbusCallToIoContextThreadSafe(
          _,
          An<absl::AnyInvocable<void(
              const boost::system::error_code&, const sdbusplus::message_t&,
              const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                               uint32_t>&)>&&>(),
          _, _, _, _, _, _, _, _))
      .Times(1)
      .WillOnce([msg](auto&&, auto&& callback, auto&&...) mutable {
        auto callback_in = std::make_shared<absl::AnyInvocable<void(
            const boost::system::error_code&, const sdbusplus::message_t&,
            const std::tuple<uint32_t, uint32_t, uint32_t, std::string,
                             uint32_t>&)>>(
            std::forward<decltype(callback)>(callback));
        managedStore::GetManagedObjectStore()->GetIoContext().post(
            [callback_in, msg]() mutable {
              std::move (*callback_in)(boost::system::errc::make_error_code(
                                           boost::system::errc::not_connected),
                                       msg, {});
            });
      });

  crow::Request req = CreateRequest(R"({"Prohibit": false})");

  handleGoogleNvmeControllerLockdownInband(app_, req, share_async_resp_,
                                           std::string(kNvmeId),
                                           std::string(kControllerId));

  RunIoUntilDone();

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

}  // namespace
}  // namespace crow::google_api