// Copyright 2022 The Fuchsia 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 "src/storage/f2fs/memory_watcher.h"

#include <fidl/fuchsia.memorypressure/cpp/markers.h>
#include <lib/async/cpp/task.h>
#include <lib/async/cpp/time.h>
#include <lib/component/incoming/cpp/protocol.h>
#include <lib/sys/cpp/service_directory.h>
#include <lib/syslog/cpp/macros.h>
#include <zircon/assert.h>

namespace f2fs {

static constexpr std::array kMemoryPressureStrings = {"unknown", "low", "medium", "high"};

MemoryPressureWatcher::MemoryPressureWatcher(async_dispatcher_t* dispatcher,
                                             MemoryPressureCallback callback)
    : dispatcher_(dispatcher), callback_(std::move(callback)) {
  if (auto ret = Start(); ret.is_ok()) {
    is_connected_ = true;
  }
}

std::string_view MemoryPressureWatcher::ToString(MemoryPressure level) {
  switch (level) {
    case MemoryPressure::kLow:
    case MemoryPressure::kMedium:
    case MemoryPressure::kHigh:
      return kMemoryPressureStrings[static_cast<int>(level)];
    default:
      return kMemoryPressureStrings[static_cast<int>(MemoryPressure::kUnknown)];
  }
}

void MemoryPressureWatcher::OnLevelChanged(OnLevelChangedRequest& request,
                                           OnLevelChangedCompleter::Sync& completer) {
  MemoryPressure level = MemoryPressure::kUnknown;
  switch (request.level()) {
    case fuchsia_memorypressure::Level::kWarning:
      level = MemoryPressure::kMedium;
      break;
    case fuchsia_memorypressure::Level::kCritical:
      level = MemoryPressure::kHigh;
      break;
    case fuchsia_memorypressure::Level::kNormal:
      level = MemoryPressure::kLow;
      break;
  }

  if (callback_) {
    callback_(level);
  }
  completer.Reply();
}

void MemoryPressureWatcher::on_fidl_error(fidl::UnbindInfo error) {
  memory_pressure_server_->Unbind();
  FX_LOGS(ERROR) << "Connection to fuchsia.memorypressure lost: " << error;
}

zx::result<> MemoryPressureWatcher::Start() {
  auto context = sys::ComponentContext::CreateAndServeOutgoingDirectory();
  auto dir = fidl::ClientEnd<fuchsia_io::Directory>(context->svc()->CloneChannel().TakeChannel());
  zx::result mempressure_client_end =
      component::ConnectAt<fuchsia_memorypressure::Provider>(dir.borrow());
  if (mempressure_client_end.is_error()) {
    FX_LOGS(ERROR) << "Failed to connect to the memorypressure Provider"
                   << mempressure_client_end.status_string();
    return mempressure_client_end.take_error();
  }

  fidl::Client memory_provider(std::move(*mempressure_client_end), dispatcher_);
  auto mempressure_endpoints = fidl::CreateEndpoints<fuchsia_memorypressure::Watcher>();
  memory_pressure_server_ =
      fidl::BindServer(dispatcher_, std::move(mempressure_endpoints->server), this);
  if (auto res = memory_provider->RegisterWatcher(std::move(mempressure_endpoints->client));
      res.is_error()) {
    FX_LOGS(INFO) << "Failed to register memory pressure watcher.";
    return zx::error(ZX_ERR_UNAVAILABLE);
  }
  return zx::ok();
}

}  // namespace f2fs