// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/developer/forensics/feedback/main_service.h"

#include <fuchsia/feedback/cpp/fidl.h>

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

#include "src/developer/forensics/testing/stubs/cobalt_logger.h"
#include "src/developer/forensics/testing/stubs/cobalt_logger_factory.h"
#include "src/developer/forensics/testing/stubs/crash_reporter.h"
#include "src/developer/forensics/testing/stubs/reboot_methods_watcher_register.h"
#include "src/developer/forensics/testing/unit_test_fixture.h"
#include "src/lib/fxl/strings/substitute.h"
#include "src/lib/timekeeper/async_test_clock.h"

namespace forensics::feedback {
namespace {

using inspect::testing::ChildrenMatch;
using inspect::testing::NameMatches;
using inspect::testing::NodeMatches;
using inspect::testing::PropertyList;
using inspect::testing::UintIs;
using ::testing::IsSupersetOf;
using ::testing::UnorderedElementsAreArray;

constexpr bool kIsFirstInstance = true;

class MainServiceTest : public UnitTestFixture {
 public:
  MainServiceTest()
      : clock_(dispatcher()),
        cobalt_(dispatcher(), services(), &clock_),
        main_service_(dispatcher(), services(), &clock_, &InspectRoot(), &cobalt_,
                      /*startup_annotations=*/{},
                      MainService::Options{
                          "",
                          LastReboot::Options{
                              .is_first_instance = kIsFirstInstance,
                              .reboot_log = RebootLog(RebootReason::kUserRequest, "reboot log",
                                                      zx::sec(100), std::nullopt),
                              .graceful_reboot_reason_write_path = "n/a",
                              .oom_crash_reporting_delay = zx::sec(1),
                          },
                          CrashReports::Options{
                              .config = {},
                              .snapshot_manager_max_annotations_size = StorageSize::Bytes(0),
                              .snapshot_manager_max_archives_size = StorageSize::Bytes(0),
                              .snapshot_manager_window_duration = zx::sec(0),
                          },
                          FeedbackData::Options{
                              .config{},
                              .is_first_instance = kIsFirstInstance,
                              .limit_inspect_data = false,
                              .spawn_system_log_recorder = false,
                              .delete_previous_boot_logs_time = std::nullopt,
                          },
                      }) {
    AddHandler(main_service_.GetHandler<fuchsia::feedback::LastRebootInfoProvider>());
    AddHandler(main_service_.GetHandler<fuchsia::feedback::CrashReporter>());
    AddHandler(main_service_.GetHandler<fuchsia::feedback::CrashReportingProductRegister>());
    AddHandler(main_service_.GetHandler<fuchsia::feedback::ComponentDataRegister>());
    AddHandler(main_service_.GetHandler<fuchsia::feedback::DataProvider>());
    AddHandler(main_service_.GetHandler<fuchsia::feedback::DataProviderController>());
  }

 private:
  timekeeper::AsyncTestClock clock_;
  cobalt::Logger cobalt_;
  MainService main_service_;
};

auto ProtocolMatcher(const std::string& feedback_protocol, const size_t total_num_connections,
                     const size_t current_num_connections) {
  return NodeMatches(AllOf(NameMatches(fxl::Substitute("fuchsia.feedback.$0", feedback_protocol)),
                           PropertyList(UnorderedElementsAreArray({
                               UintIs("total_num_connections", total_num_connections),
                               UintIs("current_num_connections", current_num_connections),
                           }))));
}

TEST_F(MainServiceTest, LastReboot) {
  fuchsia::feedback::LastRebootInfoProviderPtr last_reboot_info_provider_ptr_;
  services()->Connect(last_reboot_info_provider_ptr_.NewRequest(dispatcher()));

  bool called = false;
  last_reboot_info_provider_ptr_->Get([&](fuchsia::feedback::LastReboot) { called = true; });

  RunLoopUntilIdle();

  EXPECT_TRUE(called);
  EXPECT_THAT(InspectTree(), ChildrenMatch(IsSupersetOf({
                                 AllOf(NodeMatches(NameMatches("fidl")),
                                       ChildrenMatch(IsSupersetOf({
                                           ProtocolMatcher("LastRebootInfoProvider", 1u, 1u),
                                           ProtocolMatcher("CrashReporter", 0u, 0u),
                                           ProtocolMatcher("CrashReportingProductRegister", 0u, 0u),
                                           ProtocolMatcher("ComponentDataRegister", 0u, 0u),
                                           ProtocolMatcher("DataProvider", 0u, 0u),
                                           ProtocolMatcher("DataProviderController", 0u, 0u),
                                       }))),
                             })));

  last_reboot_info_provider_ptr_.Unbind();
  RunLoopUntilIdle();
  EXPECT_THAT(InspectTree(), ChildrenMatch(IsSupersetOf({
                                 AllOf(NodeMatches(NameMatches("fidl")),
                                       ChildrenMatch(IsSupersetOf({
                                           ProtocolMatcher("LastRebootInfoProvider", 1u, 0u),
                                           ProtocolMatcher("CrashReporter", 0u, 0u),
                                           ProtocolMatcher("CrashReportingProductRegister", 0u, 0u),
                                           ProtocolMatcher("ComponentDataRegister", 0u, 0u),
                                           ProtocolMatcher("DataProvider", 0u, 0u),
                                           ProtocolMatcher("DataProviderController", 0u, 0u),
                                       }))),
                             })));
}

TEST_F(MainServiceTest, CrashReports) {
  fuchsia::feedback::CrashReporterPtr crash_reporter_ptr_;
  services()->Connect(crash_reporter_ptr_.NewRequest(dispatcher()));

  fuchsia::feedback::CrashReportingProductRegisterPtr crash_reporting_product_register_ptr_;
  services()->Connect(crash_reporting_product_register_ptr_.NewRequest(dispatcher()));

  bool crash_reporter_called = false;
  crash_reporter_ptr_->File(
      std::move(fuchsia::feedback::CrashReport().set_program_name("program_name")),
      [&](::fpromise::result<void, zx_status_t>) { crash_reporter_called = true; });

  bool crash_reporting_product_register_called = false;
  crash_reporting_product_register_ptr_->UpsertWithAck(
      "component_url",
      std::move(fuchsia::feedback::CrashReportingProduct()
                    .set_name("product_name")
                    .set_version("product_version")),
      [&]() { crash_reporting_product_register_called = true; });

  RunLoopUntilIdle();
  EXPECT_TRUE(crash_reporter_called);
  EXPECT_TRUE(crash_reporting_product_register_called);
  EXPECT_THAT(InspectTree(), ChildrenMatch(IsSupersetOf({
                                 AllOf(NodeMatches(NameMatches("fidl")),
                                       ChildrenMatch(IsSupersetOf({
                                           ProtocolMatcher("LastRebootInfoProvider", 0u, 0u),
                                           ProtocolMatcher("CrashReporter", 1u, 1u),
                                           ProtocolMatcher("CrashReportingProductRegister", 1u, 1u),
                                           ProtocolMatcher("ComponentDataRegister", 0u, 0u),
                                           ProtocolMatcher("DataProvider", 0u, 0u),
                                           ProtocolMatcher("DataProviderController", 0u, 0u),
                                       }))),
                             })));

  crash_reporter_ptr_.Unbind();
  crash_reporting_product_register_ptr_.Unbind();
  RunLoopUntilIdle();
  EXPECT_THAT(InspectTree(), ChildrenMatch(IsSupersetOf({
                                 AllOf(NodeMatches(NameMatches("fidl")),
                                       ChildrenMatch(IsSupersetOf({
                                           ProtocolMatcher("LastRebootInfoProvider", 0u, 0u),
                                           ProtocolMatcher("CrashReporter", 1u, 0u),
                                           ProtocolMatcher("CrashReportingProductRegister", 1u, 0u),
                                           ProtocolMatcher("ComponentDataRegister", 0u, 0u),
                                           ProtocolMatcher("DataProvider", 0u, 0u),
                                           ProtocolMatcher("DataProviderController", 0u, 0u),
                                       }))),
                             })));
}

TEST_F(MainServiceTest, FeedbackData) {
  fuchsia::feedback::ComponentDataRegisterPtr component_data_ptr_;
  services()->Connect(component_data_ptr_.NewRequest(dispatcher()));

  fuchsia::feedback::DataProviderPtr data_provider_ptr_;
  services()->Connect(data_provider_ptr_.NewRequest(dispatcher()));

  fuchsia::feedback::DataProviderControllerPtr data_provider_controller_ptr_;
  services()->Connect(data_provider_controller_ptr_.NewRequest(dispatcher()));

  bool component_data_called = false;
  component_data_ptr_->Upsert(fuchsia::feedback::ComponentData{},
                              [&component_data_called]() { component_data_called = true; });

  fuchsia::feedback::GetSnapshotParameters snapshot_params;
  snapshot_params.set_collection_timeout_per_data(0u);
  bool data_provider_called = false;
  data_provider_ptr_->GetSnapshot(
      std::move(snapshot_params),
      [&data_provider_called](fuchsia::feedback::Snapshot) { data_provider_called = true; });

  bool data_provider_controller_called = false;
  data_provider_controller_ptr_->DisableAndDropPersistentLogs(
      [&data_provider_controller_called]() { data_provider_controller_called = true; });

  RunLoopUntilIdle();
  EXPECT_TRUE(component_data_called);
  EXPECT_TRUE(data_provider_called);
  EXPECT_TRUE(data_provider_controller_called);
  EXPECT_THAT(InspectTree(), ChildrenMatch(IsSupersetOf({
                                 AllOf(NodeMatches(NameMatches("fidl")),
                                       ChildrenMatch(IsSupersetOf({
                                           ProtocolMatcher("LastRebootInfoProvider", 0u, 0u),
                                           ProtocolMatcher("CrashReporter", 0u, 0u),
                                           ProtocolMatcher("CrashReportingProductRegister", 0u, 0u),
                                           ProtocolMatcher("ComponentDataRegister", 1u, 1u),
                                           ProtocolMatcher("DataProvider", 1u, 1u),
                                           ProtocolMatcher("DataProviderController", 1u, 1u),
                                       }))),
                             })));

  component_data_ptr_.Unbind();
  data_provider_ptr_.Unbind();
  data_provider_controller_ptr_.Unbind();

  RunLoopUntilIdle();
  EXPECT_THAT(InspectTree(), ChildrenMatch(IsSupersetOf({
                                 AllOf(NodeMatches(NameMatches("fidl")),
                                       ChildrenMatch(IsSupersetOf({
                                           ProtocolMatcher("LastRebootInfoProvider", 0u, 0u),
                                           ProtocolMatcher("CrashReporter", 0u, 0u),
                                           ProtocolMatcher("CrashReportingProductRegister", 0u, 0u),
                                           ProtocolMatcher("ComponentDataRegister", 1u, 0u),
                                           ProtocolMatcher("DataProvider", 1u, 0u),
                                           ProtocolMatcher("DataProviderController", 1u, 0u),
                                       }))),
                             })));
}

}  // namespace
}  // namespace forensics::feedback