#pragma once
#include "repository.hpp"
#include <QAbstractTableModel>
#include <QSortFilterProxyModel>

namespace orders {
class OrderModel final : public QAbstractTableModel {
  OrderService &service_;
  std::vector<Order> values_;
  QString lastError_;

public:
  enum Role { Id = Qt::UserRole + 1, Priority, Open };
  explicit OrderModel(OrderService &service, QObject *parent = nullptr)
      : QAbstractTableModel(parent), service_(service) {}
  int rowCount(const QModelIndex &parent = {}) const override {
    return parent.isValid() ? 0 : int(values_.size());
  }
  int columnCount(const QModelIndex &parent = {}) const override {
    return parent.isValid() ? 0 : 4;
  }
  QVariant data(const QModelIndex &index,
                int role = Qt::DisplayRole) const override {
    if (!index.isValid() || index.row() < 0 || index.row() >= rowCount() ||
        index.column() < 0 || index.column() >= 4)
      return {};
    const auto &order = values_[std::size_t(index.row())];
    if (role == Id)
      return order.id;
    if (role == Priority)
      return order.priority;
    if (role == Open)
      return order.status == Status::open;
    if (role != Qt::DisplayRole && role != Qt::EditRole)
      return {};
    switch (index.column()) {
    case 0:
      return order.id;
    case 1:
      return QString::fromStdString(order.title);
    case 2:
      return order.priority;
    case 3:
      return order.status == Status::open ? "open" : "done";
    }
    return {};
  }
  QVariant headerData(int section, Qt::Orientation orientation,
                      int role) const override {
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole &&
        section >= 0 && section < 4)
      return QStringList{"ID", "Title", "Priority", "Status"}.at(section);
    return QAbstractTableModel::headerData(section, orientation, role);
  }
  Qt::ItemFlags flags(const QModelIndex &index) const override {
    if (!index.isValid())
      return Qt::NoItemFlags;
    auto result = QAbstractTableModel::flags(index);
    if (index.column() == 1)
      result |= Qt::ItemIsEditable;
    return result;
  }
  bool setData(const QModelIndex &index, const QVariant &value,
               int role) override {
    if (role != Qt::EditRole || !index.isValid() || index.column() != 1 ||
        index.row() < 0 || index.row() >= rowCount())
      return false;
    auto candidate = values_[std::size_t(index.row())];
    candidate.title = value.toString().toStdString();
    auto saved = service_.save(candidate);
    if (!succeeded(saved)) {
      lastError_ = QString::fromStdString(std::get<Error>(saved).message);
      return false;
    }
    values_[std::size_t(index.row())] = std::move(candidate);
    lastError_.clear();
    emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
    return true;
  }
  Result<Done> refresh() {
    auto loaded = service_.list();
    if (!succeeded(loaded))
      return std::get<Error>(loaded);
    auto batch = std::get<std::vector<Order>>(std::move(loaded));
    beginResetModel();
    values_.swap(batch);
    endResetModel();
    return Done{};
  }
  QString lastError() const { return lastError_; }
};
class OpenFilter : public QSortFilterProxyModel {
  bool onlyOpen_{false};

protected:
  bool filterAcceptsRow(int row, const QModelIndex &parent) const override {
    return QSortFilterProxyModel::filterAcceptsRow(row, parent) &&
           (!onlyOpen_ || sourceModel()
                              ->index(row, 0, parent)
                              .data(OrderModel::Open)
                              .toBool());
  }

public:
  explicit OpenFilter(QObject *parent = nullptr)
      : QSortFilterProxyModel(parent) {
    setFilterKeyColumn(1);
    setFilterCaseSensitivity(Qt::CaseInsensitive);
  }
  void setOnlyOpen(bool value) {
    onlyOpen_ = value;
    invalidateFilter();
  }
};
} // namespace orders
