#include "toonzqt/dvscrollwidget.h"

// TnzQt includes

#include "toonzqt/freelayout.h"

// Qt includes

#include <qlayout></qlayout>

#include <qpushbutton></qpushbutton>

#include <qpropertyanimation></qpropertyanimation>

#include <qresizeevent></qresizeevent>

#include <qmouseevent></qmouseevent>

#include <qtimer></qtimer>

// STD includes

#include <numeric></numeric>

//****************************************************************************

//    Local namespace stuff

//****************************************************************************

namespace {

class ScrollLayout final : 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();</qlayoutitem>

    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;

}