#include "turns/domain/turn_order.hpp"

#include <catch2/catch_test_macros.hpp>

#include <glibmm/ustring.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("active_participant() is turn_order::invalid_participant_index")
      {
        REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
      }

      THEN("empty() is true")
      {
        REQUIRE(instance->empty());
      }

      THEN("get() returns a nullptr")
      {
        REQUIRE(instance->get(0) == nullptr);
      }

      THEN("list_model() returns a non-null pointer")
      {
        REQUIRE(instance->list_model());
      }

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

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

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

      THEN("size() returns the same value as list_model()->get_n_item()")
      {
        REQUIRE(instance->size() == instance->list_model()->get_n_items());
      }

      WHEN("accessing turn_order:active-participant")
      {
        THEN("get() returns turn_order::invalid_participant_index")
        {
          REQUIRE(instance->property_active_participant().get_value() == turn_order::invalid_participant_index);
        }

        THEN("get_object() returns a pointer to the instance")
        {
          REQUIRE(instance->property_active_participant().get_object() == instance.get());
        }

        THEN("get_name() returns \"active-participant\"")
        {
          REQUIRE(instance->property_active_participant().get_name() == Glib::ustring{"active-participant"});
        }
      }

      WHEN("accessing turn_order:empty")
      {
        THEN("get() returns true")
        {
          REQUIRE(instance->property_empty().get_value());
        }

        THEN("get_object() returns a pointer to the instance")
        {
          REQUIRE(instance->property_empty().get_object() == instance.get());
        }

        THEN("get_name() returns \"empty\"")
        {
          REQUIRE(instance->property_empty().get_name() == Glib::ustring{"empty"});
        }
      }

      WHEN("accessing turn_order:has-next")
      {
        THEN("get() returns false")
        {
          REQUIRE_FALSE(instance->property_has_next().get_value());
        }

        THEN("get_object() returns a pointer to the instance")
        {
          REQUIRE(instance->property_has_next().get_object() == instance.get());
        }

        THEN("get_name() returns \"has-next\"")
        {
          REQUIRE(instance->property_has_next().get_name() == Glib::ustring{"has-next"});
        }
      }

      WHEN("accessing turn_order:has-previous")
      {
        THEN("get() returns false")
        {
          REQUIRE_FALSE(instance->property_has_previous().get_value());
        }

        THEN("get_object() returns a pointer to the instance")
        {
          REQUIRE(instance->property_has_previous().get_object() == instance.get());
        }

        THEN("get_name() returns \"has-previous\"")
        {
          REQUIRE(instance->property_has_previous().get_name() == Glib::ustring{"has-previous"});
        }
      }

      WHEN("accessing turn_order:running")
      {
        THEN("get() returns false")
        {
          REQUIRE_FALSE(instance->property_running().get_value());
        }

        THEN("get_object() returns a pointer to the instance")
        {
          REQUIRE(instance->property_running().get_object() == instance.get());
        }

        THEN("get_name() returns \"running\"")
        {
          REQUIRE(instance->property_running().get_name() == Glib::ustring{"running"});
        }
      }

      WHEN("accessing turn_order:running")
      {
        THEN("get() returns 0")
        {
          REQUIRE(instance->property_round().get_value() == 0);
        }

        THEN("get_object() returns a pointer to the instance")
        {
          REQUIRE(instance->property_round().get_object() == instance.get());
        }

        THEN("get_name() returns \"round\"")
        {
          REQUIRE(instance->property_round().get_name() == Glib::ustring{"round"});
        }
      }
    }
  }

  SCENARIO("Modification of an empty turn_order", "[turn_order]")
  {
    auto instance = turn_order::create();

    GIVEN("a single participant was added")
    {
      auto constexpr priority = 12.0f;
      instance->add("Participant #0", priority, disposition::friendly);

      AND_GIVEN("the turn_order was never started")
      {
        WHEN("no other modification occurs")
        {
          THEN("active_participant() returns turn_order::invalid_participant_index")
          {
            REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
          }

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

          THEN("get() returns a valid pointer for index 0")
          {
            REQUIRE(instance->get(0));
          }

          THEN("get() returns a nullptr for an index greater than 0")
          {
            REQUIRE(instance->get(1) == nullptr);
          }

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

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

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

          THEN("turn_order:has-next is false")
          {
            REQUIRE(instance->property_has_next() == false);
          }

          THEN("turn_order:has-previous is false")
          {
            REQUIRE(instance->property_has_previous() == false);
          }

          THEN("turn_order:running is false")
          {
            REQUIRE(instance->property_running() == false);
          }
        }

        WHEN("the participant is removed again")
        {
          instance->remove(0);

          THEN("active_participant() returns turn_order::invalid_participant_index")
          {
            REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
          }

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

          THEN("get() returns a nullptr for index 0")
          {
            REQUIRE(instance->get(0) == nullptr);
          }

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

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

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

          THEN("turn_order:has-next is false")
          {
            REQUIRE(instance->property_has_next() == false);
          }

          THEN("turn_order:has-previous is false")
          {
            REQUIRE(instance->property_has_previous() == false);
          }

          THEN("turn_order:running is false")
          {
            REQUIRE(instance->property_running() == false);
          }
        }

        WHEN("another participant with the same priority is added")
        {
          instance->add("Participant #1", priority, disposition::friendly);

          THEN("active_participant() returns turn_order::invalid_participant_index")
          {
            REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
          }

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

          THEN("get() returns a valid pointer for index 0")
          {
            REQUIRE(instance->get(0));
          }

          THEN("get() returns a valid pointer for index 1")
          {
            REQUIRE(instance->get(1));
          }

          THEN("get() returns a nullptr for an index greater than 1")
          {
            REQUIRE(instance->get(2) == nullptr);
          }

          THEN("get(0) returns the participant that was added first")
          {
            REQUIRE(instance->get(0)->get_name() == "Participant #0");
          }

          THEN("get(1) returns the participant that was added second")
          {
            REQUIRE(instance->get(1)->get_name() == "Participant #1");
          }

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

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

          THEN("size() returns 2")
          {
            REQUIRE(instance->size() == 2);
          }

          THEN("turn_order:has-next is false")
          {
            REQUIRE(instance->property_has_next() == false);
          }

          THEN("turn_order:has-previous is false")
          {
            REQUIRE(instance->property_has_previous() == false);
          }

          THEN("turn_order:running is false")
          {
            REQUIRE(instance->property_running() == false);
          }

          AND_WHEN("the participant at index 0 is removed")
          {
            instance->remove(0);

            THEN("active_participant() returns turn_order::invalid_participant_index")
            {
              REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
            }

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

            THEN("get() returns a valid pointer for index 0")
            {
              REQUIRE(instance->get(0));
            }

            THEN("get() returns a nullptr for an index greater than 0")
            {
              REQUIRE(instance->get(1) == nullptr);
            }

            THEN("get(0) returns the participant that was added second")
            {
              REQUIRE(instance->get(0)->get_name() == "Participant #1");
            }

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

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

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

            THEN("turn_order:has-next is false")
            {
              REQUIRE(instance->property_has_next() == false);
            }

            THEN("turn_order:has-previous is false")
            {
              REQUIRE(instance->property_has_previous() == false);
            }

            THEN("turn_order:running is false")
            {
              REQUIRE(instance->property_running() == false);
            }
          }

          AND_WHEN("the turn_order is cleared")
          {
            instance->clear();

            THEN("active_participant() returns turn_order::invalid_participant_index")
            {
              REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
            }

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

            THEN("get() returns a nullptr pointer for index 0")
            {
              REQUIRE(instance->get(0) == nullptr);
            }

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

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

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

            THEN("turn_order:has-next is false")
            {
              REQUIRE(instance->property_has_next() == false);
            }

            THEN("turn_order:has-previous is false")
            {
              REQUIRE(instance->property_has_previous() == false);
            }

            THEN("turn_order:running is false")
            {
              REQUIRE(instance->property_running() == false);
            }
          }
        }
      }
    }
  }

}  // namespace turns::domain::tests