// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

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

#include <boost/asio/io_context.hpp>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <hoth_state.hpp>
#include <mutex>
#include <sdbusplus/bus.hpp>
#include <sdbusplus/test/sdbus_mock.hpp>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
#include <xyz/openbmc_project/Control/Hoth/State/error.hpp>

#include "ec_util_mock.hpp"
#include "host_command_mock.hpp"

using ::testing::_;
using ::testing::IsNull;
using ::testing::Return;
using ::testing::StrEq;

namespace google {
namespace hoth {
namespace {

class HothStateTest : public ::testing::Test {
 public:
  static constexpr char kTestPath[] = "/test/path";
  static constexpr char kHothInterface[] =
      "xyz.openbmc_project.Control.Hoth.State";

 protected:
  HothStateTest()
      : bus(sdbusplus::get_mocked_new(&sdbus_mock)),
        hoth_state(std::make_unique<HothState>(bus, io, kTestPath, &hostCmd,
                                               &ecUtil)) {
    EXPECT_CALL(sdbus_mock,
                sd_bus_emit_object_added(IsNull(), StrEq(kTestPath)))
        .WillRepeatedly(Return(0));
    EXPECT_CALL(sdbus_mock,
                sd_bus_emit_object_removed(IsNull(), StrEq(kTestPath)))
        .WillRepeatedly(Return(0));
    EXPECT_CALL(sdbus_mock,
                sd_bus_add_object_vtable(IsNull(), _, StrEq(kTestPath),
                                         StrEq(kHothInterface), _, _))
        .WillRepeatedly(Return(0));
  }

  // io_context
  boost::asio::io_context io;

  // sdbus mock object
  sdbusplus::SdBusMock sdbus_mock;

  // sdbusplus handle
  sdbusplus::bus::bus bus;

  // Host Command interface handle
  internal::HostCommandMock hostCmd;

  // EC Utility interface handle
  internal::EcUtilMock ecUtil;

  // Hoth object
  std::unique_ptr<HothState> hoth_state = nullptr;
};

TEST_F(HothStateTest, ChipInfoH1d3p) {
  ec_response_chip_info response = {};
  response.hardware_identity = 0x0123456789abcdef;
  response.hardware_category = 0x4;
  response.info_variant = 0xffffffff;
  EXPECT_CALL(ecUtil, getHothChipInfo()).WillOnce(Return(response));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_EQ(hoth_state->chipSerialNumber(), "4-0123456789abcdef");
  EXPECT_EQ(hoth_state->chipPartNumber(), "1100336");
  EXPECT_EQ(hoth_state->chipRevision(), "H1D3P");
  EXPECT_EQ(hoth_state->chipType(), "root_of_trust");
  EXPECT_EQ(hoth_state->chipName(), "Titan");
  EXPECT_EQ(hoth_state->chipManufacturer(), "Google");
}

TEST_F(HothStateTest, ChipInfoH1b3p) {
  ec_response_chip_info response = {};
  response.hardware_identity = 0x0123456789abcdef;
  response.hardware_category = 0x1;
  response.info_variant = 0x1;
  EXPECT_CALL(ecUtil, getHothChipInfo()).WillOnce(Return(response));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_EQ(hoth_state->chipSerialNumber(), "1-0123456789abcdef");
  EXPECT_EQ(hoth_state->chipPartNumber(), "1059594");
  EXPECT_EQ(hoth_state->chipRevision(), "H1B3P");
  EXPECT_EQ(hoth_state->chipType(), "root_of_trust");
  EXPECT_EQ(hoth_state->chipName(), "Titan");
  EXPECT_EQ(hoth_state->chipManufacturer(), "Google");
}

TEST_F(HothStateTest, ChipInfoH1b2p) {
  ec_response_chip_info response = {};
  response.hardware_identity = 0x0123456789abcdef;
  response.hardware_category = 0x1;
  response.info_variant = 0xffffffff;
  EXPECT_CALL(ecUtil, getHothChipInfo()).WillOnce(Return(response));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_EQ(hoth_state->chipSerialNumber(), "1-0123456789abcdef");
  EXPECT_EQ(hoth_state->chipPartNumber(), "07138244");
  EXPECT_EQ(hoth_state->chipRevision(), "H1B2P");
  EXPECT_EQ(hoth_state->chipType(), "root_of_trust");
  EXPECT_EQ(hoth_state->chipName(), "Titan");
  EXPECT_EQ(hoth_state->chipManufacturer(), "Google");
}

TEST_F(HothStateTest, HasPersistentPanicInfo) {
  EXPECT_CALL(ecUtil, checkHothPersistentPanicInfo()).WillOnce(Return(true));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_TRUE(hoth_state->hasPersistentPanicInfo());

  EXPECT_CALL(ecUtil, checkHothPersistentPanicInfo()).WillOnce(Return(false));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_FALSE(hoth_state->hasPersistentPanicInfo());
}

TEST_F(HothStateTest, ValidAuthRecord) {
  ec_authz_record_get_response response = {};
  response.valid = 1;
  response.record.capabilities = 0x0102030405060708;
  EXPECT_CALL(ecUtil, getHothAuthRecord()).WillOnce(Return(response));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_TRUE(hoth_state->hasValidAuthRecord());
  EXPECT_EQ(hoth_state->authRecordCapabilities(), 0x0102030405060708);
}

TEST_F(HothStateTest, InvalidAuthRecord) {
  ec_authz_record_get_response response = {};
  response.valid = 0;
  EXPECT_CALL(ecUtil, getHothAuthRecord()).WillOnce(Return(response));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_FALSE(hoth_state->hasValidAuthRecord());
}

TEST_F(HothStateTest, KeyRotationStatus) {
  ec_response_key_rotation_status response = {};
  response.version = 0x41414141;
  response.image_family = 0x4242;
  response.image_family_variant = 0x4343;
  response.validation_method = 0x44444444;
  response.validation_key_data = 0x45454545;
  response.validation_hash_data = 0x46464646;
  EXPECT_CALL(ecUtil, getHothKeyRotationStatus()).WillOnce(Return(response));
  EXPECT_NO_THROW(hoth_state->updateMetrics());

  EXPECT_EQ(hoth_state->keyRotationVersion(), 0x41414141);
  EXPECT_EQ(hoth_state->keyRotationImageFamily(), 0x4242);
  EXPECT_EQ(hoth_state->keyRotationImageFamilyVariant(), 0x4343);
  EXPECT_EQ(hoth_state->keyRotationValidationMethod(), 0x44444444);
  EXPECT_EQ(hoth_state->keyRotationValidationKeyData(), 0x45454545);
  EXPECT_EQ(hoth_state->keyRotationValidationHashData(), 0x46464646);
}

TEST_F(HothStateTest, SecureBootEnforced) {
  secure_boot_enforcement_state response = {};
  response.enabled = 1;
  EXPECT_CALL(ecUtil, getSecureBootEnforcementState())
      .WillOnce(Return(response));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_TRUE(hoth_state->secureBootEnforced());

  response.enabled = 0;
  EXPECT_CALL(ecUtil, getSecureBootEnforcementState())
      .WillOnce(Return(response));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_FALSE(hoth_state->secureBootEnforced());
}

TEST_F(HothStateTest, SecureBootEnforcedUnsupported) {
  EXPECT_CALL(ecUtil, getSecureBootEnforcementState())
      .WillOnce(testing::Throw(internal::CommandNotSupportedException(0)));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_FALSE(hoth_state->secureBootEnforced());
}

TEST_F(HothStateTest, SecureBootEnforcedException) {
  EXPECT_CALL(ecUtil, getSecureBootEnforcementState())
      .WillOnce(testing::Throw(std::runtime_error("test")));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_FALSE(hoth_state->secureBootEnforced());
}

ec_response_statistics getMockStatistics() {
  ec_response_statistics ret = {
      .valid_words = 22,
      .hoth_reset_flags = 0x1,
      .time_since_hoth_boot_us = 0xfeedbeefbeaddeab,
      .hoth_temperature = 0x3,
      .ro_info_strikes = 0x4,
      .rw_info_strikes = 0x5,
      .scratch_value = 0x6,
      .payload_update_failure_reason = 0x7,
      .firmware_update_failure_reason = 0x8,
      .failed_firmware_minor_version = 0x9,
      .boot_timing_total =
          {
              .start_us = 0x10,
              .end_us = 0x11,
          },
      .boot_timing_firmware_update =
          {
              .start_us = 0x12,
              .end_us = 0x14,
          },
      .boot_timing_firmware_mirroring =
          {
              .start_us = 0x15,
              .end_us = 0x18,
          },
      .boot_timing_payload_validation =
          {
              .start_us = 0x19,
              .end_us = 0x1d,
          },
      .payload_update_confirmation_cookie_failure_reason = 0x1e,
      .payload_update_confirmation_cookie = 0xdeadbeeffeedfeed,
      .bootloader_update_error = 0x1f,
      .reserved = {},
  };
  return ret;
}

struct HothStatisticsTestParam {
  char name[40];
  uint32_t valid_words_required = 0;
  // Upgrade all metrics to uint64_t for compatibility.
  uint64_t default_value = 0;
  uint64_t expected_initial_value = 0;
  uint64_t expected_new_value = 0;
  uint64_t (*get_metric)(const HothState*) = nullptr;
};

constexpr HothStatisticsTestParam kHothStatisticsTests[] = {
    {
        .name = "ResetFlags",
        .valid_words_required = 2,
        .default_value = 0,
        .expected_initial_value = 0x1,
        .expected_new_value = 0x11,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->resetFlags();
        },
    },
    {
        .name = "UpTime",
        .valid_words_required = 4,
        .default_value = 0,
        .expected_initial_value = 0xfeedbeefbeaddeab,
        .expected_new_value = 0xfeedbeefbeaddebb,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->upTime();
        },
    },
    {
        .name = "RoInfoStrikes",
        .valid_words_required = 6,
        .default_value = 0xffffffff,
        .expected_initial_value = 0x4,
        .expected_new_value = 0x14,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->roInfoStrikes();
        },
    },
    {
        .name = "RwInfoStrikes",
        .valid_words_required = 7,
        .default_value = 0xffffffff,
        .expected_initial_value = 0x5,
        .expected_new_value = 0x15,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->rwInfoStrikes();
        },
    },
    {
        .name = "PayloadUpdateFailureCode",
        .valid_words_required = 9,
        .default_value = 0xffff,
        .expected_initial_value = 0x7,
        .expected_new_value = 0x17,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->payloadUpdateFailureCode();
        },
    },
    {
        .name = "FirmwareUpdateFailureCode",
        .valid_words_required = 9,
        .default_value = 0xffff,
        .expected_initial_value = 0x8,
        .expected_new_value = 0x18,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->firmwareUpdateFailureCode();
        },
    },
    {
        .name = "FirmwareUpdateFailedMinor",
        .valid_words_required = 10,
        .default_value = 0xffffffff,
        .expected_initial_value = 0x9,
        .expected_new_value = 0x19,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->firmwareUpdateFailedMinor();
        },
    },
    {
        .name = "PayloadConfirmFailureCode",
        .valid_words_required = 19,
        .default_value = 0xffffffff,
        .expected_initial_value = 0x1e,
        .expected_new_value = 0x2e,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->payloadConfirmFailureCode();
        },
    },
    {
        .name = "BootloaderUpdateFailureCode",
        .valid_words_required = 22,
        .default_value = 0xffffffff,
        .expected_initial_value = 0x1f,
        .expected_new_value = 0x2f,
        .get_metric = [](const HothState* s) -> uint64_t {
          return s->bootloaderUpdateFailureCode();
        },
    },
};

class HothStatisticsTest
    : public ::testing::TestWithParam<HothStatisticsTestParam> {
 public:
  static constexpr char kTestPath[] = "/test/path";
  static constexpr char kHothInterface[] =
      "xyz.openbmc_project.Control.Hoth.State";

 protected:
  HothStatisticsTest()
      : bus(sdbusplus::get_mocked_new(&sdbus_mock)),
        hoth_state(std::make_unique<HothState>(bus, io, kTestPath, &hostCmd,
                                               &ecUtil)) {
    EXPECT_CALL(sdbus_mock,
                sd_bus_emit_object_added(IsNull(), StrEq(kTestPath)))
        .WillRepeatedly(Return(0));
    EXPECT_CALL(sdbus_mock,
                sd_bus_emit_object_removed(IsNull(), StrEq(kTestPath)))
        .WillRepeatedly(Return(0));
    EXPECT_CALL(sdbus_mock,
                sd_bus_add_object_vtable(IsNull(), _, StrEq(kTestPath),
                                         StrEq(kHothInterface), _, _))
        .WillRepeatedly(Return(0));
  }

  static void updateStatistics(ec_response_statistics* s) {
    s->hoth_reset_flags += 0x10;
    s->time_since_hoth_boot_us += 0x10;
    s->hoth_temperature += 0x10;
    s->ro_info_strikes += 0x10;
    s->rw_info_strikes += 0x10;
    s->scratch_value += 0x10;
    s->payload_update_failure_reason += 0x10;
    s->firmware_update_failure_reason += 0x10;
    s->failed_firmware_minor_version += 0x10;
    s->boot_timing_total.end_us += 0x10;
    s->boot_timing_firmware_update.end_us += 0x10;
    s->boot_timing_firmware_mirroring.end_us += 0x10;
    s->boot_timing_payload_validation.end_us += 0x10;
    s->payload_update_confirmation_cookie_failure_reason += 0x10;
    s->payload_update_confirmation_cookie += 0x10;
    s->bootloader_update_error += 0x10;
  }

  // io_context
  boost::asio::io_context io;

  // sdbus mock object
  sdbusplus::SdBusMock sdbus_mock;

  // sdbusplus handle
  sdbusplus::bus::bus bus;

  // Host Command interface handle
  internal::HostCommandMock hostCmd;

  // EC Utility interface handle
  internal::EcUtilMock ecUtil;

  // Hoth object
  std::unique_ptr<HothState> hoth_state = nullptr;
};

// Tests that statistics property queries return the correct result before and
// after a value change.
TEST_P(HothStatisticsTest, Update) {
  ec_response_statistics test_statistics = getMockStatistics();
  EXPECT_CALL(ecUtil, getHothStatistics()).WillOnce(Return(test_statistics));
  EXPECT_NO_THROW(hoth_state->updateMetrics());

  EXPECT_EQ(GetParam().get_metric(hoth_state.get()),
            GetParam().expected_initial_value);

  updateStatistics(&test_statistics);

  EXPECT_CALL(ecUtil, getHothStatistics()).WillOnce(Return(test_statistics));
  EXPECT_NO_THROW(hoth_state->updateMetrics());

  EXPECT_EQ(GetParam().get_metric(hoth_state.get()),
            GetParam().expected_new_value);
}

// Tests that not enough valid words in statistics response returns default
// value when querying the property.
TEST_P(HothStatisticsTest, NotEnoughValidWords) {
  ec_response_statistics test_statistics = getMockStatistics();
  test_statistics.valid_words = GetParam().valid_words_required;
  EXPECT_CALL(ecUtil, getHothStatistics()).WillOnce(Return(test_statistics));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_NO_THROW(GetParam().get_metric(hoth_state.get()));

  test_statistics.valid_words--;
  EXPECT_CALL(ecUtil, getHothStatistics()).WillOnce(Return(test_statistics));
  EXPECT_NO_THROW(hoth_state->updateMetrics());
  EXPECT_EQ(GetParam().get_metric(hoth_state.get()), GetParam().default_value);
}

INSTANTIATE_TEST_SUITE_P(
    HothStateTest, HothStatisticsTest, testing::ValuesIn(kHothStatisticsTests),
    [](const testing::TestParamInfo<HothStatisticsTest::ParamType>& info) {
      return info.param.name;
    });

}  // namespace
}  // namespace hoth
}  // namespace google