/******************************************************************************
 * QSkinny - Copyright (C) 2016 Uwe Rathmann
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/

#include "QskMenuSkinlet.h"
#include "QskMenu.h"

#include "QskGraphic.h"
#include "QskColorFilter.h"
#include "QskTextOptions.h"
#include "QskFunctions.h"
#include "QskMargins.h"
#include "QskFunctions.h"
#include "QskLabelData.h"

#include "QskSGNode.h"

#include <qfontmetrics.h>
#include <qmath.h>

static inline int qskActionIndex( const QskMenu* menu, int optionIndex )
{
    if ( optionIndex < 0 )
        return -1;

    const auto& actions = menu->actions();

    auto it = std::lower_bound(
        actions.constBegin(), actions.constEnd(), optionIndex );

    return it - actions.constBegin();
}

static inline qreal qskPaddedSeparatorHeight( const QskMenu* menu )
{
    using Q = QskMenu;

    const auto margins = menu->marginHint( Q::Separator );

    return menu->metric( Q::Separator | QskAspect::Size )
        + margins.top() + margins.bottom();
}

class QskMenuSkinlet::PrivateData
{
  public:
    class CacheGuard
    {
      public:
        CacheGuard( PrivateData* data )
            : m_data( data )
        {
            m_data->enableCache( true );
        }

        ~CacheGuard()
        {
            m_data->enableCache( false );
        }

      private:
        PrivateData* m_data;
    };

    void enableCache( bool on )
    {
        m_isCaching = on;
        m_segmentHeight = m_segmentWidth = m_graphicWidth = m_textWidth = -1.0;
    }

    inline qreal graphicWidth( const QskMenu* menu ) const
    {
        if ( m_isCaching )
        {
            if ( m_graphicWidth < 0.0 )
                m_graphicWidth = graphicWidthInternal( menu );

            return m_graphicWidth;
        }

        return graphicWidthInternal( menu );
    }

    inline qreal textWidth( const QskMenu* menu ) const
    {
        if ( m_isCaching )
        {
            if ( m_textWidth < 0.0 )
                m_textWidth = textWidthInternal( menu );

            return m_textWidth;
        }

        return textWidthInternal( menu );
    }

    inline qreal segmentWidth( const QskMenu* menu ) const
    {
        if ( m_isCaching )
        {
            if ( m_segmentWidth < 0.0 )
                m_segmentWidth = segmentWidthInternal( menu );

            return m_segmentWidth;
        }

        return segmentWidthInternal( menu );
    }

    inline qreal segmentHeight( const QskMenu* menu ) const
    {
        if ( m_isCaching )
        {
            if ( m_segmentHeight < 0.0 )
                m_segmentHeight = segmentHeightInternal( menu );

            return m_segmentHeight;
        }

        return segmentHeightInternal( menu );
    }

  private:
    qreal graphicWidthInternal( const QskMenu* menu ) const
    {
        const auto hint = menu->strutSizeHint( QskMenu::Icon );
        const qreal textHeight = menu->effectiveFontHeight( QskMenu::Text );

        const auto h = qMax( hint.height(), textHeight );

        qreal maxW = 0.0;

        const auto options = menu->options();
        for ( auto& option : options )
        {
            const auto graphic = option.icon().graphic();
            if ( !graphic.isNull() )
            {
                const auto w = graphic.widthForHeight( h );
                if( w > maxW )
                    maxW = w;
            }
        }

        return qMax( hint.width(), maxW );
    }

    qreal textWidthInternal( const QskMenu* menu ) const
    {
        const QFontMetricsF fm( menu->effectiveFont( QskMenu::Text ) );

        auto maxWidth = 0.0;

        const auto options = menu->options();
        for ( auto& option : options )
        {
            if( !option.text().isEmpty() )
            {
                const auto w = qskHorizontalAdvance( fm, option.text() );
                if( w > maxWidth )
                    maxWidth = w;
            }
        }

        return maxWidth;
    }

    qreal segmentWidthInternal( const QskMenu* menu ) const
    {
        using Q = QskMenu;

        const auto spacing = menu->spacingHint( Q::Segment );
        const auto padding = menu->paddingHint( Q::Segment );

        auto w = graphicWidth( menu ) + spacing + textWidth( menu );

        w += padding.left() + padding.right();

        const auto minWidth = menu->strutSizeHint( Q::Segment ).width();
        return qMax( w, minWidth );
    }

    qreal segmentHeightInternal( const QskMenu* menu ) const
    {
        using Q = QskMenu;

        const auto graphicHeight = menu->strutSizeHint( Q::Icon ).height();
        const auto textHeight = menu->effectiveFontHeight( Q::Text );
        const auto padding = menu->paddingHint( Q::Segment );

        qreal h = qMax( graphicHeight, textHeight );
        h += padding.top() + padding.bottom();

        const auto minHeight = menu->strutSizeHint( Q::Segment ).height();
        h = qMax( h, minHeight );

        return h;
    }

    bool m_isCaching;

    mutable qreal m_graphicWidth = -1.0;
    mutable qreal m_textWidth = -1.0;
    mutable qreal m_segmentHeight = -1.0;
    mutable qreal m_segmentWidth = -1.0;
};

QskMenuSkinlet::QskMenuSkinlet( QskSkin* skin )
    : Inherited( skin )
    , m_data( new PrivateData() )
{
    appendNodeRoles( { ContentsRole, PanelRole } );
}

QskMenuSkinlet::~QskMenuSkinlet() = default;

QSGNode* QskMenuSkinlet::updateSubNode(
    const QskSkinnable* skinnable, quint8 nodeRole, QSGNode* node ) const
{
    switch ( nodeRole )
    {
        case ContentsRole:
        {
            const auto popup = static_cast< const QskPopup* >( skinnable );

            auto rect = popup->contentsRect();
            if ( rect.isEmpty() )
                return nullptr;

            return updateContentsNode( popup, node );
        }
    }

    return Inherited::updateSubNode( skinnable, nodeRole, node );
}

QRectF QskMenuSkinlet::cursorRect(
    const QskSkinnable* skinnable, const QRectF& contentsRect, int index ) const
{
    using Q = QskMenu;

    const auto menu = static_cast< const QskMenu* >( skinnable );
    const auto actions = menu->actions();

    index = qskActionIndex( menu, index );

    QRectF rect;

    if ( index < 0 )
    {
        rect = sampleRect( skinnable, contentsRect, Q::Segment, 0 );
        rect.setBottom( rect.top() );
    }
    else if ( index >= actions.count() )
    {
        rect = sampleRect( skinnable, contentsRect, Q::Segment, actions.count() - 1 );
        rect.setTop( rect.bottom() );
    }
    else
    {
        rect = sampleRect( skinnable, contentsRect, Q::Segment, index );
    }

    return rect;
}

QRectF QskMenuSkinlet::subControlRect(
    const QskSkinnable* skinnable, const QRectF& contentsRect,
    QskAspect::Subcontrol subControl ) const
{
    using Q = QskMenu;

    const auto menu = static_cast< const QskMenu* >( skinnable );

    if( subControl == Q::Panel )
    {
        return contentsRect;
    }

    if( subControl == Q::Cursor )
    {
        if ( menu->currentIndex() < 0 )
            return QRectF();

        const qreal pos = menu->positionHint( Q::Cursor );

        const int pos1 = qFloor( pos );
        const int pos2 = qCeil( pos );

        auto rect = cursorRect( skinnable, contentsRect, pos1 );

        if ( pos1 != pos2 )
        {
            const auto r = cursorRect( skinnable, contentsRect, pos2 );

            const qreal ratio = ( pos - pos1 ) / ( pos2 - pos1 );
            rect = qskInterpolatedRect( rect, r, ratio );
        }

        return rect;
    }

    return Inherited::subControlRect( skinnable, contentsRect, subControl );
}

QRectF QskMenuSkinlet::sampleRect(
    const QskSkinnable* skinnable, const QRectF& contentsRect,
    QskAspect::Subcontrol subControl, int index ) const
{
    using Q = QskMenu;

    const auto menu = static_cast< const QskMenu* >( skinnable );

    if ( subControl == Q::Segment )
    {
        const auto h = m_data->segmentHeight( menu );

        auto dy = index * h;

        if ( const auto n = menu->actions()[ index ] - index )
            dy += n * qskPaddedSeparatorHeight( menu );

        const auto r = menu->subControlContentsRect( Q::Panel );
        return QRectF( r.x(), r.y() + dy, r.width(), h );
    }

    if ( subControl == QskMenu::Icon || subControl == QskMenu::Text )
    {
        const auto r = sampleRect( menu, contentsRect, Q::Segment, index );
        const auto graphicWidth = m_data->graphicWidth( menu );

        if ( subControl == QskMenu::Icon )
        {
            auto graphicRect = r;
            graphicRect.setWidth( graphicWidth );
            const auto padding = menu->paddingHint( QskMenu::Icon );
            graphicRect = graphicRect.marginsRemoved( padding );

            return graphicRect;
        }
        else
        {
            auto textRect = r;

            if ( graphicWidth > 0.0 )
            {
                const auto spacing = skinnable->spacingHint( Q::Segment );
                textRect.setX( r.x() + graphicWidth + spacing );
            }

            return textRect;
        }
    }

    if ( subControl == QskMenu::Separator )
    {
        const auto separators = menu->separators();
        if ( index >= separators.count() )
            return QRectF();

        const auto h = qskPaddedSeparatorHeight( menu );

        auto y = index * h;

        if ( const auto n = qskActionIndex( menu, separators[ index ] ) )
            y += n * m_data->segmentHeight( menu );

        const auto r = menu->subControlContentsRect( Q::Panel );
        return QRectF( r.left(), y, r.width(), h );
    }

    return Inherited::sampleRect(
        skinnable, contentsRect, subControl, index );
}

int QskMenuSkinlet::sampleIndexAt(
    const QskSkinnable* skinnable, const QRectF& contentsRect,
    QskAspect::Subcontrol subControl, const QPointF& pos ) const
{
    const PrivateData::CacheGuard guard( m_data.get() );
    return Inherited::sampleIndexAt( skinnable, contentsRect, subControl, pos );
}

int QskMenuSkinlet::sampleCount(
    const QskSkinnable* skinnable, QskAspect::Subcontrol subControl ) const
{
    using Q = QskMenu;

    if ( subControl == Q::Segment || subControl == Q::Icon || subControl == Q::Text )
    {
        const auto menu = static_cast< const QskMenu* >( skinnable );
        return menu->actions().count();
    }

    if ( subControl == Q::Separator )
    {
        const auto menu = static_cast< const QskMenu* >( skinnable );
        return menu->separators().count();
    }

    return Inherited::sampleCount( skinnable, subControl );
}

QskAspect::States QskMenuSkinlet::sampleStates(
    const QskSkinnable* skinnable, QskAspect::Subcontrol subControl, int index ) const
{
    using Q = QskMenu;
    using A = QskAspect;

    auto states = Inherited::sampleStates( skinnable, subControl, index );

    if ( subControl == Q::Segment || subControl == Q::Icon || subControl == Q::Text )
    {
        const auto menu = static_cast< const QskMenu* >( skinnable );

        if ( menu->currentIndex() == menu->actions()[ index ] )
        {
            states |= Q::Selected;

            if( menu->isPressed() )
            {
                states |= Q::Pressed;
            }
            else
            {
                states &= ~Q::Pressed;
            }
        }

        const auto cursorPos = menu->effectiveSkinHint(
            Q::Segment | Q::Hovered | A::Metric | A::Position ).toPointF();

        if( !cursorPos.isNull() && menu->indexAtPosition( cursorPos ) == index )
        {
            states |= Q::Hovered;
        }
        else
        {
            states &= ~Q::Hovered;
        }
    }

    return states;
}

QVariant QskMenuSkinlet::sampleAt( const QskSkinnable* skinnable,
    QskAspect::Subcontrol subControl, int index ) const
{
    using Q = QskMenu;

    if ( subControl == Q::Icon || subControl == Q::Text )
    {
        const auto menu = static_cast< const QskMenu* >( skinnable );

        const auto option = menu->optionAt( index );

        if ( subControl == Q::Icon )
            return QVariant::fromValue( option.icon().graphic() );
        else
            return QVariant::fromValue( option.text() );
    }

    return Inherited::sampleAt( skinnable, subControl, index );
}

QSGNode* QskMenuSkinlet::updateContentsNode(
    const QskPopup* popup, QSGNode* contentsNode ) const
{
    const PrivateData::CacheGuard guard( m_data.get() );
    return updateMenuNode( popup, contentsNode );
}

QSGNode* QskMenuSkinlet::updateMenuNode(
    const QskSkinnable* skinnable, QSGNode* contentsNode ) const
{
    enum { Panel, Segment, Cursor, Icon, Text, Separator };
    static QVector< quint8 > roles = { Panel, Separator, Segment, Cursor, Icon, Text };

    if ( contentsNode == nullptr )
        contentsNode = new QSGNode();

    for ( const auto role : roles )
    {
        auto oldNode = QskSGNode::findChildNode( contentsNode, role );

        QSGNode* newNode = nullptr;

        switch( role )
        {
            case Panel:
            {
                newNode = updateBoxNode( skinnable, oldNode, QskMenu::Panel );
                break;
            }
            case Segment:
            {
                newNode = updateSeriesNode( skinnable, QskMenu::Segment, oldNode );
                break;
            }
            case Cursor:
            {
                newNode = updateBoxNode( skinnable, oldNode, QskMenu::Cursor );
                break;
            }
            case Icon:
            {
                newNode = updateSeriesNode( skinnable, QskMenu::Icon, oldNode );
                break;
            }
            case Text:
            {
                newNode = updateSeriesNode( skinnable, QskMenu::Text, oldNode );
                break;
            }
            case Separator:
            {
                newNode = updateSeriesNode( skinnable, QskMenu::Separator, oldNode );
                break;
            }
        }

        QskSGNode::replaceChildNode( roles, role, contentsNode, oldNode, newNode );
    }

    return contentsNode;
}

QSGNode* QskMenuSkinlet::updateSampleNode( const QskSkinnable* skinnable,
    QskAspect::Subcontrol subControl, int index, QSGNode* node ) const
{
    using Q = QskMenu;

    auto menu = static_cast< const QskMenu* >( skinnable );

    const auto rect = sampleRect( menu, menu->contentsRect(), subControl, index );

    if ( subControl == Q::Segment )
    {
        return updateBoxNode( menu, node, rect, subControl );
    }

    if ( subControl == Q::Icon )
    {
        index = menu->actions()[ index ];

        const auto graphic = menu->optionAt( index ).icon().graphic();
        if ( graphic.isNull() )
            return nullptr;

        const auto alignment = menu->alignmentHint( subControl, Qt::AlignCenter );
        const auto filter = menu->effectiveGraphicFilter( subControl );

        return QskSkinlet::updateGraphicNode(
            menu, node, graphic, filter, rect, alignment );
    }

    if ( subControl == Q::Text )
    {
        index = menu->actions()[ index ];

        const auto text = menu->optionAt( index ).text();
        if ( text.isEmpty() )
            return nullptr;

        const auto alignment = menu->alignmentHint(
            subControl, Qt::AlignVCenter | Qt::AlignLeft );

        return QskSkinlet::updateTextNode( menu, node, rect,
            alignment, text, Q::Text );
    }

    if ( subControl == Q::Separator )
    {
        auto gradient = menu->gradientHint( subControl );
        if ( ( gradient.type() == QskGradient::Stops ) && !gradient.isMonochrome() )
            gradient.setLinearDirection( Qt::Vertical );

        return updateBoxNode( menu, node, rect, gradient, subControl );
    }

    return nullptr;
}

QSizeF QskMenuSkinlet::sizeHint( const QskSkinnable* skinnable,
    Qt::SizeHint which, const QSizeF& ) const
{
    if ( which != Qt::PreferredSize )
        return QSizeF();

    using Q = QskMenu;
    const auto menu = static_cast< const QskMenu* >( skinnable );

    const PrivateData::CacheGuard guard( m_data.get() );

    qreal w = 0.0;
    qreal h = 0.0;

    if ( const auto count = sampleCount( skinnable, Q::Segment ) )
    {
        w = m_data->segmentWidth( menu );
        h = count * m_data->segmentHeight( menu );
    }

    if ( const auto count = sampleCount( skinnable, Q::Separator ) )
    {
        h += count * qskPaddedSeparatorHeight( menu );
    }

    auto hint = skinnable->outerBoxSize( QskMenu::Panel, QSizeF( w, h ) );
    hint = hint.expandedTo( skinnable->strutSizeHint( QskMenu::Panel ) );

    return hint;
}

#include "moc_QskMenuSkinlet.cpp"