#include <catch2/catch.hpp>
#include "../src/core/Executor.hpp"

using namespace twq::core;

class ExecutorTest
{
public:
  explicit ExecutorTest() {}
  virtual ~ExecutorTest() {}

protected:
};

struct CommandMock: public Command
{
  int execute_count = 0;

  void execute(Context&) override
  {
    execute_count++;
  }

  void undo(Context&) override
  {
  }
};

TEST_CASE_METHOD(ExecutorTest, "Executor_one_key")
{
  Context ctx;
  auto cmd = std::make_shared<CommandMock>();
  Binding b {std::make_shared<Shortcut>("a"), cmd};

  Executor exec;
  exec.register_binding(b);

  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(2 == cmd->execute_count);
}

TEST_CASE_METHOD(ExecutorTest, "Executor_two_same_keys")
{
  Context ctx;
  auto cmd = std::make_shared<CommandMock>();
  Binding b {std::make_shared<Shortcut>("a a"), cmd};

  Executor exec;
  exec.register_binding(b);

  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(2 == cmd->execute_count);
}

TEST_CASE_METHOD(ExecutorTest, "Executor_two_keys")
{
  Context ctx;

  auto cmd = std::make_shared<CommandMock>();
  Binding b {std::make_shared<Shortcut>("a b"), cmd};

  Executor exec;
  exec.register_binding(b);

  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"b"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {"b"});
  REQUIRE(2 == cmd->execute_count);
}


TEST_CASE_METHOD(ExecutorTest, "Executor_wrong_key")
{
  Context ctx;

  auto cmd = std::make_shared<CommandMock>();
  Binding b {std::make_shared<Shortcut>("a b"), cmd};

  Executor exec;
  exec.register_binding(b);

  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"c"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"b"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"a"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {"b"});
  REQUIRE(1 == cmd->execute_count);
}


TEST_CASE_METHOD(ExecutorTest, "Executor_two_commands")
{
  Context ctx;

  auto cmd0 = std::make_shared<CommandMock>();
  Binding b0 {std::make_shared<Shortcut>("C-a b"), cmd0};

  auto cmd1 = std::make_shared<CommandMock>();
  Binding b1 {std::make_shared<Shortcut>("C-a c"), cmd1};

  Executor exec;
  exec.register_binding(b0);
  exec.register_binding(b1);

  SECTION("execute first")
    {
      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"C-a"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"b"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
    }

    SECTION("execute second")
    {
      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"C-a"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"c"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(1 == cmd1->execute_count);
    }

    SECTION("fail first, try but fail second")
    {
      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"C-a"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"d"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"b"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
    }
}

TEST_CASE_METHOD(ExecutorTest, "Executor_two_sequentials_commands")
{
  Context ctx;

  auto cmd0 = std::make_shared<CommandMock>();
  Binding b0 {std::make_shared<Shortcut>("C-a b"), cmd0};

  auto cmd1 = std::make_shared<CommandMock>();
  Binding b1 {std::make_shared<Shortcut>("b c"), cmd1};

  Executor exec;
  exec.register_binding(b0);
  exec.register_binding(b1);

  SECTION("execute sequentially")
    {
      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"C-a"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"b"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"c"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"b"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {"c"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(1 == cmd1->execute_count);
    }
}