/*
 * Copyright (C) 2024 The Android Open Source Project
 *
 * 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 "storage_files.h"

#include <android-base/logging.h>
#include <unistd.h>

#include <aconfig_storage/aconfig_storage_file.hpp>

#include "aconfigd.h"
#include "aconfigd_util.h"
#include "com_android_aconfig_new_storage.h"

using namespace aconfig_storage;

namespace android {
  namespace aconfigd {

  /// constructor for a new storage file set
  StorageFiles::StorageFiles(const std::string& container,
                             const std::string& package_map,
                             const std::string& flag_map,
                             const std::string& flag_val,
                             const std::string& flag_info,
                             const std::string& root_dir,
                             base::Result<void>& status)
      : container_(container)
      , storage_record_()
      , package_map_(nullptr)
      , flag_map_(nullptr)
      , flag_val_(nullptr)
      , boot_flag_val_(nullptr)
      , boot_flag_info_(nullptr)
      , persist_flag_val_(nullptr)
      , persist_flag_info_(nullptr) {
    auto version = get_storage_file_version(flag_val);
    if (!version.ok()) {
      status = base::Error() << "failed to get file version: " << version.error();
      return;
    }

    auto digest = GetFilesDigest({package_map, flag_map, flag_val, flag_info});
    if (!digest.ok()) {
      status = base::Error() << "failed to get files digest: " << digest.error();
      return;
    }

    storage_record_.version = *version;
    storage_record_.container = container;
    storage_record_.package_map = package_map;
    storage_record_.flag_map = flag_map;
    storage_record_.flag_val = flag_val;
    storage_record_.flag_info = flag_info;
    storage_record_.persist_package_map =
        root_dir + "/maps/" + container + ".package.map";
    storage_record_.persist_flag_map =
        root_dir + "/maps/" + container + ".flag.map";
    storage_record_.persist_flag_val =
        root_dir + "/flags/" + container + ".val";
    storage_record_.persist_flag_info =
        root_dir + "/flags/" + container + ".info";
    storage_record_.local_overrides =
        root_dir + "/flags/" + container + "_local_overrides.pb";
    storage_record_.boot_flag_val =
        root_dir + "/boot/" + container + ".val";
    storage_record_.boot_flag_info =
        root_dir + "/boot/" + container + ".info";
    storage_record_.digest= *digest;

    // copy package map file
    auto copy_result = CopyFile(package_map, storage_record_.persist_package_map, 0444);
    if (!copy_result.ok()) {
      status = base::Error() << "CopyFile failed for " << package_map << ": "
                             << copy_result.error();
      return;
    }

    // copy flag map file
    copy_result = CopyFile(flag_map, storage_record_.persist_flag_map, 0444);
    if (!copy_result.ok()) {
      status = base::Error() << "CopyFile failed for " << flag_map << ": "
                             << copy_result.error();
      return;
    }

    // copy flag value file
    copy_result = CopyFile(flag_val, storage_record_.persist_flag_val, 0644);
    if (!copy_result.ok()) {
      status = base::Error() << "CopyFile failed for " << flag_val << ": "
                             << copy_result.error();
      return;
    }

    // copy flag info file
    copy_result = CopyFile(flag_info, storage_record_.persist_flag_info, 0644);
    if (!copy_result.ok()) {
      status = base::Error() << "CopyFile failed for " << flag_info << ": "
                             << copy_result.error();
      return;
    }
  }

  /// constructor for existing new storage file set
  StorageFiles::StorageFiles(const PersistStorageRecord& pb,
                             const std::string& root_dir)
      : container_(pb.container())
      , storage_record_()
      , package_map_(nullptr)
      , flag_map_(nullptr)
      , flag_val_(nullptr)
      , boot_flag_val_(nullptr)
      , boot_flag_info_(nullptr)
      , persist_flag_val_(nullptr)
      , persist_flag_info_(nullptr) {
    storage_record_.version = pb.version();
    storage_record_.container = pb.container();
    storage_record_.package_map = pb.package_map();
    storage_record_.flag_map = pb.flag_map();
    storage_record_.flag_val = pb.flag_val();
    if (pb.has_flag_info()) {
      storage_record_.flag_info = pb.flag_info();
    } else {
      auto val_file = storage_record_.flag_val;
      storage_record_.flag_info = val_file.substr(0, val_file.size()-3) + "info";
    }
    storage_record_.persist_package_map =
        root_dir + "/maps/" + pb.container() + ".package.map";
    storage_record_.persist_flag_map =
        root_dir + "/maps/" + pb.container() + ".flag.map";
    storage_record_.persist_flag_val =
        root_dir + "/flags/" + pb.container() + ".val";
    storage_record_.persist_flag_info =
        root_dir + "/flags/" + pb.container() + ".info";
    storage_record_.local_overrides =
        root_dir + "/flags/" + pb.container() + "_local_overrides.pb";
    storage_record_.boot_flag_val =
        root_dir + "/boot/" + pb.container() + ".val";
    storage_record_.boot_flag_info =
        root_dir + "/boot/" + pb.container() + ".info";
    storage_record_.digest = pb.digest();
  }

  /// move constructor
  StorageFiles::StorageFiles(StorageFiles&& rhs) {
    if (this != &rhs) {
      *this = std::move(rhs);
    }
  }

  /// move assignment
  StorageFiles& StorageFiles::operator=(StorageFiles&& rhs) {
    if (this != &rhs) {
      container_ = rhs.container_;
      storage_record_ = std::move(rhs.storage_record_);
      package_map_ = std::move(rhs.package_map_);
      flag_map_ = std::move(rhs.flag_map_);
      flag_val_ = std::move(rhs.flag_val_);
      boot_flag_val_ = std::move(rhs.boot_flag_val_);
      boot_flag_info_ = std::move(rhs.boot_flag_info_);
      persist_flag_val_ = std::move(rhs.persist_flag_val_);
      persist_flag_info_ = std::move(rhs.persist_flag_info_);
    }
    return *this;
  }

  /// get package map
  base::Result<const MappedStorageFile*> StorageFiles::GetPackageMap() {
    if (!package_map_) {
      if (storage_record_.persist_package_map.empty()) {
        return base::Error() << "Missing persist package map file";
      }
      auto package_map = map_storage_file(storage_record_.persist_package_map);
      RETURN_IF_ERROR(package_map, "Failed to map persist package map file for " + container_);
      package_map_.reset(*package_map);
    }
    return package_map_.get();
  }

  /// get flag map
  base::Result<const MappedStorageFile*> StorageFiles::GetFlagMap() {
    if (!flag_map_) {
      if (storage_record_.persist_flag_map.empty()) {
        return base::Error() << "Missing persist flag map file";
      }
      auto flag_map = map_storage_file(storage_record_.persist_flag_map);
      RETURN_IF_ERROR(flag_map, "Failed to map persist flag map file for " + container_);
      flag_map_.reset(*flag_map);
    }
    return flag_map_.get();
  }

  /// get default flag val
  base::Result<const MappedStorageFile*> StorageFiles::GetFlagVal() {
    if (!flag_val_) {
      if (storage_record_.flag_val.empty()) {
        return base::Error() << "Missing flag val file";
      }
      auto flag_val = map_storage_file(storage_record_.flag_val);
      RETURN_IF_ERROR(flag_val, "Failed to map flag val file for " + container_);
      flag_val_.reset(*flag_val);
    }
    return flag_val_.get();
  }

  /// get boot flag val
  base::Result<const MappedStorageFile*> StorageFiles::GetBootFlagVal() {
    if (!boot_flag_val_) {
      if (storage_record_.boot_flag_val.empty()) {
        return base::Error() << "Missing boot flag val file";
      }
      auto flag_val = map_storage_file(storage_record_.boot_flag_val);
      RETURN_IF_ERROR(flag_val, "Failed to map boot flag val file for " + container_);
      boot_flag_val_.reset(*flag_val);
    }
    return boot_flag_val_.get();
  }

  /// get boot flag info
  base::Result<const MappedStorageFile*> StorageFiles::GetBootFlagInfo() {
    if (!boot_flag_info_) {
      if (storage_record_.boot_flag_info.empty()) {
        return base::Error() << "Missing boot flag info file";
      }
      auto flag_info = map_storage_file(storage_record_.boot_flag_info);
      RETURN_IF_ERROR(flag_info, "Failed to map boot flag info file for " + container_);
      boot_flag_info_.reset(*flag_info);
    }
    return boot_flag_info_.get();
  }

  /// get persist flag val
  base::Result<const MutableMappedStorageFile*> StorageFiles::GetPersistFlagVal() {
    if (!persist_flag_val_) {
      if (storage_record_.persist_flag_val.empty()) {
        return base::Error() << "Missing persist flag value file";
      }
      auto flag_val = map_mutable_storage_file(storage_record_.persist_flag_val);
      RETURN_IF_ERROR(flag_val, "Failed to map persist flag val file for " + container_);
      persist_flag_val_.reset(*flag_val);
    }
    return persist_flag_val_.get();
  }

  /// get persist flag info
  base::Result<const MutableMappedStorageFile*> StorageFiles::GetPersistFlagInfo() {
    if (!persist_flag_info_) {
      if (storage_record_.persist_flag_info.empty()) {
        return base::Error() << "Missing persist flag info file";
      }
      auto flag_info = map_mutable_storage_file(storage_record_.persist_flag_info);
      RETURN_IF_ERROR(flag_info, "Failed to map persist flag info file for " + container_);
      persist_flag_info_.reset(*flag_info);
    }
    return persist_flag_info_.get();
  }

  /// check if flag is read only
  base::Result<bool> StorageFiles::IsFlagReadOnly(const PackageFlagContext& context) {
    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto flag_info_file = GetPersistFlagInfo();
    if (!flag_info_file.ok()) {
      return base::Error() << flag_info_file.error();
    }

    auto attribute = get_flag_attribute(
        **flag_info_file, context.value_type, context.flag_index);

    if (!attribute.ok()) {
      return base::Error() << "Failed to get flag attribute";
    }

    return !(*attribute & FlagInfoBit::IsReadWrite);
  }

  /// apply local update to boot flag value copy
  base::Result<void> StorageFiles::ApplyLocalOverrideToBootFlagValue() {
    auto flag_value_result = map_mutable_storage_file(storage_record_.boot_flag_val);
    if (!flag_value_result.ok()) {
      return base::Error() << "Failed to map boot flag value file for local override: "
                           << flag_value_result.error();
    }
    auto flag_value = std::unique_ptr<MutableMappedStorageFile>(*flag_value_result);

    auto pb_file = storage_record_.local_overrides;
    auto pb = ReadPbFromFile<LocalFlagOverrides>(pb_file);
    if (!pb.ok()) {
      return base::Error() << "Failed to read pb from " << pb_file << ": " << pb.error();
    }

    auto applied_overrides = LocalFlagOverrides();
    for (auto& entry : pb->overrides()) {

      // find flag value type and index
      auto context = GetPackageFlagContext(entry.package_name(), entry.flag_name());
      if (!context.ok()) {
        return base::Error() << "Failed to find flag: " << context.error();
      }

      if (!context->flag_exists) {
        continue;
      }

      // apply a local override
      switch (context->value_type) {
        case FlagValueType::Boolean: {
          // validate value
          if (entry.flag_value() != "true" && entry.flag_value() != "false") {
            return base::Error() << "Invalid boolean flag value, it should be true|false";
          }

          // update flag value
          auto update_result = set_boolean_flag_value(
              *flag_value, context->flag_index, entry.flag_value() == "true");
          if (!update_result.ok()) {
            return base::Error() << "Failed to update flag value: " << update_result.error();
          }

          break;
        }
        default:
          return base::Error() << "Unsupported flag value type";
      }

      // mark it applied
      auto new_applied = applied_overrides.add_overrides();
      new_applied->set_package_name(entry.package_name());
      new_applied->set_flag_name(entry.flag_name());
      new_applied->set_flag_value(entry.flag_value());
    }

    if (pb->overrides_size() != applied_overrides.overrides_size()) {
      auto result = WritePbToFile<LocalFlagOverrides>(applied_overrides, pb_file);
      if (!result.ok()) {
        return base::Error() << result.error();
      }
    }

    return {};
  }

  /// has boot copy
  bool StorageFiles::HasBootCopy() {
    return FileExists(storage_record_.boot_flag_val)
        && FileExists(storage_record_.boot_flag_info);
  }

  /// Find flag value type and global index
  base::Result<StorageFiles::PackageFlagContext> StorageFiles::GetPackageFlagContext(
      const std::string& package,
      const std::string& flag) {
    auto result = PackageFlagContext(package, flag);

    // early return
    if (package.empty()) {
      result.package_exists = false;
      result.flag_exists = false;
      return result;
    }

    // find package context
    auto package_map = GetPackageMap();
    if (!package_map.ok()) {
      return base::Error() << package_map.error();
    }

    auto package_context = get_package_read_context(**package_map, package);
    if (!package_context.ok()) {
      return base::Error() << "Failed to get package context for " << package
                           << " in " << container_  << " :" << package_context.error();
    }

    if (!package_context->package_exists) {
      result.flag_exists = false;
      return result;
    } else {
      result.package_exists = true;
    }

    // early return
    if (flag.empty()) {
      return result;
    }

    uint32_t package_id = package_context->package_id;
    uint32_t boolean_flag_start_index = package_context->boolean_start_index;

    // find flag context
    auto flag_map = GetFlagMap();
    if (!flag_map.ok()) {
      return base::Error() << flag_map.error();
    }

    auto flag_context = get_flag_read_context(**flag_map, package_id, flag);
    if (!flag_context.ok()) {
      return base::Error() << "Failed to get flag context of " << package << "/"
                           << flag << " in " << container_  << " :"
                           << flag_context.error();
    }

    if (!flag_context->flag_exists) {
      result.flag_exists = false;
      return result;
    }

    StoredFlagType stored_type = flag_context->flag_type;
    uint16_t within_package_flag_index = flag_context->flag_index;
    auto value_type = map_to_flag_value_type(stored_type);
    if (!value_type.ok()) {
      return base::Error() << "Failed to get flag value type :" << value_type.error();
    }

    result.flag_exists = true;
    result.value_type = *value_type;
    result.flag_index = boolean_flag_start_index + within_package_flag_index;
    return result;
  }

  /// check if has package
  base::Result<bool> StorageFiles::HasPackage(const std::string& package) {
    auto type_and_index = GetPackageFlagContext(package, "");
    if (!type_and_index.ok()) {
      return base::Error() << type_and_index.error();
    }
    return type_and_index->package_exists;
  }

  /// check if has flag
  base::Result<bool> StorageFiles::HasFlag(const std::string& package,
                                           const std::string& flag) {
    auto type_and_index = GetPackageFlagContext(package, flag);
    if (!type_and_index.ok()) {
      return base::Error() << type_and_index.error();
    }
    return type_and_index->flag_exists;
  }

  /// get persistent flag attribute
  base::Result<uint8_t> StorageFiles::GetFlagAttribute(
      const PackageFlagContext& context) {
    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto flag_info_file = GetPersistFlagInfo();
    if (!flag_info_file.ok()) {
      return base::Error() << flag_info_file.error();
    }

    auto attribute = get_flag_attribute(**flag_info_file, context.value_type, context.flag_index);
    if (!attribute.ok()) {
      return base::Error() << "Failed to get flag info: " << attribute.error();
    }

    return *attribute;
  }

  /// get server flag value
  base::Result<std::string> StorageFiles::GetServerFlagValue(
      const PackageFlagContext& context) {
    auto attribute = GetFlagAttribute(context);
    RETURN_IF_ERROR(attribute, "Failed to get flag attribute");

    if (!(*attribute & FlagInfoBit::HasServerOverride)) {
      return std::string();
    }

    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto flag_value_file = GetPersistFlagVal();
    if (!flag_value_file.ok()) {
      return base::Error() << flag_value_file.error();
    }

    switch (context.value_type) {
      case FlagValueType::Boolean: {
        auto value = get_boolean_flag_value(**flag_value_file, context.flag_index);
        if (!value.ok()) {
          return base::Error() << "Failed to get flag value: " << value.error();
        }
        return *value ? "true" : "false";
        break;
      }
      default:
        return base::Error() << "Unsupported flag value type";
    }

    return base::Error() << "Failed to find flag in value file";
  }

  /// get local flag value
  base::Result<std::string> StorageFiles::GetLocalFlagValue(
      const PackageFlagContext& context) {
    auto attribute = GetFlagAttribute(context);
    RETURN_IF_ERROR(attribute, "Failed to get flag attribute");

    if (!(*attribute & FlagInfoBit::HasLocalOverride)) {
      return std::string();
    }

    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto pb_file = storage_record_.local_overrides;
    auto pb = ReadPbFromFile<LocalFlagOverrides>(pb_file);
    if (!pb.ok()) {
      return base::Error() << "Failed to read pb from " << pb_file << ": " << pb.error();
    }

    for (auto& entry : pb->overrides()) {
      if (context.package == entry.package_name()
          && context.flag == entry.flag_name()) {
        return entry.flag_value();
      }
    }

    return base::Error() << "Failed to find flag local override value";
  }

  /// get boot flag value
  base::Result<std::string> StorageFiles::GetBootFlagValue(
      const PackageFlagContext& context) {
    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto flag_value_file = GetBootFlagVal();
    if (!flag_value_file.ok()) {
      return base::Error() << flag_value_file.error();
    }

    switch (context.value_type) {
      case FlagValueType::Boolean: {
        auto value = get_boolean_flag_value(**flag_value_file, context.flag_index);
        if (!value.ok()) {
          return base::Error() << "Failed to get boot flag value: " << value.error();
        }
        return *value ? "true" : "false";
        break;
      }
      default:
        return base::Error() << "Unsupported flag value type";
    }

    return base::Error() << "Failed to find flag in value file";
  }

  /// get default flag value
  base::Result<std::string> StorageFiles::GetDefaultFlagValue(
      const PackageFlagContext& context) {
    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto flag_value_file = GetFlagVal();
    if (!flag_value_file.ok()) {
      return base::Error() << flag_value_file.error();
    }

    switch (context.value_type) {
      case FlagValueType::Boolean: {
        auto value = get_boolean_flag_value(**flag_value_file, context.flag_index);
        if (!value.ok()) {
          return base::Error() << "Failed to get default flag value: " << value.error();
        }
        return *value ? "true" : "false";
        break;
      }
      default:
        return base::Error() << "Unsupported flag value type";
    }

    return base::Error() << "Failed to find flag in value file";
  }

  /// server flag override, update persistent flag value
  base::Result<void> StorageFiles::SetServerFlagValue(const PackageFlagContext& context,
                                                      const std::string& flag_value) {
    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto readonly = IsFlagReadOnly(context);
    RETURN_IF_ERROR(readonly, "Failed to check if flag is readonly");
    if (*readonly) {
      return base::Error() << "Cannot update read only flag";
    }

    auto flag_value_file = GetPersistFlagVal();
    RETURN_IF_ERROR(flag_value_file, "Cannot get persist flag value file");

    switch (context.value_type) {
      case FlagValueType::Boolean: {
        if (flag_value != "true" && flag_value != "false") {
          return base::Error() << "Invalid boolean flag value, it should be true|false";
        }

        auto update = set_boolean_flag_value(
            **flag_value_file, context.flag_index, flag_value == "true");
        RETURN_IF_ERROR(update, "Failed to update flag value");

        update = SetHasServerOverride(context, true);
        RETURN_IF_ERROR(update, "Failed to set flag has server override");

        break;
      }
      default:
        return base::Error() << "Unsupported flag value type";
    }

    return {};
  }

  /// Write override immediately to boot copy.
  base::Result<void> StorageFiles::WriteLocalOverrideToBootCopy(
      const PackageFlagContext& context, const std::string& flag_value) {
    if (chmod(storage_record_.boot_flag_val.c_str(), 0644) == -1) {
      return base::ErrnoError() << "chmod() failed to set to 0644";
    }

    auto flag_value_file =
        map_mutable_storage_file(storage_record_.boot_flag_val);
    auto update_result = set_boolean_flag_value(
        **flag_value_file, context.flag_index, flag_value == "true");
    RETURN_IF_ERROR(update_result, "Failed to update flag value");

    if (chmod(storage_record_.boot_flag_val.c_str(), 0444) == -1) {
      return base::ErrnoError() << "chmod() failed to set to 0444";
    }

    return {};
  }

  /// local flag override, update local flag override pb filee
  base::Result<void> StorageFiles::SetLocalFlagValue(
      const PackageFlagContext& context, const std::string& flag_value) {
    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto readonly = IsFlagReadOnly(context);
    RETURN_IF_ERROR(readonly, "Failed to check if flag is readonly")
    if (*readonly) {
      return base::Error() << "Cannot update read only flag";
    }

    auto pb_file = storage_record_.local_overrides;
    auto pb = ReadPbFromFile<LocalFlagOverrides>(pb_file);
    if (!pb.ok()) {
      return base::Error() << "Failed to read pb from " << pb_file << ": " << pb.error();
    }

    bool exist = false;
    for (auto& entry : *(pb->mutable_overrides())) {
      if (entry.package_name() == context.package
          && entry.flag_name() == context.flag) {
        if (entry.flag_value() == flag_value) {
          return {};
        }
        exist = true;
        entry.set_flag_value(flag_value);
        break;
      }
    }

    if (!exist) {
      auto new_override = pb->add_overrides();
      new_override->set_package_name(context.package);
      new_override->set_flag_name(context.flag);
      new_override->set_flag_value(flag_value);
    }

    auto write = WritePbToFile<LocalFlagOverrides>(*pb, pb_file);
    if (!write.ok()) {
      return base::Error() << "Failed to write pb to " << pb_file << ": " << write.error();
    }

    auto update = SetHasLocalOverride(context, true);
    RETURN_IF_ERROR(update, "Failed to set flag has local override");

    return {};
  }

  /// set has server override in flag info
  base::Result<void> StorageFiles::SetHasServerOverride(const PackageFlagContext& context,
                                                        bool has_server_override) {
    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto flag_info_file = GetPersistFlagInfo();
    if (!flag_info_file.ok()) {
      return base::Error() << flag_info_file.error();
    }

    auto update_result = set_flag_has_server_override(
        **flag_info_file, context.value_type, context.flag_index, has_server_override);
    if (!update_result.ok()) {
      return base::Error() << "Failed to update flag has server override: "
                           << update_result.error();
    }

    return {};
  }

  /// set has local override in flag info
  base::Result<void> StorageFiles::SetHasLocalOverride(const PackageFlagContext& context,
                                                       bool has_local_override) {
    if (!context.flag_exists) {
      return base::Error() << "Flag does not exist";
    }

    auto flag_info_file = GetPersistFlagInfo();
    if (!flag_info_file.ok()) {
      return base::Error() << flag_info_file.error();
    }

    auto update_result = set_flag_has_local_override(
        **flag_info_file, context.value_type, context.flag_index, has_local_override);
    if (!update_result.ok()) {
      return base::Error() << "Failed to update flag has local override: "
                           << update_result.error();
    }

    return {};
  }

  /// remove a single flag local override, return if removed
  base::Result<bool> StorageFiles::RemoveLocalFlagValue(
      const PackageFlagContext& context) {

    auto pb_file = storage_record_.local_overrides;
    auto pb = ReadPbFromFile<LocalFlagOverrides>(pb_file);
    if (!pb.ok()) {
      return base::Error() << "Failed to read pb from " << pb_file << ": " << pb.error();
    }

    auto remaining_overrides = LocalFlagOverrides();
    for (auto entry : pb->overrides()) {
      if (entry.package_name() == context.package
          && entry.flag_name() == context.flag) {
        continue;
      }
      auto kept_override = remaining_overrides.add_overrides();
      kept_override->set_package_name(entry.package_name());
      kept_override->set_flag_name(entry.flag_name());
      kept_override->set_flag_value(entry.flag_value());
    }

    if (remaining_overrides.overrides_size() != pb->overrides_size()) {
      auto result = WritePbToFile<LocalFlagOverrides>(remaining_overrides, pb_file);
      if (!result.ok()) {
        return base::Error() << result.error();
      }

      auto update = SetHasLocalOverride(context, false);
      RETURN_IF_ERROR(update, "Failed to unset flag has local override");

      return true;
    } else {
      return false;
    }
  }

  /// remove all local overrides
  base::Result<void> StorageFiles::RemoveAllLocalFlagValue() {
    auto pb_file = storage_record_.local_overrides;
    auto overrides_pb = ReadPbFromFile<LocalFlagOverrides>(pb_file);
    RETURN_IF_ERROR(overrides_pb, "Failed to read local overrides");

    for (auto& entry : overrides_pb->overrides()) {
      auto context = GetPackageFlagContext(entry.package_name(), entry.flag_name());
      RETURN_IF_ERROR(context, "Failed to find package flag context for flag "
                      + entry.package_name() + "/" + entry.flag_name());

      auto update = SetHasLocalOverride(*context, false);
      RETURN_IF_ERROR(update, "Failed to unset flag has local override");
    }

    if (overrides_pb->overrides_size()) {
      auto result = WritePbToFile<LocalFlagOverrides>(
          LocalFlagOverrides(), pb_file);
      RETURN_IF_ERROR(result, "Failed to flush local overrides pb file");
    }

    return {};
  }

  /// get all current server override
  base::Result<std::vector<StorageFiles::ServerOverride>>
      StorageFiles::GetServerFlagValues() {
    auto listed_flags = list_flags_with_info(storage_record_.persist_package_map,
                                             storage_record_.persist_flag_map,
                                             storage_record_.persist_flag_val,
                                             storage_record_.persist_flag_info);
    RETURN_IF_ERROR(
        listed_flags, "Failed to list all flags for " + storage_record_.container);

    auto server_updated_flags = std::vector<ServerOverride>();
    for (const auto& flag : *listed_flags) {
      if (flag.has_server_override) {
        auto server_override = ServerOverride();
        server_override.package_name = std::move(flag.package_name);
        server_override.flag_name = std::move(flag.flag_name);
        server_override.flag_value = std::move(flag.flag_value);
        server_updated_flags.push_back(server_override);
      }
    }

    return server_updated_flags;
  }

  /// remove all storage files
  base::Result<void> StorageFiles::RemoveAllPersistFiles() {
    package_map_.reset(nullptr);
    flag_map_.reset(nullptr);
    flag_val_.reset(nullptr);
    boot_flag_val_.reset(nullptr);
    boot_flag_info_.reset(nullptr);
    persist_flag_val_.reset(nullptr);
    persist_flag_info_.reset(nullptr);
    if (unlink(storage_record_.persist_package_map.c_str()) == -1) {
      return base::ErrnoError() << "unlink() failed for "
                                << storage_record_.persist_package_map;
    }
    if (unlink(storage_record_.persist_flag_map.c_str()) == -1) {
      return base::ErrnoError() << "unlink() failed for "
                                << storage_record_.persist_flag_map;
    }
    if (unlink(storage_record_.persist_flag_val.c_str()) == -1) {
      return base::ErrnoError() << "unlink() failed for "
                                << storage_record_.persist_flag_val;
    }
    if (unlink(storage_record_.persist_flag_info.c_str()) == -1) {
      return base::ErrnoError() << "unlink() failed for "
                                << storage_record_.persist_flag_info;
    }
    if (unlink(storage_record_.local_overrides.c_str()) == -1) {
      return base::ErrnoError() << "unlink() failed for " << storage_record_.local_overrides;
    }
    return {};
  }

  /// create boot flag value and info files
  base::Result<void> StorageFiles::CreateBootStorageFiles() {
    // If the boot copy already exists, do nothing. Never update the boot copy, the boot
    // copy should be boot stable. So in the following scenario: a container storage
    // file boot copy is created, then an updated container is mounted along side existing
    // container. In this case, we should update the persistent storage file copy. But
    // never touch the current boot copy.
    if (FileExists(storage_record_.boot_flag_val)
        && FileExists(storage_record_.boot_flag_info)) {
      return {};
    }

    auto copy = CopyFile(
        storage_record_.persist_flag_val, storage_record_.boot_flag_val, 0444);
    RETURN_IF_ERROR(copy, "CopyFile failed for " + storage_record_.persist_flag_val);

    copy = CopyFile(
        storage_record_.persist_flag_info, storage_record_.boot_flag_info, 0444);
    RETURN_IF_ERROR(copy, "CopyFile failed for " + storage_record_.persist_flag_info);

    // change boot flag value file to 0644 to allow write
    if (chmod(storage_record_.boot_flag_val.c_str(), 0644) == -1) {
      return base::ErrnoError() << "chmod() failed to set to 0644";
    };

    auto apply_result = ApplyLocalOverrideToBootFlagValue();

    // change boot flag value file back to 0444
    if (chmod(storage_record_.boot_flag_val.c_str(), 0444) == -1) {
      if (!apply_result.ok()) {
        return base::ErrnoError() << apply_result.error() << ": "
                                  << "chmod() failed to set to 0444";
      } else {
        return base::ErrnoError() << "chmod() failed to set to 0444";
      }
    };

    return apply_result;
  }

  /// list a flag
  base::Result<StorageFiles::FlagSnapshot> StorageFiles::ListFlag(
      const std::string& package,
      const std::string& flag) {

    auto context = GetPackageFlagContext(package, flag);
    RETURN_IF_ERROR(context, "Failed to find package flag context");

    if (!context->flag_exists) {
      return base::Error() << "Flag " << package << "/" << flag << " does not exist";
    }

    auto attribute = GetFlagAttribute(*context);
    RETURN_IF_ERROR(context, "Failed to get flag attribute");

    auto server_value = GetServerFlagValue(*context);
    RETURN_IF_ERROR(server_value, "Failed to get server flag value");

    auto local_value = GetLocalFlagValue(*context);
    RETURN_IF_ERROR(local_value, "Failed to get local flag value");

    auto boot_value = GetBootFlagValue(*context);
    RETURN_IF_ERROR(boot_value, "Failed to get boot flag value");

    auto default_value = GetDefaultFlagValue(*context);
    RETURN_IF_ERROR(default_value, "Failed to get default flag value");

    auto snapshot = FlagSnapshot();
    snapshot.package_name = package;
    snapshot.flag_name = flag;
    snapshot.default_flag_value = *default_value;
    snapshot.boot_flag_value = *boot_value;
    snapshot.server_flag_value = *server_value;
    snapshot.local_flag_value = *local_value;
    snapshot.is_readwrite = *attribute & FlagInfoBit::IsReadWrite;
    snapshot.has_server_override = *attribute & FlagInfoBit::HasServerOverride;
    snapshot.has_local_override = *attribute & FlagInfoBit::HasLocalOverride;

    return snapshot;
  }

  /// list flags
  base::Result<std::vector<StorageFiles::FlagSnapshot>> StorageFiles::ListFlags(
      const std::string& package) {
    if (!package.empty()) {
      auto has_package = HasPackage(package);
      RETURN_IF_ERROR(
          has_package, package + " does not exist in " + storage_record_.container);
    }

    // fill default value
    auto snapshots = std::vector<FlagSnapshot>();
    auto idxs = std::unordered_map<std::string, size_t>();

    auto listed_flags = list_flags(storage_record_.package_map,
                                   storage_record_.flag_map,
                                   storage_record_.flag_val);
    RETURN_IF_ERROR(
        listed_flags, "Failed to list default flags for " + storage_record_.container);

    for (auto const& flag : *listed_flags) {
      if (package.empty() || package == flag.package_name) {
        idxs[flag.package_name + "/" + flag.flag_name] = snapshots.size();
        snapshots.emplace_back();
        auto& snapshot = snapshots.back();
        snapshot.package_name = std::move(flag.package_name);
        snapshot.flag_name = std::move(flag.flag_name);
        snapshot.default_flag_value = std::move(flag.flag_value);
      }
    }

    // fill boot value
    listed_flags = list_flags(storage_record_.package_map,
                              storage_record_.flag_map,
                              storage_record_.boot_flag_val);
    RETURN_IF_ERROR(
        listed_flags, "Failed to list boot flags for " + storage_record_.container);

    for (auto const& flag : *listed_flags) {
      auto full_flag_name = flag.package_name + "/" + flag.flag_name;
      if (!idxs.count(full_flag_name)) {
        continue;
      }
      auto idx = idxs[full_flag_name];
      snapshots[idx].boot_flag_value = std::move(flag.flag_value);
    }

    // fill server value and attribute
    auto listed_flags_with_info = list_flags_with_info(storage_record_.package_map,
                                                       storage_record_.flag_map,
                                                       storage_record_.persist_flag_val,
                                                       storage_record_.persist_flag_info);
    RETURN_IF_ERROR(listed_flags_with_info,
                    "Failed to list persist flags for " + storage_record_.container);

    for (auto const& flag : *listed_flags_with_info) {
      auto full_flag_name = flag.package_name + "/" + flag.flag_name;
      if (!idxs.count(full_flag_name)) {
        continue;
      }
      auto idx = idxs[full_flag_name];
      if (flag.has_server_override) {
        snapshots[idx].server_flag_value = std::move(flag.flag_value);
      }
      snapshots[idx].is_readwrite = flag.is_readwrite;
      snapshots[idx].has_server_override = flag.has_server_override;
      snapshots[idx].has_local_override = flag.has_local_override;
      snapshots[idx].container = storage_record_.container;
    }

    // fill local value
    auto const& pb_file = storage_record_.local_overrides;
    auto pb = ReadPbFromFile<LocalFlagOverrides>(pb_file);
    RETURN_IF_ERROR(pb, "Failed to read pb from " + pb_file);
    for (const auto& flag : pb->overrides()) {
      auto full_flag_name = flag.package_name() + "/" + flag.flag_name();
      if (!idxs.count(full_flag_name)) {
        continue;
      }
      auto idx = idxs[full_flag_name];
      snapshots[idx].local_flag_value = flag.flag_value();
    }

    auto comp = [](const auto& v1, const auto& v2){
      return (v1.package_name + "/" + v1.flag_name) <
          (v2.package_name + "/" + v2.flag_name);
    };
    std::sort(snapshots.begin(), snapshots.end(), comp);

    return snapshots;
  }

  } // namespace aconfigd
} // namespace android