#include "bios.hpp"

#include <cstdint>  // IWYU pragma: keep
#include <filesystem>  // NOLINT
#include <fstream>
#include <memory>
#include <optional>
#include <string>
#include <system_error>  // NOLINT
#include <vector>

#include <gmock/gmock.h>  // IWYU pragma: keep
#include <gtest/gtest.h>  // IWYU pragma: keep
#include "absl/cleanup/cleanup.h"
#include "absl/functional/any_invocable.h"  // IWYU pragma: keep
#include "absl/log/log.h"
#include "boost/system/error_code.hpp"  // NOLINT
#include "http_request.hpp"
#include "logging.hpp"
#include "dbus_utility.hpp"
#include "snapshot_fixture.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"

// 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::ManagedType;
using ::managedStore::ValueType;

TEST(ResourceIdFromNameString, ResourceIdFromNameString) {
  EXPECT_EQ(resourceIdFromNameString("system10"), "10");
}

TEST_F(SnapshotFixture,
       SingleHostPlatformHandleBiosServiceGetTestReturnsCorrectResponse) {
#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
  KeyType key(ManagedType::kManagedSubtreePaths, "/", 0,
              {"xyz.openbmc_project.Inventory.Item.System"});

  absl::StatusOr<std::shared_ptr<ValueType>> systemObjectsPath =
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->getMockObjectFromManagedStore(key);
  ASSERT_TRUE(systemObjectsPath.ok());

  std::optional<dbus::utility::MapperGetSubTreePathsResponse>
      originalSystemObjectsPaths =
          systemObjectsPath.value()->managedSubtreePaths;
  ASSERT_TRUE(originalSystemObjectsPaths.has_value());

  dbus::utility::MapperGetSubTreePathsResponse mockSingleHostSystem1 = {
      "/xyz/openbmc_project/inventory/system1"};

  ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                  managedStore::GetManagedObjectStore())
                  ->upsertMockObjectIntoManagedStore(
                      key, managedStore::MockManagedStoreTest::CreateValueType(
                               mockSingleHostSystem1))
                  .ok());

  absl::Cleanup mockManagedStoreResetter = [key, originalSystemObjectsPaths]() {
    ASSERT_TRUE(
        dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
            managedStore::GetManagedObjectStore())
            ->upsertMockObjectIntoManagedStore(
                key, managedStore::MockManagedStoreTest::CreateValueType(
                         originalSystemObjectsPaths.value()))
            .ok());
  };

  std::string originalPath = biosSettingFilepathFromConfig;
  biosSettingFilepathFromConfig = "/tmp/soc_firmware/host/vmtppr.cfg";
  absl::Cleanup pathResetter = [originalPath]() {
    biosSettingFilepathFromConfig = originalPath;
  };
  std::string systemName = "system1";
#else
  std::string systemName = "system";
#endif

  handleBiosServiceGet(app_, CreateRequest(), share_async_resp_, systemName);

  RunIoUntilDone();

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json["@odata.id"], "/redfish/v1/Systems/" + systemName + "/Bios");
  EXPECT_EQ(json["@odata.type"], "#Bios.v1_1_0.Bios");
  EXPECT_EQ(
      json["Actions"]["#Bios.ResetBios"]["target"],
      "/redfish/v1/Systems/" + systemName + "/Bios/Actions/Bios.ResetBios");
  EXPECT_EQ(json["Description"], "BIOS Configuration Service");
  EXPECT_EQ(json["Id"], "BIOS");
  EXPECT_EQ(json["Links"]["ActiveSoftwareImage"]["@odata.id"],
            "/redfish/v1/UpdateService/FirmwareInventory/bios_active");

  EXPECT_TRUE(json["Links"]["SoftwareImages"].is_array());
  EXPECT_EQ(json["Links"]["SoftwareImages"].size(), 1);
  EXPECT_EQ(json["Links"]["SoftwareImages"][0]["@odata.id"],
            "/redfish/v1/UpdateService/FirmwareInventory/bios_active");
  EXPECT_EQ(json["Links"]["SoftwareImages@odata.count"], 1);
  EXPECT_EQ(json["Name"], "BIOS Configuration");
  EXPECT_EQ(json["Oem"]["Google"]["MemTestBlob"], "");

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

TEST_F(SnapshotFixture,
       SingleHostPlatformHandleBiosServiceGetTestReturnsNotFound) {
  handleBiosServiceGet(app_, CreateRequest(), share_async_resp_, "system1");

  RunIoUntilDone();

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

TEST_F(SnapshotFixture,
       SingleHostPlatformHandleBiosServiceGetSystemSubTreePathsResponseError) {
  // Looking for
  // kManagedSubtreePaths|/|0|xyz.openbmc_project.Inventory.Item.System
  KeyType key(ManagedType::kManagedSubtreePaths, "/", 0,
              {"xyz.openbmc_project.Inventory.Item.System"});

  absl::StatusOr<std::shared_ptr<ValueType>> systemObjectsPath =
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->getMockObjectFromManagedStore(key);
  ASSERT_TRUE(systemObjectsPath.ok());

  // TODO(b/416746677): Uncomment after the bug is fixed
  // ASSERT_EQ(systemObjectsPath.value()->managedType,
  //           ManagedType::kManagedSubtreePaths);

  std::optional<dbus::utility::MapperGetSubTreePathsResponse>
      originalSystemObjectsPaths =
          systemObjectsPath.value()->managedSubtreePaths;

  ASSERT_TRUE(originalSystemObjectsPaths.has_value());

  ASSERT_TRUE(
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->upsertMockObjectIntoManagedStore(
              key, managedStore::MockManagedStoreTest::CreateErrorValueType(
                       originalSystemObjectsPaths.value(),
                       boost::system::errc::make_error_code(
                           boost::system::errc::io_error)))
          .ok());

  absl::Cleanup mockManagedStoreResetter = [key, originalSystemObjectsPaths]() {
    ASSERT_TRUE(
        dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
            managedStore::GetManagedObjectStore())
            ->upsertMockObjectIntoManagedStore(
                key, managedStore::MockManagedStoreTest::CreateValueType(
                         originalSystemObjectsPaths.value()))
            .ok());
  };

  handleBiosServiceGet(app_, CreateRequest(), share_async_resp_, "system");

  RunIoUntilDone();

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

class SingleHostBiosBlobPatchTest : public SnapshotFixture {
 protected:
  static void createEmptyBlobFile() {
    std::filesystem::path filePath(actualBlobFilePath);
    std::error_code ec;
    std::filesystem::create_directories(filePath.parent_path(), ec);
    if (ec) {
      LOG(ERROR) << "Failed to create directory " << filePath.parent_path()
                 << ": " << ec.message();
      FAIL();
    }
    if (std::filesystem::exists(actualBlobFilePath)) {
      // remove file if already exists
      std::error_code ec;
      std::filesystem::remove(actualBlobFilePath, ec);
      if (ec) {
        LOG(ERROR) << "BIOS setting blob file " << actualBlobFilePath
                   << " exists, failed to remove: " << ec.message();
        FAIL();
      }
    }
    // create a empty file to start
    std::ofstream out(actualBlobFilePath);
    if (!out.good()) {
      LOG(ERROR) << "Failed to create or open file " << actualBlobFilePath;
      FAIL();
    }
    out.close();
  }

  static void SetUpTestSuite() {
    SnapshotFixture::SetUpTestSuite();
    biosSettingFilepathFromConfig = biosSettingFilePathTemplate;
  }

  static void TearDownTestSuite() {
    SnapshotFixture::TearDownTestSuite();
    std::error_code ec;
    std::filesystem::remove(actualBlobFilePath, ec);
    if (ec) {
      LOG(WARNING) << "Failed to remove BIOS setting blob file "
                   << actualBlobFilePath
                   << " in TearDownTestSuite():" << ec.message();
    }
  }

  static void SetupSystemDbusMock(const std::string& systemName) {
    managedStore::KeyType systemKey(
        managedStore::ManagedType::kManagedSubtreePaths, "/", 0,
        {"xyz.openbmc_project.Inventory.Item.System"});
    std::vector<std::string> mockSystems = {"/xyz/openbmc_project/inventory/" +
                                            systemName};
    ASSERT_TRUE(
        dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
            managedStore::GetManagedObjectStore())
            ->upsertMockObjectIntoManagedStore(
                systemKey, managedStore::MockManagedStoreTest::CreateValueType(
                               mockSystems))
            .ok());
  }

  void TearDown() override {
    std::error_code ec;
    std::filesystem::remove(actualBlobFilePath, ec);
    if (ec) {
      LOG(WARNING) << "Failed to remove BIOS setting blob file "
                   << actualBlobFilePath << " in TearDown():" << ec.message();
    }
  }

  static std::string GetTestSystemName() {
#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
    return "system1";
#else
    return "system";
#endif
  }

  static inline const std::string biosSettingFilePathTemplate =
#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
      "/tmp/soc_firmware/host/vmtppr.cfg";
#else
      "/tmp/oem_bios_setting";
#endif

  static inline const std::string actualBlobFilePath =
#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
      "/tmp/soc_firmware/host0/vmtppr.cfg";
#else
      "/tmp/oem_bios_setting";
#endif
};

TEST_F(SingleHostBiosBlobPatchTest, PatchBiosSettingsPeerNotAuthenticated) {
  // no BIOS setting file if createEmptyBlobFile() is not called
  crow::Request req =
      CreateRequest("{\"Oem\": {\"Google\": {\"MemTestBlob\" : \"AAEC\"}}}");
  // peer_authenticated to false
  req.peer_authenticated = false;

  patchBiosSettings(app_, req, share_async_resp_, GetTestSystemName());
  RunIoUntilDone();

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

TEST_F(SingleHostBiosBlobPatchTest, PatchBiosSettingsRequestNoProperArgument) {
  // no BIOS setting file if createEmptyBlobFile() is not called
  crow::Request req = CreateRequest("{\"Whatever\": {\"AAEC\"}}}");
  // peer is authenticated
  req.peer_authenticated = true;

  patchBiosSettings(app_, req, share_async_resp_, GetTestSystemName());
  RunIoUntilDone();

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

TEST_F(SingleHostBiosBlobPatchTest, PatchBiosSettingsToNonExistSystem) {
  // no BIOS setting file if createEmptyBlobFile() is not called
#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
  SetupSystemDbusMock(GetTestSystemName());
#endif
  crow::Request req =
      CreateRequest("{\"Oem\": {\"Google\": {\"MemTestBlob\" : \"AAEC\"}}}");
  // peer is authenticated
  req.peer_authenticated = true;

  patchBiosSettings(app_, req, share_async_resp_, "system2");
  RunIoUntilDone();

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

TEST_F(SingleHostBiosBlobPatchTest, PatchBiosSettingsBlobFileNotExist) {
#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
  SetupSystemDbusMock(GetTestSystemName());
#endif
  biosSettingFilepathFromConfig = "/non_exist/oem_bios_setting";

  absl::Cleanup bioSettingFilePathResetter = []() {
    biosSettingFilepathFromConfig = biosSettingFilePathTemplate;
  };

  // no BIOS setting file if createEmptyBlobFile() is not called
  crow::Request req =
      CreateRequest("{\"Oem\": {\"Google\": {\"MemTestBlob\" : \"AAEC\"}}}");
  // peer is authenticated
  req.peer_authenticated = true;

  patchBiosSettings(app_, req, share_async_resp_, GetTestSystemName());
  RunIoUntilDone();

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

TEST_F(SingleHostBiosBlobPatchTest, PatchBiosSettingsWithNullBlob) {
  // no BIOS setting file if createEmptyBlobFile() is not called
  handleBiosSettingPatch(share_async_resp_, biosSettingFilepathFromConfig,
                         /*multiHost=*/false, /*memTestBlob=*/std::nullopt,
                         /*totalEnabledCores=*/std::nullopt,
                         /*systemName=*/"system");

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

TEST_F(SingleHostBiosBlobPatchTest, PatchBiosSettingsWithInvalidBlob) {
  // no BIOS setting file if createEmptyBlobFile() is not called
  // ABCDE= is a invalid base64 encoded string
#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
  SetupSystemDbusMock(GetTestSystemName());
#endif
  crow::Request req =
      CreateRequest("{\"Oem\": {\"Google\": {\"MemTestBlob\" : \"ABCDE=\"}}}");
  // peer is authenticated
  req.peer_authenticated = true;

  patchBiosSettings(app_, req, share_async_resp_, GetTestSystemName());
  RunIoUntilDone();

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

TEST_F(SingleHostBiosBlobPatchTest,
       PatchBiosSettingsGetSystemSubTreePathsResponseError) {
  // prepare the BIOS setting file
  createEmptyBlobFile();

  // Looking for
  // kManagedSubtreePaths|/|0|xyz.openbmc_project.Inventory.Item.System
  KeyType key(ManagedType::kManagedSubtreePaths, "/", 0,
              {"xyz.openbmc_project.Inventory.Item.System"});

  absl::StatusOr<std::shared_ptr<ValueType>> systemObjectsPath =
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->getMockObjectFromManagedStore(key);
  ASSERT_TRUE(systemObjectsPath.ok());

  // TODO(b/416746677): Uncomment after the bug is fixed
  // ASSERT_EQ(systemObjectsPath.value()->managedType,
  //           ManagedType::kManagedSubtreePaths);

  std::optional<dbus::utility::MapperGetSubTreePathsResponse>
      originalSystemObjectsPaths =
          systemObjectsPath.value()->managedSubtreePaths;

  ASSERT_TRUE(originalSystemObjectsPaths.has_value());

  ASSERT_TRUE(
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->upsertMockObjectIntoManagedStore(
              key, managedStore::MockManagedStoreTest::CreateErrorValueType(
                       originalSystemObjectsPaths.value(),
                       boost::system::errc::make_error_code(
                           boost::system::errc::io_error)))
          .ok());

  absl::Cleanup mockManagedStoreResetter = [key, originalSystemObjectsPaths]() {
    ASSERT_TRUE(
        dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
            managedStore::GetManagedObjectStore())
            ->upsertMockObjectIntoManagedStore(
                key, managedStore::MockManagedStoreTest::CreateValueType(
                         originalSystemObjectsPaths.value()))
            .ok());
  };

  crow::Request req =
      CreateRequest("{\"Oem\": {\"Google\": {\"MemTestBlob\" : \"AAEC\"}}}");
  // set authenticated to true
  req.peer_authenticated = true;

  patchBiosSettings(app_, req, share_async_resp_, GetTestSystemName());
  RunIoUntilDone();

  // PATCH request use no_content as convention to indicate a success
  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::internal_server_error);
}

TEST_F(SingleHostBiosBlobPatchTest, PatchBiosSettingsSuccessfully) {
#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
  SetupSystemDbusMock(GetTestSystemName());
#endif
  crow::Logger::setLogLevel(crow::LogLevel::Error);

  // prepare the BIOS setting file
  createEmptyBlobFile();

#ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM
  EXPECT_CALL(
      *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore()),
      PostDbusCallToIoContextThreadSafe(
          testing::_,
          testing::An<
              absl::AnyInvocable<void(const boost::system::error_code&)>&&>(),
          "xyz.openbmc_project.pldm", "/xyz/openbmc_project/pldm",
          "xyz.openbmc_project.PLDM.control", "loadSingleFileAndSyncCache",
          "/tmp/soc_firmware/host0/vmtppr.cfg",
          testing::Matcher<uint32_t>(uint32_t{0})))
      .Times(1)
      .WillOnce(
          managedStore::SimulateSuccessfulAsyncPostDbusCallThreadSafeAction::
              SimulateSuccessfulAsyncPostDbusCall());
#endif

  handleBiosServiceGet(app_, CreateRequest(), share_async_resp_,
                       GetTestSystemName());
  RunIoUntilDone();
  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json["Oem"]["Google"]["MemTestBlob"], "");
  EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);

  if (std::filesystem::exists(actualBlobFilePath)) {
    LOG(INFO) << actualBlobFilePath << " exists in test body";
  }

  share_async_resp_->res.clear();

  crow::Request req =
      CreateRequest("{\"Oem\": {\"Google\": {\"MemTestBlob\" : \"AAEC\"}}}");
  // set authenticated to true
  req.peer_authenticated = true;

  patchBiosSettings(app_, req, share_async_resp_, GetTestSystemName());
  RunIoUntilDone();

  // PATCH request use no_content as convention to indicate a success
  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::no_content);

  share_async_resp_->res.clear();
  handleBiosServiceGet(app_, CreateRequest(), share_async_resp_,
                       GetTestSystemName());
  RunIoUntilDone();

  json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json["Oem"]["Google"]["MemTestBlob"], "AAEC");
  EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

}  // namespace
}  // namespace redfish