//
// Copyright (C) 2012 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 "shill/key_value_store.h"

#if defined(ENABLE_BINDER)
#include <binder/PersistableBundle.h>
#include <utils/String16.h>
#endif  // ENABLE_BINDER
#include <base/stl_util.h>

#include "shill/logging.h"

#if defined(ENABLE_BINDER)
using android::os::PersistableBundle;
using android::String16;
#endif  // ENABLE_BINDER
using std::map;
using std::string;
using std::vector;

namespace shill {

KeyValueStore::KeyValueStore() {}

void KeyValueStore::Clear() {
  properties_.clear();
}

bool KeyValueStore::IsEmpty() {
  return properties_.empty();
}

void KeyValueStore::CopyFrom(const KeyValueStore& b) {
  properties_ = b.properties_;
}

bool KeyValueStore::operator==(const KeyValueStore& rhs) const {
  return properties_ == rhs.properties_;
}

bool KeyValueStore::operator!=(const KeyValueStore& rhs) const {
  return properties_ != rhs.properties_;
}

bool KeyValueStore::ContainsBool(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<bool>();
}

bool KeyValueStore::ContainsBools(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<vector<bool>>();
}

bool KeyValueStore::ContainsByteArrays(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second
          .IsTypeCompatible<vector<vector<uint8_t>>>();
}

bool KeyValueStore::ContainsInt(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<int32_t>();
}

bool KeyValueStore::ContainsInts(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<vector<int32_t>>();
}

bool KeyValueStore::ContainsInt16(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<int16_t>();
}

bool KeyValueStore::ContainsInt64(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<int64_t>();
}

bool KeyValueStore::ContainsInt64s(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<vector<int64_t>>();
}

bool KeyValueStore::ContainsDouble(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<double>();
}

bool KeyValueStore::ContainsDoubles(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<vector<double>>();
}

bool KeyValueStore::ContainsKeyValueStore(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<KeyValueStore>();
}

bool KeyValueStore::ContainsRpcIdentifier(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<dbus::ObjectPath>();
}

bool KeyValueStore::ContainsRpcIdentifiers(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second
          .IsTypeCompatible<vector<dbus::ObjectPath>>();
}

bool KeyValueStore::ContainsString(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<string>();
}

bool KeyValueStore::ContainsStringmap(const std::string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<Stringmap>();
}

bool KeyValueStore::ContainsStrings(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<Strings>();
}

bool KeyValueStore::ContainsUint(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<uint32_t>();
}

bool KeyValueStore::ContainsUint8(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<uint8_t>();
}

bool KeyValueStore::ContainsUint16(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<uint16_t>();
}

bool KeyValueStore::ContainsUint8s(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<vector<uint8_t>>();
}

bool KeyValueStore::ContainsUint32s(const string& name) const {
  return ContainsKey(properties_, name) &&
      properties_.find(name)->second.IsTypeCompatible<vector<uint32_t>>();
}

bool KeyValueStore::Contains(const string& name) const {
  return ContainsKey(properties_, name);
}

bool KeyValueStore::GetBool(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<bool>())
      << "for bool property " << name;
  return it->second.Get<bool>();
}

const vector<bool>& KeyValueStore::GetBools(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<vector<bool>>())
      << "for bools property " << name;
  return it->second.Get<vector<bool>>();
}

const vector<vector<uint8_t>>& KeyValueStore::GetByteArrays(
    const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() &&
        it->second.IsTypeCompatible<vector<vector<uint8_t>>>())
      << "for byte arrays property " << name;
  return it->second.Get<vector<vector<uint8_t>>>();
}

int32_t KeyValueStore::GetInt(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<int32_t>())
      << "for int property " << name;
  return it->second.Get<int32_t>();
}

const vector<int32_t>& KeyValueStore::GetInts(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() &&
        it->second.IsTypeCompatible<vector<int32_t>>())
      << "for ints property " << name;
  return it->second.Get<vector<int32_t>>();
}

int16_t KeyValueStore::GetInt16(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<int16_t>())
      << "for int16 property " << name;
  return it->second.Get<int16_t>();
}

int64_t KeyValueStore::GetInt64(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<int64_t>())
      << "for int64 property " << name;
  return it->second.Get<int64_t>();
}

const vector<int64_t>& KeyValueStore::GetInt64s(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() &&
        it->second.IsTypeCompatible<vector<int64_t>>())
      << "for int64s property " << name;
  return it->second.Get<vector<int64_t>>();
}

double KeyValueStore::GetDouble(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<double>())
      << "for double property " << name;
  return it->second.Get<double>();
}

const vector<double>& KeyValueStore::GetDoubles(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() &&
        it->second.IsTypeCompatible<vector<double>>())
      << "for doubles property " << name;
  return it->second.Get<vector<double>>();
}

const KeyValueStore& KeyValueStore::GetKeyValueStore(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<KeyValueStore>())
      << "for key value store property " << name;
  return it->second.Get<KeyValueStore>();
}

const string& KeyValueStore::GetRpcIdentifier(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() &&
        it->second.IsTypeCompatible<dbus::ObjectPath>())
      << "for rpc identifier property " << name;
  return it->second.Get<dbus::ObjectPath>().value();
}

vector<string> KeyValueStore::GetRpcIdentifiers(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() &&
        it->second.IsTypeCompatible<vector<dbus::ObjectPath>>())
      << "for rpc identifier property " << name;
  RpcIdentifiers ids;
  KeyValueStore::ConvertPathsToRpcIdentifiers(
      it->second.Get<vector<dbus::ObjectPath>>(), &ids);
  return ids;
}

const string& KeyValueStore::GetString(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<string>())
      << "for string property " << name;
  return it->second.Get<string>();
}

const map<string, string>& KeyValueStore::GetStringmap(
    const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<Stringmap>())
      << "for stringmap property " << name;
  return it->second.Get<Stringmap>();
}

const vector<string>& KeyValueStore::GetStrings(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<Strings>())
      << "for strings property " << name;
  return it->second.Get<Strings>();
}

uint32_t KeyValueStore::GetUint(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<uint32_t>())
      << "for uint32 property " << name;
  return it->second.Get<uint32_t>();
}

uint16_t KeyValueStore::GetUint16(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<uint16_t>())
      << "for uint16 property " << name;
  return it->second.Get<uint16_t>();
}

uint8_t KeyValueStore::GetUint8(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() && it->second.IsTypeCompatible<uint8_t>())
      << "for uint8 property " << name;
  return it->second.Get<uint8_t>();
}

const vector<uint8_t>& KeyValueStore::GetUint8s(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() &&
        it->second.IsTypeCompatible<vector<uint8_t>>())
      << "for uint8s property " << name;
  return it->second.Get<vector<uint8_t>>();
}

const vector<uint32_t>& KeyValueStore::GetUint32s(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end() &&
        it->second.IsTypeCompatible<vector<uint32_t>>())
      << "for uint32s property " << name;
  return it->second.Get<vector<uint32_t>>();
}

const brillo::Any& KeyValueStore::Get(const string& name) const {
  const auto it(properties_.find(name));
  CHECK(it != properties_.end());
  return it->second;
}

void KeyValueStore::SetBool(const string& name, bool value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetBools(const string& name, const vector<bool>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetByteArrays(const string& name,
                                  const vector<vector<uint8_t>>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetInt(const string& name, int32_t value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetInts(const string& name, const vector<int32_t>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetInt16(const string& name, int16_t value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetInt64(const string& name, int64_t value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetInt64s(const string& name,
                              const vector<int64_t>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetDouble(const string& name, double value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetDoubles(const string& name,
                               const vector<double>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetKeyValueStore(const string& name,
                                     const KeyValueStore& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetRpcIdentifier(const string& name, const string& value) {
  properties_[name] = brillo::Any(dbus::ObjectPath(value));
}

void KeyValueStore::SetRpcIdentifiers(const string& name,
                                      const vector<string>& value) {
  vector<dbus::ObjectPath> paths;
  for (const auto& rpcid : value) {
    paths.push_back(dbus::ObjectPath(rpcid));
  }
  properties_[name] = brillo::Any(paths);
}

void KeyValueStore::SetString(const string& name, const string& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetStringmap(const string& name,
                                 const map<string, string>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetStrings(const string& name,
                               const vector<string>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetUint(const string& name, uint32_t value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetUint16(const string& name, uint16_t value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetUint8(const string& name, uint8_t value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetUint8s(const string& name,
                              const vector<uint8_t>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::SetUint32s(const string& name,
                               const vector<uint32_t>& value) {
  properties_[name] = brillo::Any(value);
}

void KeyValueStore::Set(const string& name, const brillo::Any& value) {
  properties_[name] = value;
}

void KeyValueStore::RemoveByteArrays(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveInt(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveInt16(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveKeyValueStore(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveRpcIdentifier(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveString(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveStringmap(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveStrings(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveUint16(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveUint8(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveUint8s(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::RemoveUint32s(const string& name) {
  properties_.erase(name);
}

void KeyValueStore::Remove(const string& name) {
  properties_.erase(name);
}

bool KeyValueStore::LookupBool(const string& name, bool default_value) const {
  const auto it(properties_.find(name));
  if (it == properties_.end()) {
    return default_value;
  }
  CHECK(it->second.IsTypeCompatible<bool>()) << "type mismatched";
  return it->second.Get<bool>();
}

int KeyValueStore::LookupInt(const string& name, int default_value) const {
  const auto it(properties_.find(name));
  if (it == properties_.end()) {
    return default_value;
  }
  CHECK(it->second.IsTypeCompatible<int32_t>()) << "type mismatched";
  return it->second.Get<int32_t>();
}

string KeyValueStore::LookupString(const string& name,
                                   const string& default_value) const {
  const auto it(properties_.find(name));
  if (it == properties_.end()) {
    return default_value;
  }
  CHECK(it->second.IsTypeCompatible<string>()) << "type mismatched";
  return it->second.Get<string>();
}

// static.
void KeyValueStore::ConvertToVariantDictionary(
    const KeyValueStore& in_store, brillo::VariantDictionary* out_dict) {
  for (const auto& key_value_pair : in_store.properties_) {
    if (key_value_pair.second.IsTypeCompatible<KeyValueStore>()) {
      // Special handling for nested KeyValueStore (convert it to
      // nested brillo::VariantDictionary).
      brillo::VariantDictionary dict;
      ConvertToVariantDictionary(
          key_value_pair.second.Get<KeyValueStore>(), &dict);
      out_dict->emplace(key_value_pair.first, dict);
    } else {
      out_dict->insert(key_value_pair);
    }
  }
}

// static.
void KeyValueStore::ConvertFromVariantDictionary(
    const brillo::VariantDictionary& in_dict, KeyValueStore* out_store) {
  for (const auto& key_value_pair : in_dict) {
    if (key_value_pair.second.IsTypeCompatible<brillo::VariantDictionary>()) {
      // Special handling for nested brillo::VariantDictionary (convert it to
      // nested KeyValueStore).
      KeyValueStore store;
      ConvertFromVariantDictionary(
          key_value_pair.second.Get<brillo::VariantDictionary>(), &store);
      out_store->properties_.emplace(key_value_pair.first, store);
    } else {
      out_store->properties_.insert(key_value_pair);
    }
  }
}

#if defined(ENABLE_BINDER)
// static.
void KeyValueStore::ConvertToPersistableBundle(const KeyValueStore& in_store,
                                               PersistableBundle* out_bundle) {
  for (const auto& key_value_pair : in_store.properties()) {
    if (key_value_pair.second.IsTypeCompatible<bool>()) {
      out_bundle->putBoolean(String16(key_value_pair.first.c_str()),
                             key_value_pair.second.Get<bool>());
    } else if (key_value_pair.second.IsTypeCompatible<int32_t>()) {
      out_bundle->putInt(String16(key_value_pair.first.c_str()),
                         key_value_pair.second.Get<int32_t>());
    } else if (key_value_pair.second.IsTypeCompatible<int64_t>()) {
      out_bundle->putLong(String16(key_value_pair.first.c_str()),
                          key_value_pair.second.Get<int64_t>());
    } else if (key_value_pair.second.IsTypeCompatible<double>()) {
      out_bundle->putDouble(String16(key_value_pair.first.c_str()),
                            key_value_pair.second.Get<double>());
    } else if (key_value_pair.second.IsTypeCompatible<string>()) {
      out_bundle->putString(
          String16(key_value_pair.first.c_str()),
          String16(key_value_pair.second.Get<string>().c_str()));
    } else if (key_value_pair.second.IsTypeCompatible<vector<bool>>()) {
      out_bundle->putBooleanVector(String16(key_value_pair.first.c_str()),
                                   key_value_pair.second.Get<vector<bool>>());
    } else if (key_value_pair.second.IsTypeCompatible<vector<int32_t>>()) {
      out_bundle->putIntVector(String16(key_value_pair.first.c_str()),
                               key_value_pair.second.Get<vector<int32_t>>());
    } else if (key_value_pair.second.IsTypeCompatible<vector<int64_t>>()) {
      out_bundle->putLongVector(String16(key_value_pair.first.c_str()),
                                key_value_pair.second.Get<vector<int64_t>>());
    } else if (key_value_pair.second.IsTypeCompatible<vector<double>>()) {
      out_bundle->putDoubleVector(String16(key_value_pair.first.c_str()),
                                  key_value_pair.second.Get<vector<double>>());
    } else if (key_value_pair.second.IsTypeCompatible<vector<string>>()) {
      vector<String16> string16_vector;
      for (const string& std_string :
           key_value_pair.second.Get<vector<string>>()) {
        string16_vector.emplace_back(String16(std_string.c_str()));
      }
      out_bundle->putStringVector(String16(key_value_pair.first.c_str()),
                                  string16_vector);
    } else if (key_value_pair.second.IsTypeCompatible<KeyValueStore>()) {
      PersistableBundle bundle;
      ConvertToPersistableBundle(key_value_pair.second.Get<KeyValueStore>(),
                                 &bundle);
      out_bundle->putPersistableBundle(String16(key_value_pair.first.c_str()),
                                       bundle);
    } else {
      LOG(ERROR) << __func__ << ": KeyValueStore entry with key "
                 << key_value_pair.first
                 << " contains a value type that is not supported by "
                    "PersistableBundle";
    }
  }
}

// static.
void KeyValueStore::ConvertFromPersistableBundle(
    const PersistableBundle& in_bundle, KeyValueStore* out_store) {
  if (in_bundle.empty()) {
    return;
  }

  bool bool_value;
  for (const auto& key : in_bundle.getBooleanKeys()) {
    in_bundle.getBoolean(key, &bool_value);
    out_store->SetBool(String16::std_string(key), bool_value);
  }

  int32_t int_value;
  for (const auto& key : in_bundle.getIntKeys()) {
    in_bundle.getInt(key, &int_value);
    out_store->SetInt(String16::std_string(key), int_value);
  }

  int64_t long_value;
  for (const auto& key : in_bundle.getLongKeys()) {
    in_bundle.getLong(key, &long_value);
    out_store->SetInt64(String16::std_string(key), long_value);
  }

  double double_value;
  for (const auto& key : in_bundle.getDoubleKeys()) {
    in_bundle.getDouble(key, &double_value);
    out_store->SetDouble(String16::std_string(key), double_value);
  }

  String16 string_value;
  for (const auto& key : in_bundle.getStringKeys()) {
    in_bundle.getString(key, &string_value);
    out_store->SetString(String16::std_string(key),
                         String16::std_string(string_value));
  }

  vector<bool> bool_vector_value;
  for (const auto& key : in_bundle.getBooleanVectorKeys()) {
    in_bundle.getBooleanVector(key, &bool_vector_value);
    out_store->SetBools(String16::std_string(key), bool_vector_value);
  }

  vector<int32_t> int_vector_value;
  for (const auto& key : in_bundle.getIntVectorKeys()) {
    in_bundle.getIntVector(key, &int_vector_value);
    out_store->SetInts(String16::std_string(key), int_vector_value);
  }

  vector<int64_t> long_vector_value;
  for (const auto& key : in_bundle.getLongVectorKeys()) {
    in_bundle.getLongVector(key, &long_vector_value);
    out_store->SetInt64s(String16::std_string(key), long_vector_value);
  }

  vector<double> double_vector_value;
  for (const auto& key : in_bundle.getDoubleVectorKeys()) {
    in_bundle.getDoubleVector(key, &double_vector_value);
    out_store->SetDoubles(String16::std_string(key), double_vector_value);
  }

  vector<String16> string16_vector_value;
  for (const auto& key : in_bundle.getStringVectorKeys()) {
    in_bundle.getStringVector(key, &string16_vector_value);
    vector<string> string_vector_value;
    for (const String16& string16 : string16_vector_value) {
      string_vector_value.emplace_back(String16::std_string(string16));
    }
    out_store->SetStrings(String16::std_string(key), string_vector_value);
  }

  PersistableBundle persistable_bundle_value;
  for (const auto& key : in_bundle.getPersistableBundleKeys()) {
    in_bundle.getPersistableBundle(key, &persistable_bundle_value);
    KeyValueStore key_value_store_value;
    ConvertFromPersistableBundle(persistable_bundle_value,
                                 &key_value_store_value);
    out_store->SetKeyValueStore(String16::std_string(key),
                                key_value_store_value);
  }
}
#endif  // ENABLE_BINDER

// static.
void KeyValueStore::ConvertPathsToRpcIdentifiers(
  const vector<dbus::ObjectPath>& paths, vector<string>* rpc_identifiers) {
  for (const auto& path : paths) {
    rpc_identifiers->push_back(path.value());
  }
}

}  // namespace shill