// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chromeos/ash/components/dbus/hermes/fake_hermes_profile_client.h"

#include <optional>

#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/task/single_thread_task_runner.h"
#include "base/values.h"
#include "chromeos/ash/components/dbus/hermes/fake_hermes_euicc_client.h"
#include "chromeos/ash/components/dbus/hermes/hermes_euicc_client.h"
#include "chromeos/ash/components/dbus/hermes/hermes_profile_client.h"
#include "chromeos/ash/components/dbus/shill/shill_device_client.h"
#include "chromeos/ash/components/dbus/shill/shill_manager_client.h"
#include "chromeos/ash/components/dbus/shill/shill_service_client.h"
#include "dbus/property.h"
#include "third_party/cros_system_api/dbus/hermes/dbus-constants.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"

namespace ash {

namespace {

const char* kDefaultCountry = "US";
const char* kDefaultOperatorName = "Network Operator";
const char* kDefaultOperatorCode = "123456";
const char* kDefaultOperatorCountry = "US";
const char* kDefaultOperatorUuid = "12345678-1234-1234-1234-123456789012";

}  // namespace

FakeHermesProfileClient::Properties::Properties(
    const PropertyChangedCallback& callback)
    : HermesProfileClient::Properties(nullptr, callback) {}

FakeHermesProfileClient::Properties::~Properties() = default;

void FakeHermesProfileClient::Properties::Get(
    dbus::PropertyBase* property,
    dbus::PropertySet::GetCallback callback) {
  DVLOG(1) << "Get " << property->name();
  std::move(callback).Run(false);
}

void FakeHermesProfileClient::Properties::GetAll() {
  DVLOG(1) << "GetAll";
}

void FakeHermesProfileClient::Properties::Set(
    dbus::PropertyBase* property,
    dbus::PropertySet::SetCallback callback) {
  DVLOG(1) << "Set " << property->name();
  if (property->name() == nick_name().name()) {
    // Only nickname property is read/write.
    std::move(callback).Run(true);
    property->ReplaceValueWithSetValue();
  } else {
    std::move(callback).Run(false);
  }
}

FakeHermesProfileClient::FakeHermesProfileClient() = default;
FakeHermesProfileClient::~FakeHermesProfileClient() = default;

void FakeHermesProfileClient::ClearProfile(
    const dbus::ObjectPath& carrier_profile_path) {
  properties_map_.erase(carrier_profile_path);
}

void FakeHermesProfileClient::SetEnableProfileBehavior(
    EnableProfileBehavior enable_profile_behavior) {
  enable_profile_behavior_ = enable_profile_behavior;
}

void FakeHermesProfileClient::SetNextEnableCarrierProfileResult(
    HermesResponseStatus status) {
  CHECK(status != HermesResponseStatus::kSuccess);
  next_enable_carrier_profile_result_ = status;
}

void FakeHermesProfileClient::EnableCarrierProfile(
    const dbus::ObjectPath& object_path,
    HermesResponseCallback callback) {
  DVLOG(1) << "Enabling Carrier Profile path=" << object_path.value();

  if (next_enable_carrier_profile_result_.has_value()) {
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback),
                                  next_enable_carrier_profile_result_.value()));
    next_enable_carrier_profile_result_ = std::nullopt;
    return;
  }

  // Update carrier profile states.
  HermesProfileClient::Properties* properties = GetProperties(object_path);
  if (!properties) {
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback),
                                  HermesResponseStatus::kErrorUnknown));
    return;
  }
  if (properties->state().value() == hermes::profile::State::kActive) {
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback),
                                  HermesResponseStatus::kErrorAlreadyEnabled));
    return;
  }
  for (auto& item : properties_map_) {
    auto& state = item.second.get()->state();
    if (state.value() != hermes::profile::State::kActive) {
      continue;
    }
    state.ReplaceValue(hermes::profile::State::kInactive);
  }
  properties->state().ReplaceValue(hermes::profile::State::kActive);

  // Update cellular device properties to match this profile.
  UpdateCellularDevice(properties);

  // Update all cellular services to set their connection state and connectable
  // properties. The newly enabled profile will have connectable set to true
  // if |enable_profile_behavior_| indicates that it should be.
  bool connectable =
      enable_profile_behavior_ != EnableProfileBehavior::kNotConnectable;
  UpdateCellularServices(properties->iccid().value(), connectable);

  // Make sure the SIM slot info is updated to reflect this change.
  HermesEuiccClient::Get()->GetTestInterface()->UpdateShillDeviceSimSlotInfo();

  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE,
      base::BindOnce(std::move(callback), HermesResponseStatus::kSuccess));
}

void FakeHermesProfileClient::DisableCarrierProfile(
    const dbus::ObjectPath& object_path,
    HermesResponseCallback callback) {
  DVLOG(1) << "Disabling Carrier Profile path=" << object_path.value();
  HermesProfileClient::Properties* properties = GetProperties(object_path);
  if (!properties) {
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback),
                                  HermesResponseStatus::kErrorUnknown));
    return;
  }
  if (properties->state().value() == hermes::profile::State::kInactive) {
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback),
                                  HermesResponseStatus::kErrorAlreadyDisabled));
    return;
  }
  properties->state().ReplaceValue(hermes::profile::State::kInactive);

  // The newly disabled profile should have connectable set to false.
  UpdateCellularServices(properties->iccid().value(), /*connectable=*/false);

  // Make sure the SIM slot info is updated to reflect this change.
  HermesEuiccClient::Get()->GetTestInterface()->UpdateShillDeviceSimSlotInfo();

  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE,
      base::BindOnce(std::move(callback), HermesResponseStatus::kSuccess));
}

void FakeHermesProfileClient::RenameProfile(const dbus::ObjectPath& object_path,
                                            const std::string& new_name,
                                            HermesResponseCallback callback) {
  DVLOG(1) << "Renaming carrier profile name to " << new_name
           << " on path: " << object_path.value();
  HermesProfileClient::Properties* properties = GetProperties(object_path);
  if (!properties) {
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback),
                                  HermesResponseStatus::kErrorUnknown));
    return;
  }
  properties->nick_name().ReplaceValue(new_name);
  NotifyPropertyChanged(object_path, hermes::profile::kNicknameProperty);
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE,
      base::BindOnce(std::move(callback), HermesResponseStatus::kSuccess));
}

HermesProfileClient::Properties* FakeHermesProfileClient::GetProperties(
    const dbus::ObjectPath& object_path) {
  auto it = properties_map_.find(object_path);
  if (it != properties_map_.end()) {
    return it->second.get();
  }

  DVLOG(1) << "Creating new Fake Profile object path =" << object_path.value();
  std::unique_ptr<Properties> properties(new Properties(
      base::BindRepeating(&FakeHermesProfileClient::CallNotifyPropertyChanged,
                          base::Unretained(this), object_path)));
  properties_map_[object_path] = std::move(properties);
  return properties_map_[object_path].get();
}

HermesProfileClient::TestInterface*
FakeHermesProfileClient::GetTestInterface() {
  return this;
}

// Updates the Shill Cellular device properties so that they match the given
// profile |properties|. This simulates expected hermes - shill interaction
// when a carrier profile is enabled. Shill updates the active cellular device
// properties so that it matches the currently enabled carrier profile.
void FakeHermesProfileClient::UpdateCellularDevice(
    HermesProfileClient::Properties* properties) {
  ShillDeviceClient::TestInterface* device_test =
      ShillDeviceClient::Get()->GetTestInterface();

  // Update the cellular device properties so that they match the carrier
  // profile that was just enabled.
  base::Value::Dict home_provider;
  home_provider.Set(shill::kNameProperty,
                    properties->service_provider().value());
  home_provider.Set(shill::kCountryProperty, kDefaultCountry);
  home_provider.Set(shill::kNetworkIdProperty, properties->mcc_mnc().value());
  const std::string cellular_device_path =
      device_test->GetDevicePathForType(shill::kTypeCellular);
  DCHECK(!cellular_device_path.empty());

  device_test->SetDeviceProperty(cellular_device_path,
                                 shill::kHomeProviderProperty,
                                 base::Value(std::move(home_provider)), true);
}

void FakeHermesProfileClient::UpdateCellularServices(const std::string& iccid,
                                                     bool connectable) {
  ShillManagerClient::TestInterface* manager_test =
      ShillManagerClient::Get()->GetTestInterface();
  ShillServiceClient::TestInterface* service_test =
      ShillServiceClient::Get()->GetTestInterface();

  base::Value::List service_list = manager_test->GetEnabledServiceList();
  for (const base::Value& service_path : service_list) {
    const base::Value::Dict* properties =
        service_test->GetServiceProperties(service_path.GetString());
    const std::string* type = properties->FindString(shill::kTypeProperty);
    const std::string* service_iccid =
        properties->FindString(shill::kIccidProperty);
    if (!service_iccid || !type || *type != shill::kTypeCellular)
      continue;

    bool is_current_service = iccid == *service_iccid;
    // All services except one with given |iccid| will have connectable set to
    // false.
    bool service_connectable = is_current_service ? connectable : false;
    service_test->SetServiceProperty(service_path.GetString(),
                                     shill::kConnectableProperty,
                                     base::Value(service_connectable));
    const char* service_state =
        is_current_service &&
                enable_profile_behavior_ ==
                    EnableProfileBehavior::kConnectableAndConnected
            ? shill::kStateOnline
            : shill::kStateIdle;
    service_test->SetServiceProperty(service_path.GetString(),
                                     shill::kStateProperty,
                                     base::Value(service_state));

    if (!is_current_service) {
      ShillServiceClient::Get()->ClearProperty(
          dbus::ObjectPath(service_path.GetString()),
          shill::kServingOperatorProperty, base::DoNothing(),
          base::DoNothing());
      continue;
    }

    // Set the operator information for the active eSIM profile.
    service_test->SetServiceProperty(
        service_path.GetString(), shill::kServingOperatorProperty,
        base::Value(
            base::Value::Dict()
                .Set(shill::kOperatorNameKey, kDefaultOperatorName)
                .Set(shill::kOperatorCodeKey, kDefaultOperatorCode)
                .Set(shill::kOperatorCountryKey, kDefaultOperatorCountry)
                .Set(shill::kOperatorUuidKey, kDefaultOperatorUuid)));
  }
}

void FakeHermesProfileClient::CallNotifyPropertyChanged(
    const dbus::ObjectPath& object_path,
    const std::string& property_name) {
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE,
      base::BindOnce(&FakeHermesProfileClient::NotifyPropertyChanged,
                     base::Unretained(this), object_path, property_name));
}

void FakeHermesProfileClient::NotifyPropertyChanged(
    const dbus::ObjectPath& object_path,
    const std::string& property_name) {
  DVLOG(1) << "Property changed path=" << object_path.value()
           << ", property=" << property_name;
  for (auto& observer : observers()) {
    observer.OnCarrierProfilePropertyChanged(object_path, property_name);
  }
}

}  // namespace ash