#include <QEventTransition>
#include <QFontDatabase>
#include <QIcon>
#include <QMouseEvent>
#include <QPainterPath>
#include <QResizeEvent>
#include <QSignalTransition>

#include "FlatButton.h"
#include "Ripple.h"
#include "RippleOverlay.h"
#include "ThemeManager.h"

void
FlatButton::init()
{
        ripple_overlay_          = new RippleOverlay(this);
        state_machine_           = new FlatButtonStateMachine(this);
        role_                    = ui::Role::Default;
        ripple_style_            = ui::RippleStyle::PositionedRipple;
        icon_placement_          = ui::ButtonIconPlacement::LeftIcon;
        overlay_style_           = ui::OverlayStyle::GrayOverlay;
        bg_mode_                 = Qt::TransparentMode;
        fixed_ripple_radius_     = 64;
        corner_radius_           = 3;
        base_opacity_            = 0.13;
        font_size_               = 10; // 10.5;
        use_fixed_ripple_radius_ = false;

        setStyle(&ThemeManager::instance());
        setAttribute(Qt::WA_Hover);
        setMouseTracking(true);
        setCursor(QCursor(Qt::PointingHandCursor));

        QPainterPath path;
        path.addRoundedRect(rect(), corner_radius_, corner_radius_);

        ripple_overlay_->setClipPath(path);
        ripple_overlay_->setClipping(true);

        state_machine_->setupProperties();
        state_machine_->startAnimations();
}

FlatButton::FlatButton(QWidget *parent, ui::ButtonPreset preset)
  : QPushButton(parent)
{
        init();
        applyPreset(preset);
}

FlatButton::FlatButton(const QString &text, QWidget *parent, ui::ButtonPreset preset)
  : QPushButton(text, parent)
{
        init();
        applyPreset(preset);
}

FlatButton::FlatButton(const QString &text, ui::Role role, QWidget *parent, ui::ButtonPreset preset)
  : QPushButton(text, parent)
{
        init();
        applyPreset(preset);
        setRole(role);
}

FlatButton::~FlatButton()
{
}

void
FlatButton::applyPreset(ui::ButtonPreset preset)
{
        switch (preset) {
        case ui::ButtonPreset::FlatPreset:
                setOverlayStyle(ui::OverlayStyle::NoOverlay);
                break;
        case ui::ButtonPreset::CheckablePreset:
                setOverlayStyle(ui::OverlayStyle::NoOverlay);
                setCheckable(true);
                break;
        default:
                break;
        }
}

void
FlatButton::setRole(ui::Role role)
{
        role_ = role;
        state_machine_->setupProperties();
}

ui::Role
FlatButton::role() const
{
        return role_;
}

void
FlatButton::setForegroundColor(const QColor &color)
{
        foreground_color_ = color;
}

QColor
FlatButton::foregroundColor() const
{
        if (!foreground_color_.isValid()) {
                if (bg_mode_ == Qt::OpaqueMode) {
                        return ThemeManager::instance().themeColor("BrightWhite");
                }

                switch (role_) {
                case ui::Role::Primary:
                        return ThemeManager::instance().themeColor("Blue");
                case ui::Role::Secondary:
                        return ThemeManager::instance().themeColor("Gray");
                case ui::Role::Default:
                default:
                        return ThemeManager::instance().themeColor("Black");
                }
        }

        return foreground_color_;
}

void
FlatButton::setBackgroundColor(const QColor &color)
{
        background_color_ = color;
}

QColor
FlatButton::backgroundColor() const
{
        if (!background_color_.isValid()) {
                switch (role_) {
                case ui::Role::Primary:
                        return ThemeManager::instance().themeColor("Blue");
                case ui::Role::Secondary:
                        return ThemeManager::instance().themeColor("Gray");
                case ui::Role::Default:
                default:
                        return ThemeManager::instance().themeColor("Black");
                }
        }

        return background_color_;
}

void
FlatButton::setOverlayColor(const QColor &color)
{
        overlay_color_ = color;
        setOverlayStyle(ui::OverlayStyle::TintedOverlay);
}

QColor
FlatButton::overlayColor() const
{
        if (!overlay_color_.isValid()) {
                return foregroundColor();
        }

        return overlay_color_;
}

void
FlatButton::setDisabledForegroundColor(const QColor &color)
{
        disabled_color_ = color;
}

QColor
FlatButton::disabledForegroundColor() const
{
        if (!disabled_color_.isValid()) {
                return ThemeManager::instance().themeColor("FadedWhite");
        }

        return disabled_color_;
}

void
FlatButton::setDisabledBackgroundColor(const QColor &color)
{
        disabled_background_color_ = color;
}

QColor
FlatButton::disabledBackgroundColor() const
{
        if (!disabled_background_color_.isValid()) {
                return ThemeManager::instance().themeColor("FadedWhite");
        }

        return disabled_background_color_;
}

void
FlatButton::setFontSize(qreal size)
{
        font_size_ = size;

        QFont f(font());
        f.setPixelSize(size);
        setFont(f);

        update();
}

qreal
FlatButton::fontSize() const
{
        return font_size_;
}

void
FlatButton::setOverlayStyle(ui::OverlayStyle style)
{
        overlay_style_ = style;
        update();
}

ui::OverlayStyle
FlatButton::overlayStyle() const
{
        return overlay_style_;
}

void
FlatButton::setRippleStyle(ui::RippleStyle style)
{
        ripple_style_ = style;
}

ui::RippleStyle
FlatButton::rippleStyle() const
{
        return ripple_style_;
}

void
FlatButton::setIconPlacement(ui::ButtonIconPlacement placement)
{
        icon_placement_ = placement;
        update();
}

ui::ButtonIconPlacement
FlatButton::iconPlacement() const
{
        return icon_placement_;
}

void
FlatButton::setCornerRadius(qreal radius)
{
        corner_radius_ = radius;
        updateClipPath();
        update();
}

qreal
FlatButton::cornerRadius() const
{
        return corner_radius_;
}

void
FlatButton::setBackgroundMode(Qt::BGMode mode)
{
        bg_mode_ = mode;
        state_machine_->setupProperties();
}

Qt::BGMode
FlatButton::backgroundMode() const
{
        return bg_mode_;
}

void
FlatButton::setBaseOpacity(qreal opacity)
{
        base_opacity_ = opacity;
        state_machine_->setupProperties();
}

qreal
FlatButton::baseOpacity() const
{
        return base_opacity_;
}

void
FlatButton::setCheckable(bool value)
{
        state_machine_->updateCheckedStatus();
        state_machine_->setCheckedOverlayProgress(0);

        QPushButton::setCheckable(value);
}

void
FlatButton::setHasFixedRippleRadius(bool value)
{
        use_fixed_ripple_radius_ = value;
}

bool
FlatButton::hasFixedRippleRadius() const
{
        return use_fixed_ripple_radius_;
}

void
FlatButton::setFixedRippleRadius(qreal radius)
{
        fixed_ripple_radius_ = radius;
        setHasFixedRippleRadius(true);
}

QSize
FlatButton::sizeHint() const
{
        ensurePolished();

        QSize label(fontMetrics().size(Qt::TextSingleLine, text()));

        int w = 20 + label.width();
        int h = label.height();

        if (!icon().isNull()) {
                w += iconSize().width() + FlatButton::IconPadding;
                h = qMax(h, iconSize().height());
        }

        return QSize(w, 20 + h);
}

void
FlatButton::checkStateSet()
{
        state_machine_->updateCheckedStatus();
        QPushButton::checkStateSet();
}

void
FlatButton::mousePressEvent(QMouseEvent *event)
{
        if (ui::RippleStyle::NoRipple != ripple_style_) {
                QPoint pos;
                qreal radiusEndValue;

                if (ui::RippleStyle::CenteredRipple == ripple_style_) {
                        pos = rect().center();
                } else {
                        pos = event->pos();
                }

                if (use_fixed_ripple_radius_) {
                        radiusEndValue = fixed_ripple_radius_;
                } else {
                        radiusEndValue = static_cast<qreal>(width()) / 2;
                }

                Ripple *ripple = new Ripple(pos);

                ripple->setRadiusEndValue(radiusEndValue);
                ripple->setOpacityStartValue(0.35);
                ripple->setColor(foregroundColor());
                ripple->radiusAnimation()->setDuration(250);
                ripple->opacityAnimation()->setDuration(250);

                ripple_overlay_->addRipple(ripple);
        }

        QPushButton::mousePressEvent(event);
}

void
FlatButton::mouseReleaseEvent(QMouseEvent *event)
{
        QPushButton::mouseReleaseEvent(event);
        state_machine_->updateCheckedStatus();
}

void
FlatButton::resizeEvent(QResizeEvent *event)
{
        QPushButton::resizeEvent(event);
        updateClipPath();
}

void
FlatButton::paintEvent(QPaintEvent *event)
{
        Q_UNUSED(event)

        QPainter painter(this);
        painter.setRenderHint(QPainter::Antialiasing);

        const qreal cr = corner_radius_;

        if (cr > 0) {
                QPainterPath path;
                path.addRoundedRect(rect(), cr, cr);

                painter.setClipPath(path);
                painter.setClipping(true);
        }

        paintBackground(&painter);

        painter.setOpacity(1);
        painter.setClipping(false);

        paintForeground(&painter);
}

void
FlatButton::paintBackground(QPainter *painter)
{
        const qreal overlayOpacity  = state_machine_->overlayOpacity();
        const qreal checkedProgress = state_machine_->checkedOverlayProgress();

        if (Qt::OpaqueMode == bg_mode_) {
                QBrush brush;
                brush.setStyle(Qt::SolidPattern);

                if (isEnabled()) {
                        brush.setColor(backgroundColor());
                } else {
                        brush.setColor(disabledBackgroundColor());
                }

                painter->setOpacity(1);
                painter->setBrush(brush);
                painter->setPen(Qt::NoPen);
                painter->drawRect(rect());
        }

        QBrush brush;
        brush.setStyle(Qt::SolidPattern);
        painter->setPen(Qt::NoPen);

        if (!isEnabled()) {
                return;
        }

        if ((ui::OverlayStyle::NoOverlay != overlay_style_) && (overlayOpacity > 0)) {
                if (ui::OverlayStyle::TintedOverlay == overlay_style_) {
                        brush.setColor(overlayColor());
                } else {
                        brush.setColor(Qt::gray);
                }

                painter->setOpacity(overlayOpacity);
                painter->setBrush(brush);
                painter->drawRect(rect());
        }

        if (isCheckable() && checkedProgress > 0) {
                const qreal q = Qt::TransparentMode == bg_mode_ ? 0.45 : 0.7;
                brush.setColor(foregroundColor());
                painter->setOpacity(q * checkedProgress);
                painter->setBrush(brush);
                QRect r(rect());
                r.setHeight(static_cast<qreal>(r.height()) * checkedProgress);
                painter->drawRect(r);
        }
}

#define COLOR_INTERPOLATE(CH) (1 - progress) * source.CH() + progress *dest.CH()

void
FlatButton::paintForeground(QPainter *painter)
{
        if (isEnabled()) {
                painter->setPen(foregroundColor());
                const qreal progress = state_machine_->checkedOverlayProgress();

                if (isCheckable() && progress > 0) {
                        QColor source = foregroundColor();
                        QColor dest =
                          Qt::TransparentMode == bg_mode_ ? Qt::white : backgroundColor();
                        if (qFuzzyCompare(1, progress)) {
                                painter->setPen(dest);
                        } else {
                                painter->setPen(QColor(COLOR_INTERPOLATE(red),
                                                       COLOR_INTERPOLATE(green),
                                                       COLOR_INTERPOLATE(blue),
                                                       COLOR_INTERPOLATE(alpha)));
                        }
                }
        } else {
                painter->setPen(disabledForegroundColor());
        }

        if (icon().isNull()) {
                painter->drawText(rect(), Qt::AlignCenter, text());
                return;
        }

        QSize textSize(fontMetrics().size(Qt::TextSingleLine, text()));
        QSize base(size() - textSize);

        const int iw = iconSize().width() + IconPadding;
        QPoint pos((base.width() - iw) / 2, 0);

        QRect textGeometry(pos + QPoint(0, base.height() / 2), textSize);
        QRect iconGeometry(pos + QPoint(0, (height() - iconSize().height()) / 2), iconSize());

        /* if (ui::LeftIcon == icon_placement_) { */
        /* 	textGeometry.translate(iw, 0); */
        /* } else { */
        /* 	iconGeometry.translate(textSize.width() + IconPadding, 0); */
        /* } */

        painter->drawText(textGeometry, Qt::AlignCenter, text());

        QPixmap pixmap = icon().pixmap(iconSize());
        QPainter icon(&pixmap);
        icon.setCompositionMode(QPainter::CompositionMode_SourceIn);
        icon.fillRect(pixmap.rect(), painter->pen().color());
        painter->drawPixmap(iconGeometry, pixmap);
}

void
FlatButton::updateClipPath()
{
        const qreal radius = corner_radius_;

        QPainterPath path;
        path.addRoundedRect(rect(), radius, radius);
        ripple_overlay_->setClipPath(path);
}

FlatButtonStateMachine::FlatButtonStateMachine(FlatButton *parent)
  : QStateMachine(parent)
  , button_(parent)
  , top_level_state_(new QState(QState::ParallelStates))
  , config_state_(new QState(top_level_state_))
  , checkable_state_(new QState(top_level_state_))
  , checked_state_(new QState(checkable_state_))
  , unchecked_state_(new QState(checkable_state_))
  , neutral_state_(new QState(config_state_))
  , neutral_focused_state_(new QState(config_state_))
  , hovered_state_(new QState(config_state_))
  , hovered_focused_state_(new QState(config_state_))
  , pressed_state_(new QState(config_state_))
  , overlay_opacity_(0)
  , checked_overlay_progress_(parent->isChecked() ? 1 : 0)
  , was_checked_(false)
{
        Q_ASSERT(parent);

        parent->installEventFilter(this);

        config_state_->setInitialState(neutral_state_);
        addState(top_level_state_);
        setInitialState(top_level_state_);

        checkable_state_->setInitialState(parent->isChecked() ? checked_state_ : unchecked_state_);
        QSignalTransition *transition;
        QPropertyAnimation *animation;

        transition = new QSignalTransition(this, SIGNAL(buttonChecked()));
        transition->setTargetState(checked_state_);
        unchecked_state_->addTransition(transition);

        animation = new QPropertyAnimation(this, "checkedOverlayProgress", this);
        animation->setDuration(200);
        transition->addAnimation(animation);

        transition = new QSignalTransition(this, SIGNAL(buttonUnchecked()));
        transition->setTargetState(unchecked_state_);
        checked_state_->addTransition(transition);

        animation = new QPropertyAnimation(this, "checkedOverlayProgress", this);
        animation->setDuration(200);
        transition->addAnimation(animation);

        addTransition(button_, QEvent::FocusIn, neutral_state_, neutral_focused_state_);
        addTransition(button_, QEvent::FocusOut, neutral_focused_state_, neutral_state_);
        addTransition(button_, QEvent::Enter, neutral_state_, hovered_state_);
        addTransition(button_, QEvent::Leave, hovered_state_, neutral_state_);
        addTransition(button_, QEvent::Enter, neutral_focused_state_, hovered_focused_state_);
        addTransition(button_, QEvent::Leave, hovered_focused_state_, neutral_focused_state_);
        addTransition(button_, QEvent::FocusIn, hovered_state_, hovered_focused_state_);
        addTransition(button_, QEvent::FocusOut, hovered_focused_state_, hovered_state_);
        addTransition(this, SIGNAL(buttonPressed()), hovered_state_, pressed_state_);
        addTransition(button_, QEvent::Leave, pressed_state_, neutral_focused_state_);
        addTransition(button_, QEvent::FocusOut, pressed_state_, hovered_state_);
}

FlatButtonStateMachine::~FlatButtonStateMachine()
{
}

void
FlatButtonStateMachine::setOverlayOpacity(qreal opacity)
{
        overlay_opacity_ = opacity;
        button_->update();
}

void
FlatButtonStateMachine::setCheckedOverlayProgress(qreal opacity)
{
        checked_overlay_progress_ = opacity;
        button_->update();
}

void
FlatButtonStateMachine::startAnimations()
{
        start();
}

void
FlatButtonStateMachine::setupProperties()
{
        QColor overlayColor;

        if (Qt::TransparentMode == button_->backgroundMode()) {
                overlayColor = button_->backgroundColor();
        } else {
                overlayColor = button_->foregroundColor();
        }

        const qreal baseOpacity = button_->baseOpacity();

        neutral_state_->assignProperty(this, "overlayOpacity", 0);
        neutral_focused_state_->assignProperty(this, "overlayOpacity", 0);
        hovered_state_->assignProperty(this, "overlayOpacity", baseOpacity);
        hovered_focused_state_->assignProperty(this, "overlayOpacity", baseOpacity);
        pressed_state_->assignProperty(this, "overlayOpacity", baseOpacity);
        checked_state_->assignProperty(this, "checkedOverlayProgress", 1);
        unchecked_state_->assignProperty(this, "checkedOverlayProgress", 0);

        button_->update();
}

void
FlatButtonStateMachine::updateCheckedStatus()
{
        const bool checked = button_->isChecked();
        if (was_checked_ != checked) {
                was_checked_ = checked;
                if (checked) {
                        emit buttonChecked();
                } else {
                        emit buttonUnchecked();
                }
        }
}

bool
FlatButtonStateMachine::eventFilter(QObject *watched, QEvent *event)
{
        if (QEvent::FocusIn == event->type()) {
                QFocusEvent *focusEvent = static_cast<QFocusEvent *>(event);
                if (focusEvent && Qt::MouseFocusReason == focusEvent->reason()) {
                        emit buttonPressed();
                        return true;
                }
        }

        return QStateMachine::eventFilter(watched, event);
}

void
FlatButtonStateMachine::addTransition(QObject *object,
                                      const char *signal,
                                      QState *fromState,
                                      QState *toState)
{
        addTransition(new QSignalTransition(object, signal), fromState, toState);
}

void
FlatButtonStateMachine::addTransition(QObject *object,
                                      QEvent::Type eventType,
                                      QState *fromState,
                                      QState *toState)
{
        addTransition(new QEventTransition(object, eventType), fromState, toState);
}

void
FlatButtonStateMachine::addTransition(QAbstractTransition *transition,
                                      QState *fromState,
                                      QState *toState)
{
        transition->setTargetState(toState);

        QPropertyAnimation *animation;

        animation = new QPropertyAnimation(this, "overlayOpacity", this);
        animation->setDuration(150);
        transition->addAnimation(animation);

        fromState->addTransition(transition);
}