#include "turns/domain/turn_order.hpp"

#include "turns/domain/participant.hpp"

#include <compare>
#include <typeinfo>

#include <glibmm/binding.h>
#include <glibmm/refptr.h>

namespace turns::domain
{

  namespace
  {
    auto constexpr comparator = [](auto lhs, auto rhs) {
      auto result = *lhs <=> *rhs;
      if (result == std::partial_ordering::equivalent || result == std::partial_ordering::unordered)
      {
        return 0;
      }
      else if (result == std::partial_ordering::less)
      {
        return 1;
      }
      return -1;
    };

    auto constexpr equal_comparator = [](auto lhs, auto rhs) {
      return (lhs->get_name() == rhs->get_name()) && (lhs->get_priority() && rhs->get_priority());
    };
  }  // namespace

  auto turn_order::create() -> Glib::RefPtr<turn_order>
  {
    return Glib::make_refptr_for_instance(new turn_order{});
  }

  turn_order::turn_order()
      : Glib::ObjectBase{typeid(turn_order)}
      , m_model{Gio::ListStore<participant>::create()}
      , m_empty{*this, "empty", true}
  {
    Glib::Binding::bind_property(m_model->property_n_items(), m_empty.get_proxy(), Glib::Binding::Flags::DEFAULT, [](auto n) {
      return n == 0;
    });
  }

  auto turn_order::append(Glib::RefPtr<participant> item) -> void
  {
    if (auto [found, index] = m_model->find(item, equal_comparator); !found)
    {
      m_model->insert_sorted(item, comparator);
      item->property_priority().signal_changed().connect([this] { m_model->sort(comparator); });
    }
  }

  auto turn_order::append(Glib::ustring const & name, float priority, disposition disposition) -> void
  {
    auto participant = participant::create(name, priority, disposition);
    append(participant);
  }

  auto turn_order::get_participant(unsigned int index) -> Glib::RefPtr<participant>
  {
    return m_model->get_item(index);
  }

  auto turn_order::list_model() -> Glib::RefPtr<Gio::ListModel>
  {
    return m_model;
  }

  auto turn_order::n_participants() -> unsigned int
  {
    return m_model->get_n_items();
  }

  auto turn_order::remove(Glib::RefPtr<participant> item) -> void
  {
    if (auto [was_found, index] = m_model->find(item); was_found)
    {
      remove(index);
    }
  }

  auto turn_order::remove(unsigned int index) -> void
  {
    m_model->remove(index);
  }

  auto turn_order::remove_all() -> void
  {
    m_model->remove_all();
  }

  auto turn_order::start() -> void
  {
  }

  auto turn_order::get_empty() const noexcept -> bool
  {
    return m_empty;
  }

  auto turn_order::property_empty() const -> Glib::PropertyProxy_ReadOnly<bool>
  {
    return m_empty.get_proxy();
  }

}  // namespace turns::domain