#include "multiverseitem.h"
#include "multiversemodel.h"
#include "uuid/uuid.h"
#include "qsacnnode.h"

#include <QMetaEnum>

/**
 * @brief MultiverseModel::MultiverseModel
 * @param parent
 * @param node
 */
MultiverseModel::MultiverseModel(QObject *parent, QSacnNode *node)
  : QAbstractItemModel(parent)
  , node_(node)
  , rootItem_(new MultiverseItem())
{
  QMetaEnum e = QMetaEnum::fromType<MultiverseModel::Catagory>();
  for (int k = 0; k < e.keyCount(); k++)
    {
      auto item = new MultiverseItem(rootItem_);
      item->setOverrideData(QString(e.key(k)));
      auto idx = MultiverseModel::index(k, 0, QModelIndex());
      categoryIndexes.insert(static_cast<MultiverseModel::Catagory>
                              (e.value(k)), idx);
    }

  connect(node, &QSacnNode::discoveryUpdates,
          this, &MultiverseModel::doDiscovery);
  connect(node, &QSacnNode::subscribing,
          this, &MultiverseModel::doSubscription);
  connect(node, &QSacnNode::creating,
          this, &MultiverseModel::doCreation);
}


/**
 * @brief MultiverseModel::~MultiverseModel
 */
MultiverseModel::~MultiverseModel()
{
  delete rootItem_;
}


/**
 * @brief MultiverseModel::root
 * @return
 */
MultiverseItem * MultiverseModel::root()
{
  return rootItem_;
}


/**
 * @brief MultiverseModel::getItem
 * @param index
 * @return
 */
MultiverseItem * MultiverseModel::getItem(const QModelIndex &index) const
{
  if (index.isValid())
    {
      auto item = static_cast<MultiverseItem*>(index.internalPointer());
      if (item)
          return item;
  }
  return rootItem_;
}


/**
 * @brief MultiverseModel::headerData
 * @param section
 * @param orientation
 * @param role
 * @return
 */
QVariant MultiverseModel::headerData(int section, Qt::Orientation orientation,
                                     int role) const
{
  if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
      switch (static_cast<Column>(section)) {
        case Universe:
          return tr("Universe");
        case Priority:
          return tr("Priority");
        case Channels:
          return tr("Channels");
        case Description:
          return tr("Description");
        }
    }
  return QVariant();
}


/**
 * @brief MultiverseModel::index
 * @param row
 * @param column
 * @param parent
 * @return
 */
QModelIndex MultiverseModel::index(int row, int column,
                                   const QModelIndex &parent) const
{
  if (parent.isValid() && parent.column() != 0)
    return QModelIndex();

  MultiverseItem *parentItem = getItem(parent);
  if (!parentItem)
    return QModelIndex();

  auto childItem = parentItem->child(row);
  if (childItem)
    return createIndex(row, column, childItem);

  return QModelIndex();
}


/**
 * @brief MultiverseModel::parent
 * @param index
 * @return
 */
QModelIndex MultiverseModel::parent(const QModelIndex &index) const
{
  if (!checkIndex(index, CheckIndexOption::IndexIsValid |
                         CheckIndexOption::DoNotUseParent))
    return QModelIndex();

  auto childItem = getItem(index);
  auto parentItem = childItem ? childItem->parentItem() : nullptr;

  if (parentItem == rootItem_ || !parentItem)
    return QModelIndex();

  return createIndex(parentItem->row(), 0, parentItem);
}


/**
 * @brief MultiverseModel::rowCount
 * @param parent
 * @return
 */
int MultiverseModel::rowCount(const QModelIndex &parent) const
{
  auto parentItem = getItem(parent);
  return parentItem ? parentItem->childCount() : 0;
}


/**
 * @brief MultiverseModel::columnCount
 * @param parent
 * @return
 */
int MultiverseModel::columnCount(const QModelIndex &parent) const
{
  Q_UNUSED(parent);
  return QMetaEnum::fromType<Column>().keyCount();
}


/**
 * @brief MultiverseModel::data
 * @param index
 * @param role
 * @return
 */
QVariant MultiverseModel::data(const QModelIndex &index, int role) const
{
  if (!checkIndex(index, CheckIndexOption::IndexIsValid))
    return QVariant();

  return getItem(index)->data(index.column(), role);
}


/**
 * @brief MultiverseModel::flags
 * @param index
 * @return
 */
Qt::ItemFlags MultiverseModel::flags(const QModelIndex &index) const
{
  if (!checkIndex(index, CheckIndexOption::IndexIsValid))
    return Qt::NoItemFlags;

  auto item = getItem(index);

  if (!item)
    return Qt::NoItemFlags;

  return item->flags(index.column(), QAbstractItemModel::flags(index));
}


/**
 * @brief MultiverseModel::insert
 * @param universe
 * @param parent
 * @return
 */
void MultiverseModel::insert(const QModelIndex &parent,
                             QSacnUniverse *universe,
                             discoveredUniverse *discovery)
{
  auto item = getItem(parent);
  beginInsertRows(parent, item->childCount(), item->childCount());
  auto child = new MultiverseItem(item, universe, discovery);
  auto index = QPersistentModelIndex(createIndex(item->childCount(), 0, child));
  connect(universe, &QSacnUniverse::changed,
          this, [this, index] () {
      auto begin = index.sibling(index.row(), 0);
      auto end = begin.siblingAtColumn(columnCount() - 1);
      emit dataChanged(begin, end);
    });
  endInsertRows();
}


void MultiverseModel::doDiscovery()
{
  auto parentIndex = categoryIndexes.value(MultiverseModel::Discovery);
  auto parent = static_cast<MultiverseItem*>(parentIndex.internalPointer());

  beginRemoveRows(parentIndex, 0, parent->childCount() - 1);
  parent->removeChildren();
  endRemoveRows();

  beginInsertRows(parentIndex, 0, node_->discovered.size() - 1);
  for (auto& discovery : node_->discovered)
    new MultiverseItem(parent, nullptr, discovery.get());
  endInsertRows();
}


/**
 * @brief MultiverseModel::doSubscription
 * @param universe
 */
void MultiverseModel::doSubscription(QSacnUniverse* universe)
{
  auto parentIndex = categoryIndexes.value(MultiverseModel::Receiver);
  insert(parentIndex, universe);
}

/**
 * @brief MultiverseModel::doCreation
 * @param universe
 */
void MultiverseModel::doCreation(QSacnUniverse* universe)
{
  auto parentIndex = categoryIndexes.value(MultiverseModel::Source);
  insert(parentIndex, universe);
}