#include "turns/domain/turn_order.hpp"

#include "turns/domain/participant.hpp"

#include <catch2/catch_test_macros.hpp>

#include <giomm/liststore.h>

namespace turns::domain::tests
{
  SCENARIO("Queries on a fresh turn_order instance", "[turn_order]")
  {
    GIVEN("an empty turn_order")
    {
      auto instance = turn_order::create();

      THEN("get_n_items() returns 0")
      {
        auto str = Gio::ListStore<Glib::Object>::create();
        REQUIRE(instance->get_n_items() == str->get_n_items());
      }

      THEN("get_type() returns participant::get_type()")
      {
        REQUIRE(instance->get_item_type() == participant::get_type());
      }

      THEN("get_typed_object(0) returns nullptr")
      {
        REQUIRE(instance->get_typed_object<participant>(0) == nullptr);
      }

      THEN("has_next() returns false")
      {
        REQUIRE_FALSE(instance->has_next());
      }

      THEN("has_previous() returns false")
      {
        REQUIRE_FALSE(instance->has_previous());
      }

      THEN("is_empty() returns true")
      {
        REQUIRE(instance->is_empty());
      }

      THEN("is_running() returns false")
      {
        REQUIRE_FALSE(instance->is_running());
      }

      THEN("round_number() returns invalid_round_number")
      {
        REQUIRE(instance->round_number() == turn_order::invalid_round_number);
      }
    }
  }

  SCENARIO("Adding participants")
  {
    auto instance = turn_order::create();

    GIVEN("a participant has been added to a turn_order")
    {
      instance->add("Participant #0", 0, disposition::neutral);

      THEN("get_n_items() returns 1")
      {
        REQUIRE(instance->get_n_items() == 1);
      }

      THEN("get_typed_object(0) returns a non-null pointer")
      {
        REQUIRE(instance->get_typed_object<participant>(0) != nullptr);
      }

      THEN("has_next() returns true")
      {
        REQUIRE(instance->has_next());
      }

      THEN("has_previous() returns false")
      {
        REQUIRE_FALSE(instance->has_previous());
      }

      THEN("is_empty() returns false")
      {
        REQUIRE_FALSE(instance->is_empty());
      }

      THEN("is_running() returns false")
      {
        REQUIRE_FALSE(instance->is_running());
      }

      THEN("round_number() returns invalid_round_number")
      {
        REQUIRE(instance->round_number() == turn_order::invalid_round_number);
      }

      WHEN("the turn_order is start()ed")
      {
        instance->start();

        THEN("get_n_items() still returns 1")
        {
          REQUIRE(instance->get_n_items() == 1);
        }

        THEN("get_typed_object(0) still returns a non-null pointer")
        {
          REQUIRE(instance->get_typed_object<participant>(0) != nullptr);
        }

        THEN("has_next() still returns true")
        {
          REQUIRE(instance->has_next());
        }

        THEN("has_previous() still returns false")
        {
          REQUIRE_FALSE(instance->has_previous());
        }

        THEN("is_empty() still returns false")
        {
          REQUIRE_FALSE(instance->is_empty());
        }

        THEN("is_running() returns true")
        {
          REQUIRE(instance->is_running());
        }

        THEN("round_number() returns 0")
        {
          REQUIRE(instance->round_number() == 0);
        }

        AND_WHEN("invoking previous()")
        {
          instance->previous();

          THEN("get_n_items() still returns 1")
          {
            REQUIRE(instance->get_n_items() == 1);
          }

          THEN("get_typed_object(0) still returns a non-null pointer")
          {
            REQUIRE(instance->get_typed_object<participant>(0) != nullptr);
          }

          THEN("has_next() still returns true")
          {
            REQUIRE(instance->has_next());
          }

          THEN("has_previous() still returns false")
          {
            REQUIRE_FALSE(instance->has_previous());
          }

          THEN("is_empty() still returns false")
          {
            REQUIRE_FALSE(instance->is_empty());
          }

          THEN("is_running() returns true")
          {
            REQUIRE(instance->is_running());
          }

          THEN("round_number() returns 0")
          {
            REQUIRE(instance->round_number() == 0);
          }
        }

        AND_WHEN("invoking next()")
        {
          instance->next();

          THEN("get_n_items() still returns 1")
          {
            REQUIRE(instance->get_n_items() == 1);
          }

          THEN("get_typed_object(0) still returns a non-null pointer")
          {
            REQUIRE(instance->get_typed_object<participant>(0) != nullptr);
          }

          THEN("has_next() still returns true")
          {
            REQUIRE(instance->has_next());
          }

          THEN("has_previous() returns true")
          {
            REQUIRE(instance->has_previous());
          }

          THEN("is_empty() still returns false")
          {
            REQUIRE_FALSE(instance->is_empty());
          }

          THEN("is_running() returns true")
          {
            REQUIRE(instance->is_running());
          }

          THEN("round_number() returns 1")
          {
            REQUIRE(instance->round_number() == 1);
          }
        }
      }
    }
  }

}  // namespace turns::domain::tests