/*
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include <gtest/gtest.h>
#include <tbox/event/loop.h>
#include <tbox/base/scope_exit.hpp>
#include "action.h"

namespace tbox {
namespace flow {

TEST(Action, StartFinish) {
  auto loop = event::Loop::New();
  SetScopeExitAction([loop] { delete loop; });

  class TestAction : public Action {
    public:
      explicit TestAction(event::Loop &loop) : Action(loop, "Test") { }
      virtual bool isReady() const override { return true; }
      virtual void onStart() override { finish(true, 100); }
  };

  TestAction action(*loop);

  bool is_callback = false;
  action.setFinishCallback(
    [&, loop] (bool is_succ, const Action::Reason &r, const Action::Trace &t) {
      EXPECT_TRUE(is_succ);

      EXPECT_EQ(r.code, 100);
      ASSERT_EQ(t.size(), 1);
      EXPECT_EQ(t[0].type, "Test");
      is_callback = true;
    }
  );
  action.start();

  loop->exitLoop(std::chrono::milliseconds(10));
  loop->runLoop();

  EXPECT_TRUE(is_callback);
}

TEST(Action, StartBlock) {
  auto loop = event::Loop::New();
  SetScopeExitAction([loop] { delete loop; });

  class TestAction : public Action {
    public:
      explicit TestAction(event::Loop &loop) : Action(loop, "Test") { }
      virtual bool isReady() const override { return true; }
      virtual void onStart() override {
        Action::onStart();
        block(Action::Reason(100, "block_on_start"));
      }
  };

  bool is_block = false;

  TestAction action(*loop);
  action.setBlockCallback(
    [&](const Action::Reason &r, const Action::Trace &t) {
      EXPECT_EQ(r.code, 100);
      EXPECT_EQ(r.message, "block_on_start");
      ASSERT_EQ(t.size(), 1);
      EXPECT_EQ(t[0].type, "Test");
      is_block = true;
    }
  );
  action.start();

  loop->exitLoop(std::chrono::milliseconds(10));
  loop->runLoop();

  EXPECT_TRUE(is_block);
  EXPECT_EQ(action.state(), Action::State::kPause);

  action.stop();
  EXPECT_EQ(action.state(), Action::State::kStoped);
}

TEST(Action, Timeout) {
  auto loop = event::Loop::New();
  SetScopeExitAction([loop] { delete loop; });

  class TestAction : public Action {
    public:
      explicit TestAction(event::Loop &loop) : Action(loop, "Test") { }
      virtual bool isReady() const override { return true; }
  };

  TestAction action(*loop);
  action.setTimeout(std::chrono::milliseconds(50));

  bool is_callback = false;
  std::chrono::steady_clock::time_point ts_start;
  std::chrono::steady_clock::time_point ts_timeout;

  action.setFinishCallback(
    [&, loop] (bool is_succ, const Action::Reason &r, const Action::Trace &t) {
      EXPECT_FALSE(is_succ);
      EXPECT_EQ(r.code, ACTION_REASON_ACTION_TIMEOUT);
      EXPECT_EQ(r.message, "ActionTimeout");
      ASSERT_EQ(t.size(), 1);
      EXPECT_EQ(t[0].type, "Test");

      is_callback = true;
      ts_timeout = std::chrono::steady_clock::now();
      loop->exitLoop();
    }
  );
  action.start();
  ts_start = std::chrono::steady_clock::now();

  loop->runLoop();
  EXPECT_TRUE(is_callback);

  auto cout_50 = std::chrono::duration_cast<std::chrono::milliseconds>(ts_timeout - ts_start).count();
  EXPECT_LE(cout_50, 51);
  EXPECT_GE(cout_50, 49);
}

}
}