// Copyright 2016 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.

#ifndef LIB_DEPRECATED_LOOP_MESSAGE_LOOP_H_
#define LIB_DEPRECATED_LOOP_MESSAGE_LOOP_H_

#include <map>

#include <lib/async-loop/cpp/loop.h>

#include "lib/fxl/fxl_export.h"
#include "lib/fxl/macros.h"
#include "lib/fxl/memory/ref_ptr.h"
#include "lib/fxl/tasks/task_runner.h"
#include "topaz/lib/deprecated_loop/incoming_task_queue.h"

namespace deprecated_loop {

// DEPRECATED: please use async::Loop instead.
class FXL_EXPORT MessageLoop : private internal::TaskQueueDelegate {
 public:
  using HandlerKey = uint64_t;

  // Constructs a message loop with an empty task queue. The message loop is
  // bound to the current thread.
  MessageLoop();

  // Constructs a message loop that will begin by draining the tasks already
  // present in the |incoming_tasks| queue. The message loop is bound to the
  // current thread.
  explicit MessageLoop(fxl::RefPtr<internal::IncomingTaskQueue> incoming_tasks);

  ~MessageLoop() override;

  // Returns the message loop associated with the current thread, if any.
  static MessageLoop* GetCurrent();

  // Gets the underlying libasync dispatcher.
  // See <async/dispatcher.h> for details on how to use this.
  async_dispatcher_t* dispatcher() const { return loop_.dispatcher(); }

  // Return an interface for posting tasks to this message loop.
  const fxl::RefPtr<fxl::TaskRunner>& task_runner() const {
    return task_runner_;
  }

  // The message loop will call |callback| after each task that execute and
  // after each time it signals a handler. If the message loop already has an
  // after task callback set, this function will replace it with this one.
  void SetAfterTaskCallback(fxl::Closure callback);

  // The message loop will no longer call the registered after task callback, if
  // any.
  void ClearAfterTaskCallback();

  // Causes the message loop to run tasks until |QuitNow| is called. If no tasks
  // are available, the message loop with block and wait for tasks to be posted
  // via the |task_runner|.
  void Run();

  // Runs until there are no tasks to run and no runnable handlers. This is
  // useful for unit testing, because the behavior doesn't depend on time.
  void RunUntilIdle();

  // Prevents further tasks from running and returns from |Run|. Must be called
  // while |Run| is on the stack.
  void QuitNow();

  // Posts a task to the queue that calls |QuitNow|. Useful for gracefully
  // ending the message loop. Can be called whether or not |Run| is on the
  // stack.
  void PostQuitTask();

 private:
  // |internal::TaskQueueDelegate| implementation:
  void PostTask(fxl::Closure task, fxl::TimePoint target_time) override;
  bool RunsTasksOnCurrentThread() override;

  void Run(bool until_idle);

  static void Epilogue(async_loop_t* loop, void* data);

  internal::IncomingTaskQueue* incoming_tasks() {
    return static_cast<internal::IncomingTaskQueue*>(task_runner_.get());
  }

  async_loop_config_t loop_config_;
  async::Loop loop_;

  fxl::RefPtr<fxl::TaskRunner> task_runner_;
  fxl::Closure after_task_callback_;
  bool is_running_ = false;

  FXL_DISALLOW_COPY_AND_ASSIGN(MessageLoop);
};

}  // namespace deprecated_loop

#endif  // LIB_DEPRECATED_LOOP_MESSAGE_LOOP_H_