#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 QString(tr("Universe"));
        case Priority:
          return QString(tr("Priority"));
        case Description:
          return QString(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() + 1);
  new MultiverseItem(item, universe, discovery);
  endInsertRows();
}


void MultiverseModel::doDiscovery()
{
  return;
}


/**
 * @brief MultiverseModel::doDiscovered
 * @param discovery
 */
void MultiverseModel::doDiscovered(sACN::EXTENDED::DISCOVERY::discoveredUniverse * discovery)
{
  auto parentIndex = categoryIndexes.value(MultiverseModel::Discovery);
  insert(parentIndex, nullptr, discovery);
}


/**
 * @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);
}