// Copyright (c) 2021 The Orbit 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 "PresetFile/PresetFile.h"

#include <absl/strings/match.h>
#include <absl/strings/str_format.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/text_format.h>
#include <string.h>

#include <algorithm>
#include <string_view>

#include "OrbitBase/File.h"
#include "OrbitBase/Logging.h"
#include "OrbitBase/ReadFileToString.h"

namespace orbit_preset_file {

using orbit_client_protos::PresetInfo;
using orbit_client_protos::PresetInfoLegacy;

namespace {

constexpr const char* kPresetFileSignature = "# ORBIT preset file\n";

ErrorMessageOr<PresetInfo> ReadPresetFromString(std::string_view content) {
  google::protobuf::io::ArrayInputStream is{content.data(), static_cast<int>(content.size())};
  PresetInfo preset_info;
  if (!google::protobuf::TextFormat::Parse(&is, &preset_info)) {
    return ErrorMessage{"Unable to parse message"};
  }

  return preset_info;
}

ErrorMessageOr<PresetInfoLegacy> ReadLegacyPresetFromString(std::string_view content) {
  PresetInfoLegacy preset_info;
  if (!preset_info.ParseFromArray(content.data(), content.size())) {
    return ErrorMessage{"Unable to parse message"};
  }

  return preset_info;
}

}  // namespace

[[nodiscard]] static std::vector<std::filesystem::path> GetPresetModulePathsLegacy(
    const orbit_client_protos::PresetInfoLegacy& preset_info) {
  std::vector<std::filesystem::path> module_paths;
  for (const auto& entry : preset_info.path_to_module()) {
    module_paths.emplace_back(entry.first);
  }

  return module_paths;
}

std::vector<std::filesystem::path> PresetFile::GetModulePaths() const {
  if (IsLegacyFileFormat()) {
    return GetPresetModulePathsLegacy(preset_info_legacy_);
  }

  std::vector<std::filesystem::path> module_paths;
  for (const auto& entry : preset_info_.modules()) {
    module_paths.emplace_back(entry.first);
  }

  return module_paths;
}

size_t PresetFile::GetNumberOfFunctionsForModule(const std::filesystem::path& module_path) const {
  if (IsLegacyFileFormat()) {
    return preset_info_legacy_.path_to_module().at(module_path.string()).function_hashes_size();
  }

  return preset_info_.modules().at(module_path.string()).function_names_size();
}

bool PresetFile::IsLegacyFileFormat() const { return is_legacy_format_; }

std::vector<uint64_t> PresetFile::GetSelectedFunctionHashesForModuleLegacy(
    const std::filesystem::path& module_path) const {
  ORBIT_CHECK(IsLegacyFileFormat());
  ORBIT_CHECK(preset_info_legacy_.path_to_module().contains(module_path.string()));
  const auto& function_hashes =
      preset_info_legacy_.path_to_module().at(module_path.string()).function_hashes();
  return {function_hashes.begin(), function_hashes.end()};
}

std::vector<uint64_t> PresetFile::GetFrameTrackFunctionHashesForModuleLegacy(
    const std::filesystem::path& module_path) const {
  ORBIT_CHECK(IsLegacyFileFormat());
  ORBIT_CHECK(preset_info_legacy_.path_to_module().contains(module_path.string()));
  const auto& frame_track_function_hashes =
      preset_info_legacy_.path_to_module().at(module_path.string()).frame_track_function_hashes();
  return {frame_track_function_hashes.begin(), frame_track_function_hashes.end()};
}

std::vector<std::string> PresetFile::GetSelectedFunctionNamesForModule(
    const std::filesystem::path& module_path) const {
  ORBIT_CHECK(!IsLegacyFileFormat());
  ORBIT_CHECK(preset_info_.modules().contains(module_path.string()));
  const auto& function_names = preset_info_.modules().at(module_path.string()).function_names();
  return {function_names.begin(), function_names.end()};
}

std::vector<std::string> PresetFile::GetFrameTrackFunctionNamesForModule(
    const std::filesystem::path& module_path) const {
  ORBIT_CHECK(!IsLegacyFileFormat());
  ORBIT_CHECK(preset_info_.modules().contains(module_path.string()));
  const auto& function_names =
      preset_info_.modules().at(module_path.string()).frame_track_function_names();
  return {function_names.begin(), function_names.end()};
}

ErrorMessageOr<PresetFile> ReadPresetFromFile(const std::filesystem::path& file_path) {
  OUTCOME_TRY(auto&& file_content, orbit_base::ReadFileToString(file_path));

  // If signature is not detected assume the file is in old format.
  if (!absl::StartsWith(file_content, kPresetFileSignature)) {
    OUTCOME_TRY(auto&& preset_info_legacy, ReadLegacyPresetFromString(file_content));
    return PresetFile{file_path, preset_info_legacy};
  }

  OUTCOME_TRY(auto&& preset_info,
              ReadPresetFromString(file_content.c_str() + strlen(kPresetFileSignature)));
  return PresetFile{file_path, preset_info};
}

ErrorMessageOr<void> PresetFile::SaveToFile() const {
  ORBIT_CHECK(!is_legacy_format_);

  OUTCOME_TRY(auto&& fd, orbit_base::OpenFileForWriting(file_path_));
  ORBIT_LOG("Saving preset to \"%s\"", file_path_.string());

  auto write_result = orbit_base::WriteFully(fd, kPresetFileSignature);
  if (write_result.has_error()) {
    std::string error_message = absl::StrFormat(
        "Failed to save preset to \"%s\": %s", file_path_.string(), write_result.error().message());
    ORBIT_ERROR("%s", error_message);
    return ErrorMessage(error_message);
  }

  std::string content;
  if (!google::protobuf::TextFormat::PrintToString(preset_info_, &content)) {
    return ErrorMessage{"Unable to convert message to string"};
  }

  write_result = orbit_base::WriteFully(fd, content);
  if (write_result.has_error()) {
    std::string error_message = absl::StrFormat(
        "Failed to save preset to \"%s\": %s", file_path_.string(), write_result.error().message());
    ORBIT_ERROR("%s", error_message);
    return ErrorMessage(error_message);
  }

  return outcome::success();
}

}  // namespace orbit_preset_file