#include "turns-turn-order.h"

#include <glib-object.h>
#include <glib.h>

#include <array>
#include <cstddef>
#include <limits>

G_BEGIN_DECLS

struct _TurnsTurnOrder
{
  GObject parent_instance;

  gsize participant_count;
  gboolean running;
};

G_DEFINE_FINAL_TYPE(TurnsTurnOrder, turns_turn_order, G_TYPE_OBJECT);

G_END_DECLS

namespace
{
  enum struct property
  {
    ParticipantCount = 1,
    Running,
    N_PROPERTIES,
  };

  auto static constinit properties = std::array<GParamSpec *, static_cast<std::size_t>(property::N_PROPERTIES)>{};

  auto get_property(GObject * self, guint id, GValue * value, GParamSpec * specification) -> void
  {
    auto instance = TURNS_TURN_ORDER(self);

    switch (static_cast<property>(id))
    {
    case property::ParticipantCount:
      return g_value_set_uint64(value, turns_turn_order_get_participant_count(instance));
    case property::Running:
      return g_value_set_boolean(value, turns_turn_order_get_running(instance));
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(self, id, specification);
    }
  }

}  // namespace

G_BEGIN_DECLS

static void turns_turn_order_class_init(TurnsTurnOrderClass * klass)
{
  auto object_class = G_OBJECT_CLASS(klass);

  object_class->get_property = get_property;

  properties[static_cast<std::size_t>(property::ParticipantCount)] =
      g_param_spec_uint64("participant-count",
                          "Participant Count",
                          "The number of participants in this turn order.",
                          0,
                          std::numeric_limits<gsize>::max(),
                          0,
                          static_cast<GParamFlags>(G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY));

  properties[static_cast<std::size_t>(property::Running)] =
      g_param_spec_boolean("running",
                           "Running",
                           "Whether or not the turn order is running (e.g. has been started)",
                           false,
                           static_cast<GParamFlags>(G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY));

  g_object_class_install_properties(object_class, properties.size(), properties.data());
}

static void turns_turn_order_init(TurnsTurnOrder * self)
{
  self->participant_count = 0;
  self->running = false;
}

TurnsTurnOrder * turns_turn_order_new()
{
  return TURNS_TURN_ORDER(g_object_new(TURNS_TYPE_TURN_ORDER, nullptr));
}

gsize turns_turn_order_get_participant_count(TurnsTurnOrder const * self)
{
  g_return_val_if_fail(TURNS_IS_TURN_ORDER(const_cast<TurnsTurnOrder *>(self)), 0);
  return self->participant_count;
}

gboolean turns_turn_order_get_running(TurnsTurnOrder const * self)
{
  g_return_val_if_fail(TURNS_IS_TURN_ORDER(const_cast<TurnsTurnOrder *>(self)), false);
  return self->running;
}

G_END_DECLS