// Copyright 2013 The Flutter 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 "flutter/fml/platform/fuchsia/message_loop_fuchsia.h"

#include <lib/async-loop/default.h>
#include <lib/async/cpp/task.h>
#include <lib/async/default.h>
#include <lib/zx/time.h>
#include <zircon/status.h>

#include "flutter/fml/platform/fuchsia/task_observers.h"

namespace fml {

namespace {

// See comment on `ExecuteAfterTaskObservers` for explanation.
static void LoopEpilogue(async_loop_t*, void*) {
  ExecuteAfterTaskObservers();
}

constexpr async_loop_config_t kLoopConfig = {
    .make_default_for_current_thread = false,
    .epilogue = &LoopEpilogue,
};

}  // namespace

MessageLoopFuchsia::MessageLoopFuchsia() : loop_(&kLoopConfig) {
  async_set_default_dispatcher(loop_.dispatcher());

  zx_status_t timer_status =
      zx::timer::create(ZX_TIMER_SLACK_LATE, ZX_CLOCK_MONOTONIC, &timer_);
  FML_CHECK(timer_status == ZX_OK)
      << "MessageLoopFuchsia failed to create timer; status="
      << zx_status_get_string(timer_status);
}

MessageLoopFuchsia::~MessageLoopFuchsia() {
  // It is only safe to unset the current thread's default dispatcher if it is
  // already pointing to this loop.
  if (async_get_default_dispatcher() == loop_.dispatcher()) {
    async_set_default_dispatcher(nullptr);
  }
}

void MessageLoopFuchsia::Run() {
  timer_wait_ = std::make_unique<async::Wait>(
      timer_.get(), ZX_TIMER_SIGNALED, 0,
      [this](async_dispatcher_t* dispatcher, async::Wait* wait,
             zx_status_t status, const zx_packet_signal_t* signal) {
        if (status == ZX_ERR_CANCELED) {
          return;
        }
        FML_CHECK(signal->observed & ZX_TIMER_SIGNALED);

        // Cancel the timer now, because `RunExpiredTasksNow` might not re-arm
        // the timer.  That would leave the timer in a signalled state and it
        // would trigger the async::Wait again immediately, creating a busy
        // loop.
        //
        // NOTE: It is not neccesary to synchronize this with the timer_.set()
        // call below, even though WakeUp() can be called from any thread and
        // thus timer_.set() can run in parallel with this timer_.cancel().
        //
        // Zircon will synchronize the 2 syscalls internally, and the Wait loop
        // here is resilient to cancel() and set() being called in any order.
        timer_.cancel();

        // Run the tasks, which may or may not re-arm the timer for the future.
        RunExpiredTasksNow();

        // Kick off the next iteration of the timer wait loop.
        zx_status_t wait_status = wait->Begin(loop_.dispatcher());
        FML_CHECK(wait_status == ZX_OK)
            << "MessageLoopFuchsia::WakeUp failed to wait for timer; status="
            << zx_status_get_string(wait_status);
      });

  // Kick off the first iteration of the timer wait loop.
  zx_status_t wait_status = timer_wait_->Begin(loop_.dispatcher());
  FML_CHECK(wait_status == ZX_OK)
      << "MessageLoopFuchsia::WakeUp failed to wait for timer; status="
      << zx_status_get_string(wait_status);

  // Kick off the underlying async loop that services the timer wait in addition
  // to other tasks and waits queued on its `async_dispatcher_t`.
  loop_.Run();

  // Ensure any pending waits on the timer are properly canceled.
  if (timer_wait_->is_pending()) {
    timer_wait_->Cancel();
    timer_.cancel();
  }
}

void MessageLoopFuchsia::Terminate() {
  loop_.Quit();
}

void MessageLoopFuchsia::WakeUp(fml::TimePoint time_point) {
  constexpr zx::duration kZeroSlack(0);
  zx::time due_time(time_point.ToEpochDelta().ToNanoseconds());

  zx_status_t timer_status = timer_.set(due_time, kZeroSlack);
  FML_CHECK(timer_status == ZX_OK)
      << "MessageLoopFuchsia::WakeUp failed to set timer; status="
      << zx_status_get_string(timer_status);
}

}  // namespace fml