// Copyright 2021 The Chromium OS 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 <optional>
#include <utility>

#include <base/containers/contains.h>
#include <ModemManager/ModemManager.h>

#include "hermes/modem_manager_proxy.h"

namespace {

constexpr auto kInhibitTimeout = base::Minutes(1);

}

namespace hermes {

ModemManagerProxy::ModemManagerProxy(const scoped_refptr<dbus::Bus>& bus)
    : bus_(bus),
      object_manager_proxy_(
          std::make_unique<org::freedesktop::DBus::ObjectManagerProxy>(
              bus,
              modemmanager::kModemManager1ServiceName,
              dbus::ObjectPath(modemmanager::kModemManager1ServicePath))),
      mm_proxy_(std::make_unique<org::freedesktop::ModemManager1Proxy>(
          bus, modemmanager::kModemManager1ServiceName)),
      modem_appeared_(false),
      weak_factory_(this) {
  auto on_interface_added = base::BindRepeating(
      &ModemManagerProxy::OnInterfaceAdded, weak_factory_.GetWeakPtr());
  auto on_interface_removed = base::BindRepeating(
      &ModemManagerProxy::OnInterfaceRemoved, weak_factory_.GetWeakPtr());
  auto on_dbus_signal_connected =
      base::BindRepeating([](const std::string& interface,
                             const std::string& signal, bool success) {
        if (!success)
          LOG(ERROR) << "Failed to connect to signal " << interface << "."
                     << signal;
      });
  object_manager_proxy_->RegisterInterfacesAddedSignalHandler(
      std::move(on_interface_added), on_dbus_signal_connected);
  object_manager_proxy_->RegisterInterfacesRemovedSignalHandler(
      std::move(on_interface_removed), on_dbus_signal_connected);
}

ModemManagerProxy::ModemManagerProxy() : weak_factory_(this) {}

void ModemManagerProxy::RegisterModemAppearedCallback(base::OnceClosure cb) {
  VLOG(2) << __func__;
  on_modem_appeared_cb_ = std::move(cb);
}

void ModemManagerProxy::WaitForModem(base::OnceClosure cb) {
  VLOG(2) << __func__;
  if (modem_proxy_) {
    std::move(cb).Run();
    return;
  }
  auto on_service_available =
      base::BindOnce(&ModemManagerProxy::WaitForModemStepGetObjects,
                     weak_factory_.GetWeakPtr(), std::move(cb));
  object_manager_proxy_->GetObjectProxy()->WaitForServiceToBeAvailable(
      std::move((on_service_available)));
}

void ModemManagerProxy::WaitForModemStepGetObjects(base::OnceClosure cb, bool) {
  VLOG(2) << __func__;
  auto error_cb = base::BindOnce([](brillo::Error* err) {
    LOG(ERROR) << "Could not get MM managed objects: " << err->GetDomain()
               << ": " << err->GetCode() << ": " << err->GetMessage();
  });
  object_manager_proxy_->GetManagedObjectsAsync(
      base::BindOnce(&ModemManagerProxy::WaitForModemStepLast,
                     weak_factory_.GetWeakPtr(), std::move(cb)),
      std::move(error_cb));
}

void ModemManagerProxy::WaitForModemStepLast(
    base::OnceClosure cb,
    const DBusObjectsWithProperties& dbus_objects_with_properties) {
  VLOG(2) << __func__;
  for (const auto& object_properties_pair : dbus_objects_with_properties) {
    VLOG(2) << __func__ << ": " << object_properties_pair.first.value();
    if (!base::Contains(object_properties_pair.second,
                        modemmanager::kModemManager1ModemInterface)) {
      continue;
    }
    LOG(INFO) << __func__ << ": Found " << object_properties_pair.first.value();
    RegisterModemAppearedCallback(std::move(cb));
    OnNewModemDetected(dbus::ObjectPath{object_properties_pair.first.value()});
    return;
  }
  LOG(INFO) << __func__ << ": Waiting for modem...";
  RegisterModemAppearedCallback(std::move(cb));
}

void ModemManagerProxy::OnInterfaceAdded(
    const dbus::ObjectPath& object_path,
    const DBusInterfaceToProperties& properties) {
  brillo::ErrorPtr error;
  VLOG(2) << __func__ << ": " << object_path.value();
  if (!base::Contains(properties, modemmanager::kModemManager1ModemInterface)) {
    VLOG(2) << __func__ << "Interfaces added, but not modem interface.";
    return;
  }
  OnNewModemDetected(object_path);
}

void ModemManagerProxy::OnInterfaceRemoved(
    const dbus::ObjectPath& object_path,
    const std::vector<std::string>& iface) {
  brillo::ErrorPtr error;
  VLOG(2) << __func__ << ": " << object_path.value();
  if (!base::Contains(iface, modemmanager::kModemManager1ModemInterface)) {
    VLOG(2) << __func__ << "Interfaces removed, but not modem interface.";
    return;
  }
  if (!modem_proxy_) {
    VLOG(2) << "Not tracking any modem. Ignoring removal of modem interface on "
            << object_path.value();
    return;
  }
  if (modem_proxy_->GetObjectPath() != object_path)
    return;
  LOG(INFO) << "Clearing modem proxy for "
            << modem_proxy_->GetObjectPath().value();
  modem_proxy_.reset();
  pending_inhibit_cb_.Reset();
}

void ModemManagerProxy::OnNewModemDetected(dbus::ObjectPath object_path) {
  LOG(INFO) << __func__ << ": New modem detected at " << object_path.value();
  // TODO(b/229183415): Listen for dbus name owner changes instead of
  // kFirstModemAfterRestart
  const char kFirstModemAfterMMRestart[] =
      "/org/freedesktop/ModemManager1/Modem/0";
  if (modem_proxy_ && object_path.value() != kFirstModemAfterMMRestart) {
    LOG(INFO) << "Already tracking " << modem_proxy_->GetObjectPath().value()
              << ". Ignoring " << object_path.value();
    return;
  }
  modem_appeared_ = true;
  modem_proxy_ = std::make_unique<org::freedesktop::ModemManager1::ModemProxy>(
      bus_, modemmanager::kModemManager1ServiceName, object_path);
  modem_proxy_->InitializeProperties(base::BindRepeating(
      &ModemManagerProxy::OnPropertiesChanged, weak_factory_.GetWeakPtr()));
}

void ModemManagerProxy::OnPropertiesChanged(
    org::freedesktop::ModemManager1::ModemProxyInterface* modem_proxy_interface,
    const std::string& prop) {
  VLOG(3) << __func__ << " : " << prop << " changed.";

  // wait for all properties that we will be read by ModemMbim.
  if (!modem_proxy_->GetProperties()->primary_port.is_valid() ||
      !modem_proxy_->GetProperties()->state.is_valid())
    return;

  if (prop == MM_MODEM_PROPERTY_STATE && pending_inhibit_cb_ &&
      IsModemSafeToInhibit()) {
    std::move(pending_inhibit_cb_).Run();
    return;
  }

  // Ignore on_modem_appeared_cb if a property update on an existing
  // modem_proxy_ triggered this call.
  if (!modem_appeared_)
    return;
  modem_appeared_ = false;
  if (cached_primary_port_.has_value() &&
      cached_primary_port_ != modem_proxy_->primary_port()) {
    LOG(ERROR) << "Unexpected modem appeared at "
               << modem_proxy_->primary_port();
    return;
  }
  cached_primary_port_ = modem_proxy_->primary_port();
  if (!on_modem_appeared_cb_.is_null())
    std::move(on_modem_appeared_cb_).Run();
}

std::string ModemManagerProxy::GetPrimaryPort() const {
  if (!cached_primary_port_.has_value()) {
    LOG(ERROR) << __func__ << ": Primary port has never been read.";
    return "";
  }
  return cached_primary_port_.value();
}

void ModemManagerProxy::Uninhibit() {
  uninhibit_cb_.Cancel();
  if (inhibited_uid_.has_value()) {
    InhibitDevice(false, base::BindOnce([](int err) {
                    VLOG(2) << "Uninhibit completed with err: " << err;
                  }));
  }
}

void ModemManagerProxy::ScheduleUninhibit(base::TimeDelta timeout) {
  LOG(INFO) << "Uninhibiting in " << timeout.InSeconds() << " seconds.";
  uninhibit_cb_.Cancel();

  uninhibit_cb_.Reset(base::BindOnce(&ModemManagerProxy::Uninhibit,
                                     weak_factory_.GetWeakPtr()));
  base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
      FROM_HERE, uninhibit_cb_.callback(), timeout);
}

void ModemManagerProxy::WaitForModemAndInhibit(ResultCallback cb) {
  // wait for modem if another daemon has inhibited MM. If Hermes has inhibited
  // MM, then we needn't wait for the modem.
  if (inhibited_uid_.has_value()) {
    LOG(INFO) << inhibited_uid_.value() << " is already inhibited.";
    OnInhibitSuccess(/*inhibit*/ true, inhibited_uid_.value(), std::move(cb));
    return;
  }
  WaitForModem(base::BindOnce(&ModemManagerProxy::InhibitDevice,
                              weak_factory_.GetWeakPtr(), true, std::move(cb)));
}

void ModemManagerProxy::InhibitDevice(bool inhibit, ResultCallback cb) {
  LOG(INFO) << __func__ << ": inhibit = " << inhibit;
  if (!inhibit && !inhibited_uid_.has_value()) {
    LOG(ERROR) << "No inhibited device found.";
    std::move(cb).Run(kModemManagerError);
    return;
  }

  if (inhibit && (!modem_proxy_ || modem_proxy_->device().empty())) {
    LOG(ERROR) << __func__ << ": Device identifier unavailable.";
    std::move(cb).Run(kModemManagerError);
    return;
  }

  // convert cb into a repeating callback, so that it can be used by either
  // on_inhibit_success or on_inhibit_fail or FinalInhibitAttempt
  auto return_inhibit_result = base::BindRepeating(
      [](ResultCallback cb, int err) { std::move(cb).Run(err); },
      base::Passed(std::move(cb)));

  if (inhibit && !IsModemSafeToInhibit()) {
    LOG(INFO) << "Waiting for modem to become safe to inhibit";
    pending_inhibit_cb_ = base::BindOnce(&ModemManagerProxy::InhibitDevice,
                                         weak_factory_.GetWeakPtr(), inhibit,
                                         return_inhibit_result);
    base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
        FROM_HERE,
        base::BindOnce(&ModemManagerProxy::InhibitTimeout,
                       weak_factory_.GetWeakPtr(), return_inhibit_result),
        kInhibitTimeout);
    return;
  }

  auto uid = inhibit ? modem_proxy_->device() : inhibited_uid_.value();

  constexpr int kInhibitTimeoutMilliseconds = 15000;

  auto on_inhibit_success = base::BindOnce(&ModemManagerProxy::OnInhibitSuccess,
                                           weak_factory_.GetWeakPtr(), inhibit,
                                           uid, return_inhibit_result);
  auto on_inhibit_fail = base::BindOnce(
      [](ResultCallback cb, brillo::Error* error) {
        LOG(ERROR) << error->GetMessage();
        std::move(cb).Run(kModemManagerError);
      },
      return_inhibit_result);

  mm_proxy_->InhibitDeviceAsync(uid, inhibit, std::move(on_inhibit_success),
                                std::move(on_inhibit_fail),
                                kInhibitTimeoutMilliseconds);
}

void ModemManagerProxy::InhibitTimeout(ResultCallback cb) {
  if (pending_inhibit_cb_ && !IsModemSafeToInhibit()) {
    std::move(cb).Run(kModemManagerError);
    return;
  }
  if (pending_inhibit_cb_) {
    std::move(pending_inhibit_cb_).Run();
  }
}

void ModemManagerProxy::OnInhibitSuccess(bool inhibit,
                                         std::basic_string<char> uid,
                                         ResultCallback cb) {
  VLOG(2) << __func__;
  inhibited_uid_ =
      inhibit ? std::optional<std::basic_string<char>>{uid} : std::nullopt;

  // uninhibit automatically if we exceed the max duration allowed for a
  // Hermes operation.
  uninhibit_cb_.Cancel();
  if (inhibit) {
    ScheduleUninhibit(kHermesTimeout);
    std::move(cb).Run(kSuccess);
    return;
  }

  std::move(cb).Run(kSuccess);
}

bool ModemManagerProxy::IsModemSafeToInhibit() {
  if (!modem_proxy_)
    return false;

  // modem_proxy_ seems to miss property updates at times. If property updates
  // were working perfectly, one could check modem_proxy_->state() instead of
  // reading the state from MM.
  brillo::ErrorPtr error;
  auto resp = brillo::dbus_utils::CallMethodAndBlock(
      modem_proxy_->GetObjectProxy(), dbus::kDBusPropertiesInterface,
      dbus::kDBusPropertiesGet, &error,
      std::string(modemmanager::kModemManager1ModemInterface),
      std::string(MM_MODEM_PROPERTY_STATE));
  if (!resp)
    return false;
  std::int32_t state;
  if (!brillo::dbus_utils::ExtractMethodCallResults(resp.get(), &error,
                                                    &state)) {
    return false;
  }

  if (state == MM_MODEM_STATE_ENABLING || state == MM_MODEM_STATE_DISABLING ||
      state == MM_MODEM_STATE_INITIALIZING ||
      state == MM_MODEM_STATE_CONNECTING ||
      state == MM_MODEM_STATE_DISCONNECTING) {
    LOG(INFO) << "Modem in a transitional state, state = " << state;
    return false;
  }
  return true;
}

}  // namespace hermes