// Copyright 2017 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 <zircon/syscalls.h>
#include <zircon/types.h>
#include <lib/zx/timer.h>

#include <dispatcher-pool/dispatcher-execution-domain.h>
#include <dispatcher-pool/dispatcher-wakeup-event.h>

#include <utility>

namespace dispatcher {

// static
fbl::RefPtr<WakeupEvent> WakeupEvent::Create() {
  fbl::AllocChecker ac;

  auto ptr = new (&ac) WakeupEvent();
  if (!ac.check())
    return nullptr;

  return fbl::AdoptRef(ptr);
}

zx_status_t WakeupEvent::Activate(fbl::RefPtr<ExecutionDomain> domain,
                                  ProcessHandler process_handler) {
  if (process_handler == nullptr)
    return ZX_ERR_INVALID_ARGS;

  fbl::AutoLock obj_lock(&obj_lock_);
  zx::event event;
  zx_status_t res = zx::event::create(0, &event);
  if (res != ZX_OK)
    return res;

  res = ActivateLocked(std::move(event), std::move(domain));
  if (res != ZX_OK)
    return res;

  res = WaitOnPortLocked();
  if (res != ZX_OK) {
    InternalDeactivateLocked();
    return res;
  }

  process_handler_ = std::move(process_handler);

  return ZX_OK;
}

void WakeupEvent::Deactivate() {
  ProcessHandler old_process_handler;

  {
    fbl::AutoLock obj_lock(&obj_lock_);
    InternalDeactivateLocked();

    // If we were previously signalled, we are not any more.
    signaled_ = false;

    // If we are in the process of actively dispatching, do not discard our
    // handler just yet.  It is currently being used by the dispatch thread.
    // Instead, wait until the dispatch thread unwinds and allow it to clean
    // up the handler.
    //
    // Otherwise, transfer the handler state into local storage and let it
    // destruct after we have released the object lock.
    if (dispatch_state() != DispatchState::Dispatching) {
      ZX_DEBUG_ASSERT((dispatch_state() == DispatchState::Idle) ||
                      (dispatch_state() == DispatchState::WaitingOnPort));
      old_process_handler = std::move(process_handler_);
    }
  }
}

zx_status_t WakeupEvent::Signal() {
  fbl::AutoLock obj_lock(&obj_lock_);

  // If we are no longer active, we cannot signal the event.
  if (!is_active())
    return ZX_ERR_BAD_HANDLE;

  // If we are still active, then our handle had better be valid.
  ZX_DEBUG_ASSERT(handle_.is_valid());

  // Update our internal bookkeeping.
  signaled_ = true;

  // If we have already fired and are in the process of dispatching, don't
  // bother to actually signal the event at the kernel level.
  if ((dispatch_state() == DispatchState::DispatchPending) ||
      (dispatch_state() == DispatchState::Dispatching)) {
    return ZX_OK;
  }

  zx_status_t res = zx_object_signal(handle_.get(), 0u, ZX_USER_SIGNAL_0);
  ZX_DEBUG_ASSERT(res == ZX_OK);  // I cannot think of any reason that this should ever fail.

  return res;
}

void WakeupEvent::Dispatch(ExecutionDomain* domain) {
  ZX_DEBUG_ASSERT(domain != nullptr);
  ZX_DEBUG_ASSERT(process_handler_ != nullptr);

  {
    // Clear the signalled flag.  Someone might signal us again during the
    // dispatch operation.
    fbl::AutoLock obj_lock(&obj_lock_);
    ZX_DEBUG_ASSERT(dispatch_state() == DispatchState::Dispatching);
    signaled_ = false;
  }

  zx_status_t res = process_handler_(this);
  ProcessHandler old_process_handler;
  {
    fbl::AutoLock obj_lock(&obj_lock_);
    ZX_DEBUG_ASSERT(dispatch_state() == DispatchState::Dispatching);
    dispatch_state_ = DispatchState::Idle;

    // Was there a problem during processing?  If so, make sure that we
    // de-activate ourselves.
    if (res != ZX_OK) {
      InternalDeactivateLocked();
    }

    // Are we still active?  If so, either setup the next port wait
    // operation, or re-queue ourselves if we were signalled during the
    // dispatch operation.
    if (is_active()) {
      if (signaled_) {
        dispatch_state_ = DispatchState::WaitingOnPort;
        res = domain->AddPendingWork(this);
      } else {
        res = zx_object_signal(handle_.get(), ZX_USER_SIGNAL_0, 0u);
        if (res == ZX_OK)
          res = WaitOnPortLocked();
      }

      if (res != ZX_OK) {
        dispatch_state_ = DispatchState::Idle;
        InternalDeactivateLocked();
      }
    }

    // Have we become deactivated (either during dispatching or just now)?
    // If so, move our process handler state outside of our lock so that it
    // can safely destruct.
    if (!is_active()) {
      old_process_handler = std::move(process_handler_);
    }
  }
}

}  // namespace dispatcher