#ifndef INSTALL_INSTALLER_H_
#define INSTALL_INSTALLER_H_

#include <cstdint>
#include <fstream>
#include <optional>
#include <string>
#include <vector>

#include "owner_certificate/owner_verification_cert_configuration.pb.h"
#include "absl/container/flat_hash_set.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/time/time.h"
#include <nlohmann/json.hpp>

namespace bloom_install {

// Possible return codes for CheckDevKeysEnabledMain.
inline constexpr int kDevKeysEnabled = 0;
inline constexpr int kDevKeysDisabled = 1;
inline constexpr int kDevKeysError = 2;

// Represents a software package to be installed.
struct Package {
  std::string name;
  std::string activation_script_path;
  std::string install_script_path;
  bool operator==(const Package& other) const {
    return name == other.name &&
           activation_script_path == other.activation_script_path &&
           install_script_path == other.install_script_path;
  }
};

// Defines the possible states of the installation process for logging.
enum class State : std::uint8_t {
  kStarting,
  kCheckingActivation,
  kSkipped,
  kInstalling,
  kSuccess,
  kFailureRetry,
  kFailureFatal,
  kCheckingBundleSignature,
  kGettingOwnerConfiguration,
  kUnknown
};

// Defines the specific event codes for logging.
enum class LogCode : std::uint8_t {
  kInitStart,
  kInstallHalt,
  kInstallComplete,
  kPkgActivationCheckStart,
  kPkgActivationSkip,
  kPkgInstallProceed,
  kPkgInstallStart,
  kPkgInstallSuccess,
  kPkgInstallFailRetry,
  kPkgInstallFailFatal,
  kBundleSignatureFail,
  kBundleSignatureSuccess,
  kBundleHashFail,
  kBundleSignatureCheckStart,
  kGetOwnerConfigStart,
  kGetOwnerConfigFail,
  kGetOwnerConfigSuccess,
  kUnknown
};

// Handles logging of installation progress to a file in JSON format.
class ProgressLogger {
 public:
  explicit ProgressLogger(const std::string& log_file_path);

  // Logs a progress message using a type-safe LogCode enum.
  void Log(State state, absl::Duration elapsed_time, const std::string& message,
           LogCode code, int retries = -1);

  bool IsHealthy() const;

 private:
  static std::string StateToString(State state) {
    switch (state) {
      case State::kStarting:
        return "starting";
      case State::kCheckingActivation:
        return "checking_activation";
      case State::kSkipped:
        return "skipped";
      case State::kInstalling:
        return "installing";
      case State::kSuccess:
        return "success";
      case State::kFailureRetry:
        return "failure_retry";
      case State::kFailureFatal:
        return "failure_fatal";
      case State::kCheckingBundleSignature:
        return "checking_bundle_signature";
      case State::kGettingOwnerConfiguration:
        return "getting_owner_configuration";
      default:
        return "unknown";
    }
  }
  // Converts a LogCode enum to its string representation.
  static std::string LogCodeToString(LogCode code) {
    switch (code) {
      case LogCode::kInitStart:
        return "init_start";
      case LogCode::kInstallHalt:
        return "install_halt";
      case LogCode::kInstallComplete:
        return "install_complete";
      case LogCode::kPkgActivationCheckStart:
        return "pkg_activation_check_start";
      case LogCode::kPkgActivationSkip:
        return "pkg_activation_skip";
      case LogCode::kPkgInstallProceed:
        return "pkg_install_proceed";
      case LogCode::kPkgInstallStart:
        return "pkg_install_start";
      case LogCode::kPkgInstallSuccess:
        return "pkg_install_success";
      case LogCode::kPkgInstallFailRetry:
        return "pkg_install_fail_retry";
      case LogCode::kPkgInstallFailFatal:
        return "pkg_install_fail_fatal";
      case LogCode::kBundleSignatureFail:
        return "bundle_signature_fail";
      case LogCode::kBundleSignatureSuccess:
        return "bundle_signature_success";
      case LogCode::kBundleHashFail:
        return "bundle_hash_fail";
      case LogCode::kBundleSignatureCheckStart:
        return "bundle_signature_check_start";
      case LogCode::kGetOwnerConfigStart:
        return "get_owner_config_start";
      case LogCode::kGetOwnerConfigFail:
        return "get_owner_config_fail";
      case LogCode::kGetOwnerConfigSuccess:
        return "get_owner_config_success";
      default:
        return "unknown";
    }
  }

  std::string log_file_path_;
  std::ofstream log_file_;
  bool is_healthy_;
};

namespace internal {

// Reports generic installation status to a file.
// This class implements the contract between the installer and its consumers.
// Do not use this class directly.
class StatusReporter {
 public:
  static StatusReporter Create(const std::string& status_path,
                               int total_packages);
  // Writes the initial "IN_PROGRESS" status.
  void Start(const std::string& message);
  // Records a successfully completed package and updates progress.
  void RecordSuccess(const std::string& message);
  // Finalizes the status file as "SUCCESS" or "FAILURE".
  void Complete(bool success, const std::string& message);

 private:
  // Private constructor forces use of the factory method.
  StatusReporter(const std::string& status_path, int total_packages);
  // Writes the current state to the JSON file.
  void WriteStatus();
  // Updates the progress fields in the JSON object.
  void UpdateProgress(const std::string& message);

  std::string status_path_;
  int total_packages_;
  int packages_completed_ = 0;
  nlohmann::json status_json_;
};

// Returns the set of files listed in the manifest file.
absl::flat_hash_set<std::string> GetManifestFiles(
    const std::string& sha256sums_file_path);

// Returns true if the directory entry represents a valid package.
bool IsPackageValid(const std::string& package_path,
                    const absl::flat_hash_set<std::string>& manifest_files);

}  // namespace internal

// Defines configuration options for the Installer.
struct InstallerOptions {
  std::vector<Package> packages;
  int max_retries = 3;
  std::string log_path = "/var/google/install/progress_internal.log";
  std::string status_path = "/var/google/install/progress_status.json";
  // Activation check scripts will be persisted in this directory.
  std::string activation_check_dir = "/var/google/firmware_bundle/";
};

// Manages the installation of a list of software packages.
class InstallerTest;

class Installer {
 public:
  explicit Installer(const InstallerOptions& options);

  friend class InstallerTest;

  // Post install runs the activation check and install scripts for each
  // package. Returns true if all packages are installed successfully, false
  // otherwise. It also persists the activation check scripts to the activation
  // check directory.
  bool PostInstall();
  // Activation check runs the activation check scripts for each package.
  void ActivationCheck();
  // Checks the signature of the firmware bundle.
  bool CheckBundleSignature(const std::string& sha256sums_file_path,
                            const std::string& signature_file_path,
                            const std::string& public_key_path);
  // Retrieves and parses the owner configuration.
  absl::StatusOr<owner_certificate::OwnerVerificationCertConfiguration>
  GetOwnerConfiguration(const std::string& config_file_path);

 private:
  bool InstallPackage(const Package& package);
  bool VerifyDetachedSignature(const std::string& file_to_verify,
                               const std::string& signature_file,
                               const std::string& public_key_file);

  // Executes a binary command with the given arguments and working directory.
  // This is preferred over std::system because it does not interpret filepaths
  // as shell commands. This removes the risk of command injection.
  static int ExecuteCommand(const std::vector<std::string>& args,
                            const std::string& working_dir = "");
  static int ExecuteCommand(const std::string& command,
                            const std::string& working_dir = "");

  const InstallerOptions options_;
  ProgressLogger logger_;
  internal::StatusReporter status_reporter_;
};

std::vector<Package> ParsePostInstallPackages(
    const std::string& tar_file_path, const std::string& sha256sums_file_path);

int ActivationMain(const std::string& activation_check_dir);

int PostInstallMain(const std::string& inventory_dir,
                    const std::string& install_lock_file_path,
                    const std::string& bundle_tar_file_path,
                    const std::string& activation_check_dir);

int SignatureCheckMain(const std::string& bundle_tar_file_path,
                       const std::string& public_key_path);

int CheckDevKeysEnabledMain(const std::string& config_file_path);

}  // namespace bloom_install

#endif  // INSTALL_INSTALLER_H_