#include "autoinputcellnumberpopup.h"

// Tnz includes
#include "tapp.h"
#include "menubarcommandids.h"
#include "cellselection.h"
#include "columnselection.h"

#if defined(x64)
#include "penciltestpopup.h"
#else
#include "penciltestpopup_qt.h"
#endif

// TnzQt includes
#include "toonzqt/intfield.h"
#include "toonzqt/tselectionhandle.h"
#include "toonzqt/selection.h"
#include "toonzqt/dvdialog.h"

// TnzLib includes
#include "toonz/txsheethandle.h"
#include "toonz/txshcell.h"
#include "toonz/txshsimplelevel.h"
#include "toonz/txshchildlevel.h"
#include "toonz/preferences.h"

#include "tundo.h"
#include "historytypes.h"

#include <QMainWindow>
#include <QGridLayout>
#include <QLabel>
#include <QPushButton>

#include <iostream>

namespace {
class AutoInputCellNumberUndo final : public TUndo {
  int m_increment, m_interval, m_step, m_repeat;
  int m_from, m_to;
  int m_r0, m_r1;
  bool m_isOverwrite;
  std::vector<int> m_columnIndices;
  std::vector<TXshLevelP> m_levels;

  int m_rowsCount;
  std::unique_ptr<TXshCell[]> m_beforeCells;

public:
  AutoInputCellNumberUndo(int increment, int interval, int step, int repeat,
                          int from, int to, int r0, int r1, bool isOverwrite,
                          std::vector<int> columnIndices,
                          std::vector<TXshLevelP> levels);

  ~AutoInputCellNumberUndo() {}

  void undo() const override;
  void redo() const override;
  int getSize() const override { return sizeof(*this); }

  QString getHistoryString() override {
    return QObject::tr("Auto Input Cell Numbers : %1")
        .arg((m_isOverwrite) ? QObject::tr("Overwrite")
                             : QObject::tr("Insert"));
  }
  int getHistoryType() override { return HistoryType::Xsheet; }

  int rowsCount() { return m_rowsCount; }
};
};  // namespace

//-----------------------------------------------------------------------------
// executing this on column selection, set r1 = -1.
// Here are the expected behaviors
// 1. Cell Selection + Overwrite
//    Cells will be input from the top of the selected range.
//    New arrangement CANNOT run over the selected range.
//    If the new arrangement is shorter than the selected range,
//    excess cells will not be cleared but keep their contents.
//    (It is the same behavior as Celsys' QuickChecker)
// 2. Cell Selection + Insert
//    New arrangement will be inserted before the selected range.
//    If the selected range has multiple columns, then the inserted
//    cells will be expanded to the longest arrangement with empty cells.
// 3. Column Selection + Overwrite
//    Cells will be input from the top of the columns.
//    New arrangement CAN run over the existing column range.
//    If the new arrangement is shorter than the selected range,
//    excess cells will not be cleared but keep their contents.
// 4. Column Selection + Insert
//    New arrangement will be inserted at the top of the columns.
//    If multiple columns are selected, then the inserted cells
//    will be expanded to the longest arrangement with empty cells.
//

AutoInputCellNumberUndo::AutoInputCellNumberUndo(int increment, int interval,
                                                 int step, int repeat, int from,
                                                 int to, int r0, int r1,
                                                 bool isOverwrite,
                                                 std::vector<int> columnIndices,
                                                 std::vector<TXshLevelP> levels)
    : m_increment(increment)
    , m_interval(interval)
    , m_step(step)
    , m_repeat(repeat)
    , m_from(from)
    , m_to(to)
    , m_r0(r0)
    , m_r1(r1)
    , m_isOverwrite(isOverwrite)
    , m_columnIndices(columnIndices)
    , m_levels(levels) {
  if (Preferences::instance()->isShowFrameNumberWithLettersEnabled())
    m_increment *= 10;

  int maxInputFrameAmount = 0;
  int frameRangeMin       = std::min(m_from, m_to);
  int frameRangeMax       = std::max(m_from, m_to);

  if (m_increment == 0) {
    // obtain the maximum frame amount to be input
    for (int lv = 0; lv < m_levels.size(); lv++) {
      TXshLevelP level = m_levels.at(lv);
      std::vector<TFrameId> fids;
      level->getFids(fids);
      int fCount = 0;
      for (auto itr = fids.begin(); itr != fids.end(); ++itr) {
        if ((*itr).getNumber() >= frameRangeMin &&
            (*itr).getNumber() <= frameRangeMax) {
          fCount++;
        } else if ((*itr).getNumber() > frameRangeMax)
          break;
      }
      if (maxInputFrameAmount < fCount) maxInputFrameAmount = fCount;
    }
  } else
    maxInputFrameAmount = (int)std::ceil(
        (float)(frameRangeMax - frameRangeMin + 1) / (float)m_increment);

  maxInputFrameAmount *= m_repeat;

  // compute maximum row amount to be arranged
  if (maxInputFrameAmount == 0) {
    m_rowsCount = 0;
    return;
  } else
    m_rowsCount =
        maxInputFrameAmount * m_step + (maxInputFrameAmount - 1) * m_interval;

  // on overwrite case, keep existing cells for undo
  if (m_isOverwrite) {
    int rowUpTo =
        (m_r1 == -1) ? m_rowsCount - 1 : std::min(m_r1, m_r0 + m_rowsCount - 1);
    m_beforeCells.reset(
        new TXshCell[m_columnIndices.size() * (rowUpTo - m_r0 + 1)]);
    int k = 0;
    for (int c = 0; c < m_columnIndices.size(); ++c) {
      for (int r = m_r0; r <= rowUpTo; ++r)
        m_beforeCells[k++] =
            TApp::instance()->getCurrentXsheet()->getXsheet()->getCell(
                r, m_columnIndices.at(c));
    }
  }
}

void AutoInputCellNumberUndo::undo() const {
  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();
  // on overwrite case, retrieve cells
  if (m_isOverwrite) {
    int rowUpTo =
        (m_r1 == -1) ? m_rowsCount - 1 : std::min(m_r1, m_r0 + m_rowsCount - 1);
    int k = 0;
    for (int c = 0; c < m_columnIndices.size(); ++c) {
      for (int r = m_r0; r <= rowUpTo; ++r) {
        if (m_beforeCells[k].isEmpty())
          xsh->clearCells(r, m_columnIndices.at(c));
        else
          xsh->setCell(r, m_columnIndices.at(c), m_beforeCells[k]);
        k++;
      }
    }
  } else {  // on insert case, remove inserted cells
    for (int c = 0; c < m_columnIndices.size(); ++c)
      xsh->removeCells(m_r0, m_columnIndices.at(c), m_rowsCount);
  }
  TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
}

void AutoInputCellNumberUndo::redo() const {
  TApp::instance()->getCurrentXsheet()->getXsheet()->autoInputCellNumbers(
      m_increment, m_interval, m_step, m_repeat, m_from, m_to, m_r0, m_r1,
      m_isOverwrite, m_columnIndices, m_levels, m_rowsCount);
  TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
}

//=============================================================================

AutoInputCellNumberPopup::AutoInputCellNumberPopup()
    : Dialog(TApp::instance()->getMainWindow(), false, true,
             "AutoInputCellNumberPopup") {
  setWindowTitle(tr("Auto Input Cell Number"));

  m_from      = new FrameNumberLineEdit(this, TFrameId(1), false);
  m_increment = new DVGui::IntLineEdit(this, 0, 0);
  m_to        = new FrameNumberLineEdit(this, TFrameId(1), false);
  m_interval  = new DVGui::IntLineEdit(this, 0, 0);
  m_step      = new DVGui::IntLineEdit(this, 1, 1);
  m_repeat    = new DVGui::IntLineEdit(this, 1, 1);

  m_overwriteBtn         = new QPushButton(tr("Overwrite"), this);
  m_insertBtn            = new QPushButton(tr("Insert"), this);
  QPushButton *cancelBtn = new QPushButton(tr("Cancel"), this);

  m_increment->setToolTip(
      tr("Setting this value 0 will automatically \npick up all frames in the "
         "selected level."));

  // layout

  QGridLayout *mainLay = new QGridLayout();
  mainLay->setHorizontalSpacing(5);
  mainLay->setVerticalSpacing(10);
  {
    mainLay->addWidget(new QLabel(tr("From frame"), this), 0, 0,
                       Qt::AlignRight | Qt::AlignVCenter);
    mainLay->addWidget(m_from, 0, 1);
    mainLay->addWidget(new QLabel(tr(" ", "from frame"), this), 0, 2, 1, 2);

    mainLay->addWidget(new QLabel(tr("with"), this), 1, 0, 1, 2,
                       Qt::AlignRight | Qt::AlignVCenter);
    mainLay->addWidget(m_increment, 1, 2);
    mainLay->addWidget(new QLabel(tr("frames increment"), this), 1, 3);

    mainLay->addWidget(new QLabel(tr("To frame"), this), 2, 0,
                       Qt::AlignRight | Qt::AlignVCenter);
    mainLay->addWidget(m_to, 2, 1);
    mainLay->addWidget(new QLabel(tr(" ", "to frame"), this), 2, 2, 1, 2);

    mainLay->addWidget(new QLabel(tr("inserting"), this), 3, 0, 1, 2,
                       Qt::AlignRight | Qt::AlignVCenter);
    mainLay->addWidget(m_interval, 3, 2);
    mainLay->addWidget(new QLabel(tr("empty cell intervals"), this), 3, 3);

    mainLay->addWidget(new QLabel(tr("with"), this), 4, 0,
                       Qt::AlignRight | Qt::AlignVCenter);
    mainLay->addWidget(m_step, 4, 1);
    mainLay->addWidget(new QLabel(tr("cell steps"), this), 4, 2, 1, 2);

    mainLay->addWidget(new QLabel(tr("Repeat"), this), 5, 0,
                       Qt::AlignRight | Qt::AlignVCenter);
    mainLay->addWidget(m_repeat, 5, 1);
    mainLay->addWidget(new QLabel(tr("times"), this), 5, 2, 1, 2);
  }
  m_topLayout->addLayout(mainLay);

  m_buttonFrame = new QFrame(this);
  m_buttonFrame->setObjectName("dialogButtonFrame");
  m_buttonFrame->setFrameStyle(QFrame::StyledPanel);
  m_buttonFrame->setFixedHeight(45);

  m_buttonLayout = new QHBoxLayout;
  m_buttonLayout->setContentsMargins(0, 0, 0, 0);
  m_buttonLayout->setSpacing(20);
  m_buttonLayout->setAlignment(Qt::AlignHCenter);
  {
    m_buttonLayout->addSpacing(20);
    m_buttonLayout->addWidget(m_overwriteBtn, 0);
    m_buttonLayout->addWidget(m_insertBtn, 0);
    m_buttonLayout->addWidget(cancelBtn, 0);
    m_buttonLayout->addSpacing(20);
  }
  m_buttonFrame->setLayout(m_buttonLayout);
  layout()->addWidget(m_buttonFrame);

  // signal-slot connections
  bool ret = true;
  ret      = ret && connect(m_overwriteBtn, SIGNAL(clicked()), this,
                       SLOT(onOverwritePressed()));
  ret      = ret &&
        connect(m_insertBtn, SIGNAL(clicked()), this, SLOT(onInsertPressed()));
  ret = ret && connect(cancelBtn, SIGNAL(clicked()), this, SLOT(close()));
  assert(ret);
}

//-----------------------------------------------------------------------------

void AutoInputCellNumberPopup::onOverwritePressed() { doExecute(true); }

//-----------------------------------------------------------------------------

void AutoInputCellNumberPopup::onInsertPressed() { doExecute(false); }

//-----------------------------------------------------------------------------

void AutoInputCellNumberPopup::doExecute(bool overwrite) {
  std::vector<int> columnIndices;
  std::vector<TXshLevelP> levels;
  int r0, r1;
  bool found = getTarget(columnIndices, levels, r0, r1);
  // just in case the execution is done to empty column
  if (!found) {
    DVGui::MsgBox(DVGui::WARNING,
                  tr("No available cells or columns are selected."));
    return;
  }
  AutoInputCellNumberUndo *undo = new AutoInputCellNumberUndo(
      m_increment->getValue(), m_interval->getValue(), m_step->getValue(),
      m_repeat->getValue(), m_from->getValue().getNumber(),
      m_to->getValue().getNumber(), r0, r1, overwrite, columnIndices, levels);
  // if no cells will be arranged, then return
  if (undo->rowsCount() == 0) {
    DVGui::MsgBox(DVGui::WARNING,
                  tr("Selected level has no frames between From and To."));
    delete undo;
    return;
  }
  undo->redo();
  TUndoManager::manager()->add(undo);
  // on cell selection & insert case, select the inserted cell range
  if (!overwrite && r1 != -1) {
    TSelection *selection =
        TApp::instance()->getCurrentSelection()->getSelection();
    if (!selection) return;
    TCellSelection *cellSelection = dynamic_cast<TCellSelection *>(selection);
    if (!cellSelection) return;
    int c0, c1;
    cellSelection->getSelectedCells(r0, c0, r1, c1);
    cellSelection->selectCells(r0, c0, r0 + undo->rowsCount() - 1, c1);
    TApp::instance()->getCurrentSelection()->notifySelectionChanged();
  }
  // If execution is properly completed, then close this popup
  close();
}

//-----------------------------------------------------------------------------

void AutoInputCellNumberPopup::onSelectionChanged() {
  // enable buttons only if they will work
  m_overwriteBtn->setEnabled(false);
  m_insertBtn->setEnabled(false);

  std::vector<int> columnIndices;
  std::vector<TXshLevelP> levels;
  int r0, r1;
  bool found = getTarget(columnIndices, levels, r0, r1, true);

  // if no reference level is found, return
  if (!found) return;

  int from, to;
  std::vector<TFrameId> fids;
  levels.front()->getFids(fids);
  from = fids.front().getNumber();
  to   = fids.back().getNumber();

  m_from->setValue(from);
  m_to->setValue(to);

  // enable buttons
  m_overwriteBtn->setEnabled(true);
  m_insertBtn->setEnabled(true);
}

//-----------------------------------------------------------------------------

void AutoInputCellNumberPopup::showEvent(QShowEvent *) {
  bool ret = connect(TApp::instance()->getCurrentSelection(),
                     SIGNAL(selectionChanged(TSelection *)), this,
                     SLOT(onSelectionChanged()));
  assert(ret);
  onSelectionChanged();
}

//-----------------------------------------------------------------------------

void AutoInputCellNumberPopup::hideEvent(QHideEvent *) {
  bool ret = disconnect(TApp::instance()->getCurrentSelection(),
                        SIGNAL(selectionChanged(TSelection *)), this,
                        SLOT(onSelectionChanged()));
  assert(ret);
}

//-----------------------------------------------------------------------------

bool AutoInputCellNumberPopup::getTarget(std::vector<int> &columnIndices,
                                         std::vector<TXshLevelP> &levels,
                                         int &r0, int &r1, bool forCheck) {
  TSelection *selection =
      TApp::instance()->getCurrentSelection()->getSelection();
  if (!selection) return false;

  // something must be selected
  if (selection->isEmpty()) return false;

  // selection must be cells or columns
  TCellSelection *cellSelection = dynamic_cast<TCellSelection *>(selection);
  TColumnSelection *columnSelection =
      dynamic_cast<TColumnSelection *>(selection);
  if (!cellSelection && !columnSelection) return false;

  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();
  // TXshLevelP refLevel;

  if (cellSelection) {
    // if cells are selected, selected range must contain at least one available
    // level
    int c0, c1;
    cellSelection->getSelectedCells(r0, c0, r1, c1);
    for (int col = c0; col <= c1; col++) {
      // column should not be empty or locked
      if (xsh->isColumnEmpty(col)) continue;
      TXshColumn *column = xsh->getColumn(col);
      if (column->isLocked()) continue;
      // column type should be "level"
      if (column->getColumnType() != TXshColumn::eLevelType) continue;
      // try to find the topmost available level in the column
      for (int row = r0; row <= r1; row++) {
        TXshCell cell = xsh->getCell(row, col);
        if (cell.isEmpty()) continue;
        TXshSimpleLevel *simpleLevel = cell.getSimpleLevel();
        TXshChildLevel *childLevel   = cell.getChildLevel();
        if (!simpleLevel && !childLevel) continue;
        if (simpleLevel) {
          TFrameId fid = simpleLevel->getFirstFid();
          // the level should not be single-framed
          if (fid.getNumber() == TFrameId::EMPTY_FRAME ||
              fid.getNumber() == TFrameId::NO_FRAME)
            continue;
        }
        levels.push_back(cell.m_level);
        columnIndices.push_back(col);
        break;
      }
      // if some level found, break the loop for check
      if (forCheck && !levels.empty()) break;
    }
  }

  else {  // columnSelection case
    r0                    = 0;
    r1                    = -1;
    std::set<int> indices = columnSelection->getIndices();
    // try to find the leftmost available column
    for (auto id = indices.begin(); id != indices.end(); ++id) {
      TXshColumn *column = xsh->getColumn(*id);
      if (!column) continue;
      if (column->isEmpty() || column->isLocked()) continue;
      // column type should be "level"
      if (column->getColumnType() != TXshColumn::eLevelType) continue;
      // try to find the topmost available level in the column
      TXshCellColumn *xshColumn = column->getCellColumn();
      if (!xshColumn) continue;
      int tmpR0, tmpR1;
      column->getRange(tmpR0, tmpR1);
      for (int row = tmpR0; row <= tmpR1; row++) {
        TXshCell cell = xshColumn->getCell(row);
        if (cell.isEmpty()) continue;
        TXshSimpleLevel *simpleLevel = cell.getSimpleLevel();
        TXshChildLevel *childLevel   = cell.getChildLevel();
        if (!simpleLevel && !childLevel) continue;
        if (simpleLevel) {
          TFrameId fid = simpleLevel->getFirstFid();
          // the level should not be single-framed
          if (fid.getNumber() == TFrameId::EMPTY_FRAME ||
              fid.getNumber() == TFrameId::NO_FRAME)
            continue;
        }
        levels.push_back(cell.m_level);
        columnIndices.push_back(*id);
        break;
      }
      // if some level found, break the loop for check
      if (forCheck && !levels.empty()) break;
    }
  }

  return !levels.empty();
}

//-----------------------------------------------------------------------------

OpenPopupCommandHandler<AutoInputCellNumberPopup> openAutoInputCellNumberPopup(
    MI_AutoInputCellNumber);
