// 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 "flatland_connection.h"

#include <lib/async/cpp/task.h>
#include <lib/async/default.h>

#include <zircon/rights.h>
#include <zircon/status.h>
#include <zircon/types.h>

#include <utility>

#include "flutter/fml/logging.h"

namespace flutter_runner {

namespace {

// Helper function for traces.
double DeltaFromNowInNanoseconds(const fml::TimePoint& now,
                                 const fml::TimePoint& time) {
  return (time - now).ToNanoseconds();
}

}  // namespace

FlatlandConnection::FlatlandConnection(
    const std::string& debug_label,
    fuchsia::ui::composition::FlatlandHandle flatland,
    fml::closure error_callback,
    on_frame_presented_event on_frame_presented_callback,
    async_dispatcher_t* dispatcher)
    : dispatcher_(dispatcher),
      flatland_(flatland.Bind()),
      error_callback_(std::move(error_callback)),
      on_frame_presented_callback_(std::move(on_frame_presented_callback)) {
  flatland_.set_error_handler([callback = error_callback_](zx_status_t status) {
    FML_LOG(ERROR) << "Flatland disconnected: " << zx_status_get_string(status);
    callback();
  });
  debug_label_ = debug_label;
  flatland_->SetDebugName(debug_label);
  flatland_.events().OnError =
      fit::bind_member(this, &FlatlandConnection::OnError);
  flatland_.events().OnFramePresented =
      fit::bind_member(this, &FlatlandConnection::OnFramePresented);
  flatland_.events().OnNextFrameBegin =
      fit::bind_member(this, &FlatlandConnection::OnNextFrameBegin);
}

FlatlandConnection::~FlatlandConnection() = default;

// This method is called from the raster thread.
void FlatlandConnection::Present() {
  TRACE_DURATION("flutter", "FlatlandConnection::Present");
  std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_);
  if (threadsafe_state_.present_credits_ > 0) {
    DoPresent();
  } else {
    present_waiting_for_credit_ = true;
  }
}

// This method is called from the raster thread.
void FlatlandConnection::DoPresent() {
  TRACE_DURATION("flutter", "FlatlandConnection::DoPresent");

  std::string per_app_tracing_name =
      "Flatland::PerAppPresent[" + debug_label_ + "]";
  TRACE_FLOW_BEGIN("gfx", per_app_tracing_name.c_str(), next_present_trace_id_);
  ++next_present_trace_id_;

  FML_CHECK(threadsafe_state_.present_credits_ > 0);
  --threadsafe_state_.present_credits_;

  fuchsia::ui::composition::PresentArgs present_args;
  present_args.set_requested_presentation_time(0);
  present_args.set_acquire_fences(std::move(acquire_fences_));

  // Schedule acquire fence overflow signaling if there is one.
  if (acquire_overflow_ != nullptr) {
    FML_CHECK(acquire_overflow_->event_.is_valid());
    async::PostTask(dispatcher_, [dispatcher = dispatcher_,
                                  overflow = acquire_overflow_]() {
      const size_t fences_size = overflow->fences_.size();
      std::shared_ptr<size_t> fences_completed = std::make_shared<size_t>(0);
      std::shared_ptr<std::vector<async::WaitOnce>> closures;

      for (auto i = 0u; i < fences_size; i++) {
        auto wait = std::make_unique<async::WaitOnce>(
            overflow->fences_[i].get(), ZX_EVENT_SIGNALED, 0u);
        auto wait_ptr = wait.get();
        wait_ptr->Begin(
            dispatcher,
            [wait = std::move(wait), overflow, fences_size, fences_completed,
             closures](async_dispatcher_t*, async::WaitOnce*,
                       zx_status_t status, const zx_packet_signal_t*) {
              (*fences_completed)++;
              FML_CHECK(status == ZX_OK)
                  << "status: " << zx_status_get_string(status);
              if (*fences_completed == fences_size) {
                // Signal the acquire fence passed on to Flatland.
                const zx_status_t status =
                    overflow->event_.signal(0, ZX_EVENT_SIGNALED);
                FML_CHECK(status == ZX_OK)
                    << "status: " << zx_status_get_string(status);
              }
            });
      }
    });
    acquire_overflow_.reset();
  }
  FML_CHECK(acquire_overflow_ == nullptr);

  present_args.set_release_fences(std::move(previous_present_release_fences_));
  // Frame rate over latency.
  present_args.set_unsquashable(true);
  flatland_->Present(std::move(present_args));

  // In Flatland, release fences apply to the content of the previous present.
  // Keeping track of the old frame's release fences and swapping ensure we set
  // the correct ones for VulkanSurface's interpretation.
  previous_present_release_fences_.clear();
  previous_present_release_fences_.swap(current_present_release_fences_);
  previous_release_overflow_ = current_release_overflow_;
  current_release_overflow_ = nullptr;

  // Similar to the treatment of acquire_fences_overflow_ above. Except in
  // the other direction.
  if (previous_release_overflow_ != nullptr) {
    FML_CHECK(previous_release_overflow_->event_.is_valid());

    std::shared_ptr<Overflow> fences = previous_release_overflow_;

    async::PostTask(dispatcher_, [dispatcher = dispatcher_,
                                  fences = previous_release_overflow_]() {
      FML_CHECK(fences != nullptr);
      FML_CHECK(fences->event_.is_valid());

      auto wait = std::make_unique<async::WaitOnce>(fences->event_.get(),
                                                    ZX_EVENT_SIGNALED, 0u);
      auto wait_ptr = wait.get();

      wait_ptr->Begin(
          dispatcher, [_wait = std::move(wait), fences](
                          async_dispatcher_t*, async::WaitOnce*,
                          zx_status_t status, const zx_packet_signal_t*) {
            FML_CHECK(status == ZX_OK)
                << "status: " << zx_status_get_string(status);

            // Multiplex signaling all events.
            for (auto& event : fences->fences_) {
              const zx_status_t status = event.signal(0, ZX_EVENT_SIGNALED);
              FML_CHECK(status == ZX_OK)
                  << "status: " << zx_status_get_string(status);
            }
          });
    });
    previous_release_overflow_ = nullptr;
  }
  FML_CHECK(previous_release_overflow_ == nullptr);  // Moved.

  acquire_fences_.clear();
}

// This method is called from the UI thread.
void FlatlandConnection::AwaitVsync(FireCallbackCallback callback) {
  TRACE_DURATION("flutter", "FlatlandConnection::AwaitVsync");

  std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_);
  threadsafe_state_.pending_fire_callback_ = nullptr;
  const auto now = fml::TimePoint::Now();

  // Initial case.
  if (MaybeRunInitialVsyncCallback(now, callback)) {
    return;
  }

  // Throttle case.
  if (threadsafe_state_.present_credits_ == 0) {
    threadsafe_state_.pending_fire_callback_ = std::move(callback);
    return;
  }

  // Regular case.
  RunVsyncCallback(now, callback);
}

// This method is called from the UI thread.
void FlatlandConnection::AwaitVsyncForSecondaryCallback(
    FireCallbackCallback callback) {
  TRACE_DURATION("flutter",
                 "FlatlandConnection::AwaitVsyncForSecondaryCallback");

  std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_);
  const auto now = fml::TimePoint::Now();

  // Initial case.
  if (MaybeRunInitialVsyncCallback(now, callback)) {
    return;
  }

  // Regular case.
  RunVsyncCallback(now, callback);
}

// This method is called from the raster thread.
void FlatlandConnection::OnError(
    fuchsia::ui::composition::FlatlandError error) {
  FML_LOG(ERROR) << "Flatland error: " << static_cast<int>(error);
  error_callback_();
}

// This method is called from the raster thread.
void FlatlandConnection::OnNextFrameBegin(
    fuchsia::ui::composition::OnNextFrameBeginValues values) {
  // Collect now before locking because this is an important timing information
  // from Scenic.
  const auto now = fml::TimePoint::Now();

  std::scoped_lock<std::mutex> lock(threadsafe_state_.mutex_);
  threadsafe_state_.first_feedback_received_ = true;
  threadsafe_state_.present_credits_ += values.additional_present_credits();
  TRACE_DURATION("flutter", "FlatlandConnection::OnNextFrameBegin",
                 "present_credits", threadsafe_state_.present_credits_);

  if (present_waiting_for_credit_ && threadsafe_state_.present_credits_ > 0) {
    DoPresent();
    present_waiting_for_credit_ = false;
  }

  // Update vsync_interval_ by calculating the difference between the first two
  // presentation times. Flatland always returns >1 presentation_infos, so this
  // check is to guard against any changes to this assumption.
  if (values.has_future_presentation_infos() &&
      values.future_presentation_infos().size() > 1) {
    threadsafe_state_.vsync_interval_ = fml::TimeDelta::FromNanoseconds(
        values.future_presentation_infos().at(1).presentation_time() -
        values.future_presentation_infos().at(0).presentation_time());
  } else {
    FML_LOG(WARNING)
        << "Flatland didn't send enough future_presentation_infos to update "
           "vsync interval.";
  }

  // Update next_presentation_times_.
  std::queue<fml::TimePoint> new_times;
  for (const auto& info : values.future_presentation_infos()) {
    new_times.emplace(fml::TimePoint::FromEpochDelta(
        fml::TimeDelta::FromNanoseconds(info.presentation_time())));
  }
  threadsafe_state_.next_presentation_times_.swap(new_times);

  // Update vsync_offset_.
  // We use modulo here because Flatland may point to the following vsync if
  // OnNextFrameBegin() is called after the current frame's latch point.
  auto vsync_offset =
      (fml::TimePoint::FromEpochDelta(fml::TimeDelta::FromNanoseconds(
           values.future_presentation_infos().front().presentation_time())) -
       now) %
      threadsafe_state_.vsync_interval_;
  // Thread contention may result in OnNextFrameBegin() being called after the
  // presentation time. Ignore these outliers.
  if (vsync_offset > fml::TimeDelta::Zero()) {
    threadsafe_state_.vsync_offset_ = vsync_offset;
  }

  // Throttle case.
  if (threadsafe_state_.pending_fire_callback_ &&
      threadsafe_state_.present_credits_ > 0) {
    RunVsyncCallback(now, threadsafe_state_.pending_fire_callback_);
    threadsafe_state_.pending_fire_callback_ = nullptr;
  }
}

// This method is called from the raster thread.
void FlatlandConnection::OnFramePresented(
    fuchsia::scenic::scheduling::FramePresentedInfo info) {
  on_frame_presented_callback_(std::move(info));
}

// Parses and updates next_presentation_times_.
fml::TimePoint FlatlandConnection::GetNextPresentationTime(
    const fml::TimePoint& now) {
  const fml::TimePoint& cutoff =
      now > threadsafe_state_.last_presentation_time_
          ? now
          : threadsafe_state_.last_presentation_time_;

  // Remove presentation times that may have been passed. This may happen after
  // a long draw call.
  while (!threadsafe_state_.next_presentation_times_.empty() &&
         threadsafe_state_.next_presentation_times_.front() <= cutoff) {
    threadsafe_state_.next_presentation_times_.pop();
  }

  // Calculate a presentation time based on
  // |threadsafe_state_.last_presentation_time_| that is later than cutoff using
  // |vsync_interval| increments if we don't have any future presentation times
  // left.
  if (threadsafe_state_.next_presentation_times_.empty()) {
    auto result = threadsafe_state_.last_presentation_time_;
    while (result <= cutoff) {
      result = result + threadsafe_state_.vsync_interval_;
    }
    return result;
  }

  // Return the next presentation time in the queue for the regular case.
  const auto result = threadsafe_state_.next_presentation_times_.front();
  threadsafe_state_.next_presentation_times_.pop();
  return result;
}

// This method is called from the UI thread.
bool FlatlandConnection::MaybeRunInitialVsyncCallback(
    const fml::TimePoint& now,
    FireCallbackCallback& callback) {
  if (!threadsafe_state_.first_feedback_received_) {
    TRACE_DURATION("flutter",
                   "FlatlandConnection::MaybeRunInitialVsyncCallback");
    const auto frame_end = now + kInitialFlatlandVsyncOffset;
    threadsafe_state_.last_presentation_time_ = frame_end;
    callback(now, frame_end);
    return true;
  }
  return false;
}

// This method may be called from the raster or UI thread, but it is safe
// because VsyncWaiter posts the vsync callback on UI thread.
void FlatlandConnection::RunVsyncCallback(const fml::TimePoint& now,
                                          FireCallbackCallback& callback) {
  const auto& frame_end = GetNextPresentationTime(now);
  const auto& frame_start = frame_end - threadsafe_state_.vsync_offset_;
  threadsafe_state_.last_presentation_time_ = frame_end;
  TRACE_DURATION("flutter", "FlatlandConnection::RunVsyncCallback",
                 "frame_start_delta",
                 DeltaFromNowInNanoseconds(now, frame_start), "frame_end_delta",
                 DeltaFromNowInNanoseconds(now, frame_end));
  callback(frame_start, frame_end);
}

// Enqueue a single fence into either the "base" vector of fences, or a
// "special" overflow multiplexer.
//
// Args:
//   - fence: the fence to add
//   - fences: the "regular" fences vector to add to.
//   - overflow: the overflow fences vector. Fences added here if there are
//     more than can fit in `fences`.
static void Enqueue(zx::event fence,
                    std::vector<zx::event>* fences,
                    std::shared_ptr<Overflow>* overflow) {
  constexpr size_t kMaxFences =
      fuchsia::ui::composition::MAX_ACQUIRE_RELEASE_FENCE_COUNT;

  // Number of all previously added fences, plus this one.
  const auto num_all_fences =
      fences->size() + 1 +
      ((*overflow == nullptr) ? 0 : (*overflow)->fences_.size());

  // If more than max number of fences come in, schedule any further fences into
  // an overflow. The overflow fences are scheduled for processing here, but are
  // processed in DoPresent().
  if (num_all_fences <= kMaxFences) {
    fences->push_back(std::move(fence));
  } else if (num_all_fences == kMaxFences + 1) {
    // The ownership of the overflow will be handed over to the signaling
    // closure on DoPresent call. So we always expect that we enter here with
    // overflow not set.
    FML_CHECK((*overflow) == nullptr) << "overflow is still active";
    *overflow = std::make_shared<Overflow>();

    // Set up the overflow fences. Creates an overflow handle, places it
    // into `fences` instead of the previous fence, and puts the prior fence
    // and this one into overflow.
    zx::event overflow_handle = std::move(fences->back());
    fences->pop_back();

    zx::event overflow_fence;
    zx_status_t status = zx::event::create(0, &overflow_fence);
    FML_CHECK(status == ZX_OK) << "status: " << zx_status_get_string(status);

    // Every DoPresent should invalidate this handle.  Holler if not.
    FML_CHECK(!(*overflow)->event_.is_valid()) << "overflow valid";
    status =
        overflow_fence.duplicate(ZX_RIGHT_SAME_RIGHTS, &(*overflow)->event_);
    FML_CHECK(status == ZX_OK) << "status: " << zx_status_get_string(status);
    fences->push_back(std::move(overflow_fence));

    // Prepare for wait_many call.
    (*overflow)->fences_.push_back(std::move(overflow_handle));
    (*overflow)->fences_.push_back(std::move(fence));

    FML_LOG(INFO) << "Enqueue using fence overflow, expect a performance hit.";
  } else {
    FML_CHECK((*overflow) != nullptr);
    // Just add to the overflow fences.
    (*overflow)->fences_.push_back(std::move(fence));
  }
}

// This method is called from the raster thread.
void FlatlandConnection::EnqueueAcquireFence(zx::event fence) {
  Enqueue(std::move(fence), &acquire_fences_, &acquire_overflow_);
}

// This method is called from the raster thread.
void FlatlandConnection::EnqueueReleaseFence(zx::event fence) {
  Enqueue(std::move(fence), &current_present_release_fences_,
          &current_release_overflow_);
}

}  // namespace flutter_runner