// 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 <fuchsia/feedback/cpp/fidl.h>
#include <fuchsia/process/lifecycle/cpp/fidl.h>
#include <lib/async/cpp/executor.h>
#include <lib/fidl/cpp/interface_request.h>
#include <lib/fit/defer.h>
#include <lib/fpromise/promise.h>
#include <lib/syslog/cpp/log_settings.h>
#include <lib/syslog/cpp/macros.h>
#include <zircon/processargs.h>

#include <cstdlib>
#include <memory>

#include <fbl/unique_fd.h>

#include "src/developer/forensics/crash_reports/default_annotations.h"
#include "src/developer/forensics/feedback/annotations/startup_annotations.h"
#include "src/developer/forensics/feedback/config.h"
#include "src/developer/forensics/feedback/constants.h"
#include "src/developer/forensics/feedback/main_service.h"
#include "src/developer/forensics/feedback/migration/utils/log.h"
#include "src/developer/forensics/feedback/migration/utils/migrate.h"
#include "src/developer/forensics/feedback/namespace_init.h"
#include "src/developer/forensics/feedback/reboot_log/annotations.h"
#include "src/developer/forensics/feedback/reboot_log/reboot_log.h"
#include "src/developer/forensics/feedback/redactor_factory.h"
#include "src/developer/forensics/feedback_data/default_annotations.h"
#include "src/developer/forensics/utils/cobalt/logger.h"
#include "src/developer/forensics/utils/component/component.h"
#include "src/lib/files/file.h"
#include "src/lib/fxl/strings/split_string.h"
#include "src/lib/uuid/uuid.h"

namespace forensics::feedback {

int main() {
  syslog::SetTags({"forensics", "feedback"});

  // Delay serving the outgoing directory because the migration happens asynchronously and the
  // component's services cannot be used until the migration has completed.
  forensics::component::Component component(/*lazy_outgoing_dir=*/true);

  async::Executor executor(component.Dispatcher());

  auto crash_reports_config = GetCrashReportsConfig();
  if (!crash_reports_config) {
    FX_LOGS(FATAL) << "Failed to get config for crash reporting";
    return EXIT_FAILURE;
  }

  auto feedback_data_config = GetFeedbackDataConfig();
  if (!feedback_data_config) {
    FX_LOGS(FATAL) << "Failed to get config for feedback data";
    return EXIT_FAILURE;
  }

  auto migration_log = MigrationLog::FromFile("/data/migration_log.json");
  if (!migration_log) {
    FX_LOGS(ERROR) << "Failed to create migration log";
  }

  // Don't allocate the |cobalt| and |main_service|until after the migration has completed and the
  // component can function properly.
  std::unique_ptr<cobalt::Logger> cobalt;
  std::unique_ptr<MainService> main_service;

  executor.schedule_task(
      MigrateData(component.Dispatcher(), component.Services(), migration_log,
                  kDirectoryMigratorResponeTimeout)
          .and_then(
              [&](const std::tuple<::fpromise::result<void, Error>, ::fpromise::result<void, Error>,
                                   ::fpromise::result<void, Error>>& results) {
                std::map<std::string, std::string> migration_failures;
                if (const auto result = std::get<0>(results); !result.is_ok()) {
                  FX_LOGS(ERROR)
                      << "Experienced errors while migrating last reboot, continuing as normal: "
                      << ToString(result.error());
                  migration_failures["debug.last_reboot.migration-failure"] =
                      ToString(result.error());
                }

                if (const auto result = std::get<1>(results); !result.is_ok()) {
                  FX_LOGS(ERROR)
                      << "Experienced errors while migrating crash reports, continuing as normal: "
                      << ToString(result.error());
                  migration_failures["debug.crash_reports.migration-failure"] =
                      ToString(result.error());
                }

                if (const auto result = std::get<2>(results); !result.is_ok()) {
                  FX_LOGS(ERROR)
                      << "Experienced errors while migrating feedback data, continuing as normal: "
                      << ToString(result.error());
                  migration_failures["debug.feedback_data.migration-failure"] =
                      ToString(result.error());
                }

                if (migration_log) {
                  if (!migration_log->Contains(MigrationLog::Component::kLastReboot)) {
                    migration_log->Set(MigrationLog::Component::kLastReboot);
                  } else {
                    FX_LOGS(INFO) << "Already migrated last reboot";
                  }

                  if (!migration_log->Contains(MigrationLog::Component::kCrashReports)) {
                    migration_log->Set(MigrationLog::Component::kCrashReports);
                  } else {
                    FX_LOGS(INFO) << "Already migrated crash reports";
                  }

                  if (!migration_log->Contains(MigrationLog::Component::kFeedbackData)) {
                    migration_log->Set(MigrationLog::Component::kFeedbackData);
                  } else {
                    FX_LOGS(INFO) << "Already migrated feedback data";
                  }
                }

                cobalt = std::make_unique<cobalt::Logger>(component.Dispatcher(),
                                                          component.Services(), component.Clock());

                if (component.IsFirstInstance()) {
                  MovePreviousRebootReason();
                  CreatePreviousLogsFile(cobalt.get());
                  MoveAndRecordBootId(uuid::Generate());
                  if (std::string build_version;
                      files::ReadFileToString(kBuildVersionPath, &build_version)) {
                    MoveAndRecordBuildVersion(build_version);
                  }
                }

                auto reboot_log = RebootLog::ParseRebootLog("/boot/log/last-panic.txt",
                                                            kPreviousGracefulRebootReasonFile,
                                                            TestAndSetNotAFdr());

                const bool limit_inspect_data = files::IsFile(kLimitInspectDataPath);
                const bool spawn_system_log_recorder =
                    !files::IsFile(kDoNotLaunchSystemLogRecorder);

                std::optional<std::string> local_device_id_path = kDeviceIdPath;
                if (files::IsFile(kUseRemoteDeviceIdProviderPath)) {
                  local_device_id_path = std::nullopt;
                }

                std::optional<zx::duration> delete_previous_boot_logs_time(std::nullopt);
                if (files::IsFile(kPreviousLogsFilePath)) {
                  delete_previous_boot_logs_time = zx::hour(24);
                }

                const auto startup_annotations = GetStartupAnnotations(reboot_log);

                main_service = std::make_unique<MainService>(
                    component.Dispatcher(), component.Services(), component.Clock(),
                    component.InspectRoot(), cobalt.get(), startup_annotations,
                    MainService::Options{
                        local_device_id_path,
                        LastReboot::Options{
                            .is_first_instance = component.IsFirstInstance(),
                            .reboot_log = reboot_log,
                            .graceful_reboot_reason_write_path = kCurrentGracefulRebootReasonFile,
                            .oom_crash_reporting_delay = kOOMCrashReportingDelay,
                        },
                        CrashReports::Options{
                            .config = *crash_reports_config,
                            .snapshot_manager_max_annotations_size = kSnapshotAnnotationsMaxSize,
                            .snapshot_manager_max_archives_size = kSnapshotArchivesMaxSize,
                            .snapshot_manager_window_duration = kSnapshotSharedRequestWindow,
                        },
                        FeedbackData::Options{
                            .config = *feedback_data_config,
                            .is_first_instance = component.IsFirstInstance(),
                            .limit_inspect_data = limit_inspect_data,
                            .spawn_system_log_recorder = spawn_system_log_recorder,
                            .delete_previous_boot_logs_time = delete_previous_boot_logs_time,
                        }});

                if (!migration_failures.empty()) {
                  main_service->ReportMigrationError(migration_failures);
                }

                // The component is now ready to serve its outgoing directory and serve requests.
                component.AddPublicService(
                    main_service->GetHandler<fuchsia::feedback::LastRebootInfoProvider>());
                component.AddPublicService(
                    main_service->GetHandler<fuchsia::feedback::CrashReporter>());
                component.AddPublicService(
                    main_service->GetHandler<fuchsia::feedback::CrashReportingProductRegister>());
                component.AddPublicService(
                    main_service->GetHandler<fuchsia::feedback::ComponentDataRegister>());
                component.AddPublicService(
                    main_service->GetHandler<fuchsia::feedback::DataProvider>());
                component.AddPublicService(
                    main_service->GetHandler<fuchsia::feedback::DataProviderController>());

                zx::channel lifecycle_channel(zx_take_startup_handle(PA_LIFECYCLE));

                component.OnStopSignal(
                    ::fidl::InterfaceRequest<fuchsia::process::lifecycle::Lifecycle>(
                        std::move(lifecycle_channel)),
                    [&](::fit::deferred_callback stop_respond) {
                      FX_LOGS(INFO) << "Received stop signal; stopping upload, but not exiting "
                                       "to continue persisting new reports and logs";
                      main_service->ShutdownImminent(std::move(stop_respond));
                    });
              }));

  component.RunLoop();
  return EXIT_SUCCESS;
}

}  // namespace forensics::feedback