#include "radixwidgets/navigationmodel.hh"
#include "radixwidgets/navigationitem.hh"

#include "radixbug/bug.hh"

#include <QList>

namespace radix
{
class NavigationModel::PImpl
{
 public:
  NavigationItem* root = nullptr;

  ~PImpl();
};

NavigationModel::PImpl::~PImpl()
{
  if (root) delete root;
}
NavigationModel::NavigationModel(QObject* parent)
    : QAbstractItemModel(parent)
    , p(new PImpl(), [](PImpl* impl) { delete impl; })
{
  radix_tagged_line("Navigation Model");
  p->root = new NavigationItem();
  p->root->addChild(new NavigationItem("Hello", p->root));
  NavigationItem* world = new NavigationItem("World", p->root);
  p->root->addChild(world);
  NavigationItem* child = new NavigationItem("My name is edward", world);
  world->addChild(child);
}

QVariant NavigationModel::data(const QModelIndex& index, int role) const
{
  radix_tagged_line("data(" << index.row() << ", " << index.column() << ")");
  if (!index.isValid()) return QVariant();

  if (role != Qt::DisplayRole) return QVariant();

  NavigationItem* item = static_cast<NavigationItem*>(index.internalPointer());

  return item->data(index.column());
}

bool NavigationModel::setData(const QModelIndex& index, const QVariant& value,
                              int role)
{
  return false;
}

Qt::ItemFlags NavigationModel::flags(const QModelIndex& index) const
{
  if (!index.isValid()) return QAbstractItemModel::flags(index);

  return QAbstractItemModel::flags(index);
}

QVariant NavigationModel::headerData(int section, Qt::Orientation orientation,
                                     int role) const
{
  if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
    return p->root->data(section);

  return QVariant();
}

QModelIndex NavigationModel::index(int row, int column,
                                   const QModelIndex& parent) const
{
  radix_tagged_line("index(" << row << "," << column << ")");
  if (!hasIndex(row, column, parent)) return QModelIndex();

  NavigationItem* parentItem;

  if (!parent.isValid())
    parentItem = p->root;
  else
    parentItem = static_cast<NavigationItem*>(parent.internalPointer());

  NavigationItem* childItem = parentItem->child(row);
  if (childItem)
    return createIndex(row, column, childItem);
  else
    return QModelIndex();
}

QModelIndex NavigationModel::parent(const QModelIndex& index) const
{
  radix_tagged_line("parent(" << index.row() << "," << index.column() << ")");
  if (!index.isValid()) return QModelIndex();

  NavigationItem* childItem =
      static_cast<NavigationItem*>(index.internalPointer());
  NavigationItem* parentItem = childItem->parentItem();

  if (parentItem == p->root) return QModelIndex();

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

int NavigationModel::rowCount(const QModelIndex& parent) const
{
  radix_tagged_line("rowCount(" << parent.row() << "," << parent.column()
                                << ")");
  NavigationItem* parentItem;
  if (parent.column() > 0) return 0;

  if (!parent.isValid())
    parentItem = p->root;
  else
    parentItem = static_cast<NavigationItem*>(parent.internalPointer());

  return parentItem->childCount();
}

int NavigationModel::columnCount(const QModelIndex& parent) const
{
  radix_tagged_line("columnCount(" << parent.row() << "," << parent.column()
                                   << ")");
  if (parent.isValid())
    return static_cast<NavigationItem*>(parent.internalPointer())
        ->columnCount();
  else
    return p->root->columnCount();
}

}  // namespace radix