#include "toonzqt/dvscrollwidget.h"

// TnzQt includes
#include "toonzqt/freelayout.h"

// Qt includes
#include <QLayout>
#include <QPushButton>
#include <QPropertyAnimation>
#include <QResizeEvent>
#include <QMouseEvent>
#include <QTimer>

// STD includes
#include <numeric>

//****************************************************************************
//    Local namespace stuff
//****************************************************************************

namespace {

class ScrollLayout : public DummyLayout {
  DvScrollWidget *m_scrollWidget;

public:
  ScrollLayout(DvScrollWidget *scrollWidget) : m_scrollWidget(scrollWidget) {
    assert(m_scrollWidget);
  }

  QSize minimumSize() const override {
    struct locals {
      inline static QSize expand(const QSize &size, const QLayoutItem *item) {
        return size.expandedTo(item->minimumSize());
      }
    };

    QSize minSize = std::accumulate(m_items.begin(), m_items.end(), QSize(),
                                    locals::expand);

    return (m_scrollWidget->getOrientation() == Qt::Horizontal)
               ? QSize(0, minSize.height())
               : QSize(minSize.width(), 0);
  }

  QSize maximumSize() const override {
    struct locals {
      inline static QSize bound(const QSize &size, const QLayoutItem *item) {
        return size.boundedTo(item->minimumSize());
      }
    };

    QSize maxSize =
        std::accumulate(m_items.begin(), m_items.end(),
                        QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX), locals::bound);

    return (m_scrollWidget->getOrientation() == Qt::Horizontal)
               ? QSize(QWIDGETSIZE_MAX, maxSize.height())
               : QSize(maxSize.width(), QWIDGETSIZE_MAX);
  }

  void setGeometry(const QRect &r) override {
    const Qt::Orientation orientation = m_scrollWidget->getOrientation();

    QList<QLayoutItem *>::const_iterator it, iEnd = m_items.end();
    for (it = m_items.begin(); it != iEnd; ++it) {
      QLayoutItem *item = *it;

      QSize targetSize = item->sizeHint();

      if (orientation & item->expandingDirections()) {
        if (orientation & Qt::Horizontal)
          targetSize.setWidth(r.width());
        else
          targetSize.setHeight(r.height());
      }

      const QSize &minSize = item->minimumSize(),
                  &maxSize = item->maximumSize();

      targetSize.setWidth(
          tcrop(targetSize.width(), minSize.width(), maxSize.width()));
      targetSize.setHeight(
          tcrop(targetSize.height(), minSize.height(), maxSize.height()));

      const QRect &geom = item->geometry();

      if (geom.size() != targetSize)
        item->setGeometry(QRect(geom.topLeft(), targetSize));
    }

    m_scrollWidget->scroll(0);  // Refresh scroll buttons visibility
  }
};

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

qreal heldScrollEasing(qreal progress) {
  // Equilibrate sum of Linear and InQuad
  return 0.5 * progress * (1.0 + progress);
}

}  // namespace

//****************************************************************************
//    DvScrollWidget implementation
//****************************************************************************

DvScrollWidget::DvScrollWidget(QWidget *parent, Qt::Orientation orientation)
    : QFrame(parent)
    , m_content(0)
    , m_animation(0)
    , m_clickEase(QEasingCurve::OutCubic)
    , m_holdEase(QEasingCurve::Linear)
    , m_backwardTimer(new QTimer(this))
    , m_forwardTimer(new QTimer(this))
    , m_pressed(false)
    , m_heldRelease(false)
    , m_heldClick(false) {
  ScrollLayout *scrollLayout = new ScrollLayout(this);
  setLayout(scrollLayout);

  // At the toolbar sides, add scroll buttons
  m_scrollBackward =
      new QPushButton(this);  // NOTE: Not being managed by the scroll layout.
  m_scrollBackward->setFixedSize(
      24, 24);  //       It's not necessary. They are not part
  m_scrollBackward->setFocusPolicy(Qt::NoFocus);  //       of the content.

  m_scrollForward =
      new QPushButton(this);  //       Observe that the parent widget must
  m_scrollForward->setFixedSize(24,
                                24);  //       therefore be explicitly supplied.
  m_scrollForward->setFocusPolicy(Qt::NoFocus);

  setOrientation(orientation);

  m_scrollBackward->move(0, 0);

  m_backwardTimer->setInterval(450);
  m_forwardTimer->setInterval(450);
  m_backwardTimer->setSingleShot(true);
  m_forwardTimer->setSingleShot(true);

  connect(m_scrollBackward, SIGNAL(clicked(bool)), this,
          SLOT(scrollBackward()));
  connect(m_scrollForward, SIGNAL(clicked(bool)), this, SLOT(scrollForward()));
  connect(m_backwardTimer, SIGNAL(timeout()), this, SLOT(holdBackward()));
  connect(m_forwardTimer, SIGNAL(timeout()), this, SLOT(holdForward()));

  connect(m_scrollBackward, SIGNAL(pressed()), m_backwardTimer, SLOT(start()));
  connect(m_scrollForward, SIGNAL(pressed()), m_forwardTimer, SLOT(start()));
  connect(m_scrollBackward, SIGNAL(released()), this, SLOT(releaseBackward()));
  connect(m_scrollForward, SIGNAL(released()), this, SLOT(releaseForward()));
}

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

void DvScrollWidget::setWidget(QWidget *widget) {
  // Delete currently set widget, if any
  QLayout *lay = layout();

  while (QLayoutItem *item = lay->takeAt(
             0))  // Should be 1 item only - while is just to be pedant
  {
    assert(item->widget());

    delete item->widget();  // The item DOES NOT own the widget.
    delete item;            // The parent widget (this) does - this
  }                         // is by Qt's manual.

  // Add widget
  lay->addWidget(widget);
  m_content = widget;
  m_content->lower();  // Needs to be below the scroll buttons.
                       // Seemingly not working on Mac (see showEvent).

  assert(widget->parent() == this);

  // Use animations to make scrolling 'smooth'
  delete m_animation;
  m_animation = new QPropertyAnimation(m_content, "pos");
  connect(m_animation, SIGNAL(stateChanged(QAbstractAnimation::State,
                                           QAbstractAnimation::State)),
          this, SLOT(updateButtonsVisibility()));
}

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

void DvScrollWidget::setOrientation(Qt::Orientation orientation) {
  if ((m_horizontal = (orientation == Qt::Horizontal))) {
    setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);

    m_scrollBackward->setObjectName("ScrollLeftButton");
    m_scrollForward->setObjectName("ScrollRightButton");
  } else {
    setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);

    m_scrollBackward->setObjectName("ScrollUpButton");
    m_scrollForward->setObjectName("ScrollDownButton");
  }
}

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

Qt::Orientation DvScrollWidget::getOrientation() const {
  return m_horizontal ? Qt::Horizontal : Qt::Vertical;
}

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

void DvScrollWidget::setEasing(QEasingCurve clickEase,
                               QEasingCurve holdPressEase) {
  m_clickEase = clickEase;
  m_holdEase  = holdPressEase;
}

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

void DvScrollWidget::scroll(int dx, int duration, QEasingCurve ease) {
  if (m_content)
    scrollTo(m_horizontal ? m_content->x() + dx : m_content->y() + dx, duration,
             ease);
}

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

void DvScrollWidget::scrollTo(int pos, int duration, QEasingCurve ease) {
  if (!m_content) return;

  // Retrieve the contents' bounds
  QRect bounds(m_content->pos(), m_content->size());

  QPoint newPos;
  if (m_horizontal) {
    newPos     = QPoint(pos, 0);
    int minPos = width() - bounds.width();

    if (newPos.x() <= minPos) newPos.setX(minPos);
    if (newPos.x() >= 0) newPos.setX(0);
  } else {
    newPos     = QPoint(0, pos);
    int minPos = height() - bounds.height();

    if (newPos.y() <= minPos) newPos.setY(minPos);
    if (newPos.y() >= 0) newPos.setY(0);
  }

  if (duration > 0) {
    m_animation->stop();
    m_animation->setEasingCurve(ease);
    m_animation->setStartValue(bounds.topLeft());
    m_animation->setEndValue(newPos);
    m_animation->setDuration(duration);
    m_animation->start();
  } else {
    m_content->move(newPos);
    updateButtonsVisibility();
  }
}

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

void DvScrollWidget::updateButtonsVisibility() {
  if ((!m_content) || (m_animation->state() == QPropertyAnimation::Running))
    return;

  QRect bounds(m_content->pos(), m_content->size());
  if (m_horizontal) {
    if (bounds.right() <= width()) {
      m_scrollForward->setDown(false);
      m_scrollForward->hide();
      m_heldRelease = m_heldClick = false;
    } else
      m_scrollForward->show();

    if (bounds.left() >= 0) {
      m_scrollBackward->setDown(false);
      m_scrollBackward->hide();
      m_heldRelease = m_heldClick = false;
    } else
      m_scrollBackward->show();
  } else {
    if (bounds.bottom() <= height()) {
      m_scrollForward->setDown(false);
      m_scrollForward->hide();
      m_heldRelease = m_heldClick = false;
    } else
      m_scrollForward->show();

    if (bounds.top() >= 0) {
      m_scrollBackward->setDown(false);
      m_scrollBackward->hide();
      m_heldRelease = m_heldClick = false;
    } else
      m_scrollBackward->show();
  }
}

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

void DvScrollWidget::showEvent(QShowEvent *se) {
  // These are necessary on Mac.
  m_scrollBackward->raise();
  m_scrollForward->raise();
}

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

void DvScrollWidget::resizeEvent(QResizeEvent *re) {
  QWidget::resizeEvent(re);
  scroll(0);
  if (m_horizontal) {
    m_scrollBackward->setFixedSize(m_scrollBackward->width(), height());
    m_scrollForward->setFixedSize(m_scrollForward->width(), height());
    m_scrollForward->move(re->size().width() - m_scrollForward->width(), 0);
  } else {
    m_scrollBackward->setFixedSize(width(), m_scrollBackward->height());
    m_scrollForward->setFixedSize(width(), m_scrollForward->height());
    m_scrollForward->move(0, re->size().height() - m_scrollForward->height());
  }
}

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

void DvScrollWidget::mousePressEvent(QMouseEvent *me) {
  m_pressed  = true;
  m_mousePos = m_horizontal ? me->x() : me->y();
  me->accept();
}

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

void DvScrollWidget::mouseMoveEvent(QMouseEvent *me) {
  if (!m_pressed) return;

  if (m_horizontal) {
    scroll(me->x() - m_mousePos);
    m_mousePos = me->x();
  } else {
    scroll(me->y() - m_mousePos);
    m_mousePos = me->y();
  }
  me->accept();
}

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

void DvScrollWidget::mouseReleaseEvent(QMouseEvent *me) {
  m_pressed = false;
  me->accept();
}

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

void DvScrollWidget::holdBackward() {
  if (!m_content) return;

  m_heldRelease = m_heldClick = true;

  QRect bounds(m_content->pos(), m_content->size());
  int spaceLeft = -(m_horizontal ? bounds.left() : bounds.top());

  QEasingCurve ease;
  ease.setCustomType(&heldScrollEasing);
  scrollTo(0, spaceLeft * 10, ease);  // 100 pix per second
}

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

void DvScrollWidget::holdForward() {
  if (!m_content) return;

  m_heldRelease = m_heldClick = true;

  QRect bounds(m_content->pos(), m_content->size());
  int pos =
      m_horizontal ? width() - bounds.width() : height() - bounds.height();
  int spaceLeft = (m_horizontal ? bounds.left() : bounds.top()) - pos;

  QEasingCurve ease;
  ease.setCustomType(&heldScrollEasing);
  scrollTo(pos, spaceLeft * 10, ease);  // 100 pix per second
}

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

void DvScrollWidget::releaseBackward() {
  m_backwardTimer->stop();

  if (m_heldRelease) m_animation->stop();

  m_heldRelease = false;
}

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

void DvScrollWidget::releaseForward() {
  m_forwardTimer->stop();

  if (m_heldRelease) m_animation->stop();

  m_heldRelease = false;
}

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

void DvScrollWidget::scrollBackward() {
  if (!m_heldClick) scroll(0.5 * (m_horizontal ? width() : height()), 300);

  m_heldClick = false;
}

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

void DvScrollWidget::scrollForward() {
  if (!m_heldClick) scroll(-0.5 * (m_horizontal ? width() : height()), 300);

  m_heldClick = false;
}