#include "universemodel.h"

#include <QBrush>
#include <QFont>
#include <QChar>
#include <QMetaEnum>

/**
 * @brief UniverseModel::UniverseModel
 * @param parent
 * @param universe
 */
UniverseModel::UniverseModel(QObject *parent, std::shared_ptr<DMX::Universe> universe)
    : QAbstractTableModel(parent)
    , universe_(universe)
    , data_mode_(Decimal)
{
  if (!universe_)
    return;

  data_change_token = universe_->onDataChange([this] (DMX::Universe*) {
      emit dataChanged(createIndex(0,0), createIndex(rowCount(), columnCount()));
  });
}


/**
 * @brief UniverseModel::headerData
 * @param section
 * @param orientation
 * @param role
 * @return
 */
QVariant UniverseModel::headerData(int section, Qt::Orientation orientation, int role) const
{
  switch (role)
    {
    case Qt::DisplayRole:
      switch (orientation)
        {
        case Qt::Horizontal:
          return section + 1;
        case Qt::Vertical:
          return section * 10;
        }
    default:
      return QVariant();
    }
}


/**
 * @brief UniverseModel::rowCount
 * @param parent
 * @return
 */
int UniverseModel::rowCount(const QModelIndex &parent) const
{
  if (parent.isValid())
    return 0;

  return 52;
}


/**
 * @brief UniverseModel::columnCount
 * @param parent
 * @return
 */
int UniverseModel::columnCount(const QModelIndex &parent) const
{
  if (parent.isValid())
    return 0;

  return 10;
}


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

  if (!universe_)
    return QVariant();

  uint16_t slot = (index.row() * 10) + (index.column() + 1);

  switch (role) {
    case Qt::DisplayRole:
      {
        if (slot == 0 || slot > 512)
          return QVariant();
        switch (data_mode_)
          {
          case Decimal:
            return universe_->slot(slot);
          case Hex:
            return QString("%1")
                .arg(universe_->slot(slot), 2, 16, QChar('0'))
                .toUpper();
          case Percent:
            return QString("%1%").arg((universe_->slot(slot) / 255.0F) * 100,
                                      0, 'f', 0, '0');
          }
        return QVariant();
      }
    case Qt::FontRole:
      return QFont("monospace");
    case Qt::TextAlignmentRole:
      return int(Qt::AlignCenter | Qt::AlignVCenter);
    case Qt::ForegroundRole:
      {
        if (slot > universe_->activeSlots() - 1)
          return QBrush(Qt::gray);
        return QVariant();
      }
    default:
      return QVariant();
    }
}


/**
 * @brief UniverseModel::setData
 * @param index
 * @param value
 * @param role
 * @return
 */
bool UniverseModel::setData(const QModelIndex &index, const QVariant &value,
                            int role)
{
  if (!universe_->isEditable())
    return false;

  if (data(index, role) == value)
    return false;

  uint16_t slot = (index.row() * 10) + (index.column() + 1);

  uint data;
  bool ok;
  switch (data_mode_)
    {
    case Decimal:
      data = value.toUInt(&ok);
      break;
    case Hex:
      data = value.toString().toUInt(&ok, 16);
      break;
    case Percent:
      data = 255 * (value.toDouble(&ok) / 100);
      break;
    }
  if (!ok || data > 255)
    return false;

  universe_->setValue(slot, data);
  emit dataChanged(index, index, QVector<int>() << role);
  return true;
}


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

  if (!universe_)
    return Qt::NoItemFlags;

  uint16_t slot = (index.row() * 10) + (index.column() + 1);

  if (slot == 0 || slot > 512)
    return Qt::NoItemFlags;

  auto f = QAbstractItemModel::flags(index);
  return universe_->isEditable() ? f | Qt::ItemIsEditable : f;
}


/**
 * @brief UniverseModel::setDataMode
 * @param mode
 */
void UniverseModel::setDataMode(const UniverseModel::data_modes mode)
{
   data_mode_ = mode;
   emit dataChanged(index(0,0), index(rowCount(), columnCount()));
}


/**
 * @brief UniverseModel::dataMode
 * @return
 */
UniverseModel::data_modes UniverseModel::dataMode()
{
  return data_mode_;
}