/******************************************************************************
 * QSkinny - Copyright (C) The authors
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/

#include "QskHintAnimator.h"
#include "QskAnimationHint.h"
#include "QskControl.h"
#include "QskEvent.h"

#include <qobject.h>
#include <qthread.h>

#include <algorithm>
#include <vector>

#define ALIGN_VALUES 0

#if ALIGN_VALUES

static inline qreal qskAligned05( qreal value )
{
    // aligned to 0.5
    return qRound( 2.0 * value ) / 2.0;
}

static inline QSizeF qskAligned05( const QSizeF& size )
{
    return QSizeF( qskAligned05( size.width() ), qskAligned05( size.height() ) );
}

static inline QskMargins qskAligned05( const QskMargins& margins )
{
    const qreal left = qskAligned05( margins.left() );
    const qreal top = qskAligned05( margins.top() );
    const qreal right = qskAligned05( margins.right() );
    const qreal bottom = qskAligned05( margins.bottom() );

    return QskMargins( left, top, right, bottom );
}

static inline QVariant qskAligned05( const QVariant& value )
{
    if ( value.canConvert< QskBoxBorderMetrics >() )
    {
        auto metrics = value.value< QskBoxBorderMetrics >();

        if ( metrics.sizeMode() == Qt::AbsoluteSize )
        {
            metrics.setWidths( qskAligned05( metrics.widths() ) );
            return QVariant::fromValue( metrics );
        }
    }
    else if ( value.canConvert< QskBoxShapeMetrics >() )
    {
        auto metrics = value.value< QskBoxShapeMetrics >();
        if ( metrics.sizeMode() == Qt::AbsoluteSize )
        {
            for ( int i = Qt::TopLeftCorner; i <= Qt::BottomRightCorner; i++ )
            {
                const auto corner = static_cast< Qt::Corner >( i );
                metrics.setRadius( corner, qskAligned05( metrics.radius( corner ) ) );
            }

            return QVariant::fromValue( metrics );
        }
    }
    else if ( value.canConvert< QskMargins >() )
    {
        const auto margins = value.value< QskMargins >();
        return QVariant::fromValue( qskAligned05( margins ) );
    }

    return value;
}

#endif

static inline void qskSendAnimatorEvent(
    const QskAspect aspect, int index, bool on, QObject* receiver )
{
    const auto state = on ? QskAnimatorEvent::Started : QskAnimatorEvent::Terminated;

    const auto thread = receiver->thread();
    if ( thread && ( thread != QThread::currentThread() ) )
    {
        /*
            QskInputPanelSkinlet changes the skin state, what leads to
            sending events from the wrong thread. We can't use
            QCoreApplication::sendEvent then, TODO ...
         */
        
        auto event = new QskAnimatorEvent( aspect, index, state );
        QCoreApplication::postEvent( receiver, event );
    }
    else
    {
        QskAnimatorEvent event( aspect, index, state );
        QCoreApplication::sendEvent( receiver, &event );
    }
}

QskHintAnimator::QskHintAnimator() noexcept
    : m_index( -1 )
{
}

QskHintAnimator::QskHintAnimator( const QskAspect aspect, int index ) noexcept
    : m_aspect( aspect )
    , m_index( index )
{
}

QskHintAnimator::~QskHintAnimator()
{
}

void QskHintAnimator::setAspect( const QskAspect aspect ) noexcept
{
    m_aspect = aspect;
}

void QskHintAnimator::setIndex( int index ) noexcept
{
    m_index = index;
}

void QskHintAnimator::setUpdateFlags( QskAnimationHint::UpdateFlags flags ) noexcept
{
    m_updateFlags = flags;
}

void QskHintAnimator::setControl( QskControl* control ) noexcept
{
    m_control = control;
}

void QskHintAnimator::advance( qreal progress )
{
    const auto oldValue = currentValue();

    Inherited::advance( progress );

#if ALIGN_VALUES
    setCurrentValue( qskAligned05( currentValue() ) );
#endif

    if ( m_control && ( currentValue() != oldValue ) )
    {
        if ( m_updateFlags == QskAnimationHint::UpdateAuto )
        {
            if ( !m_aspect.isColor() )
            {
                m_control->resetImplicitSize();

                if ( !m_control->childItems().isEmpty() )
                    m_control->polish();
            }

            m_control->update();
        }
        else
        {
            if ( m_updateFlags & QskAnimationHint::UpdateSizeHint )
                m_control->resetImplicitSize();

            if ( m_updateFlags & QskAnimationHint::UpdatePolish )
                m_control->polish();

            if ( m_updateFlags & QskAnimationHint::UpdateNode )
                m_control->update();
        }
    }
}

#ifndef QT_NO_DEBUG_STREAM

#include <qdebug.h>

QDebug operator<<( QDebug debug, const QskHintAnimator& animator )
{
    QDebugStateSaver saver( debug );
    debug.nospace();

    debug << "Animator" << "( ";

    debug << animator.aspect() << ", " << animator.endValue().typeName() << ", ";

    if ( animator.index() >= 0 )
        debug << animator.index() << ", ";

    if ( animator.isRunning() )
        debug << "R: " << animator.duration() << ", " << animator.elapsed();
    else
        debug << "S" << animator.duration();

    if ( auto control = animator.control() )
        debug << ", " << control->className() << ", " << (void*) control;

    debug << " )";

    return debug;
}

#endif

namespace
{
    class AnimatorMap : public std::vector< QskHintAnimator* >
    {
      public:
        ~AnimatorMap()
        {
            qDeleteAll( *this );
        }

        inline const QskHintAnimator* find( const QskAspect aspect, int index  ) const
        {
            const Key key { aspect, index };

            auto it = std::lower_bound( cbegin(), cend(), key, lessThan );
            if ( it != cend() )
            {
                if ( ( ( *it )->aspect() == aspect ) && ( ( *it )->index() == index ) )
                    return *it;
            }

            return nullptr;
        }

        inline QskHintAnimator* findOrInsert( const QskAspect aspect, int index )
        {
            const Key key { aspect, index };

            auto it = std::lower_bound( begin(), end(), key, lessThan );
            if ( it == end() || ( *it )->aspect() != aspect || ( *it )->index() != index )
            {
                it = insert( it, new QskHintAnimator( aspect, index ) );
            }

            return *it;
        }

      private:
        struct Key
        {
            QskAspect aspect;
            int index;
        };

        static inline bool lessThan( const QskHintAnimator* animator, const Key& key )
        {
            if ( animator->aspect() == key.aspect )
                return animator->index() < key.index;

            return animator->aspect() < key.aspect;
        }
    };

    class AnimatorGuard final : public QObject
    {
        Q_OBJECT

      public:
        AnimatorGuard()
        {
            QskAnimator::addCleanupHandler( this,
                SLOT(cleanup()), Qt::QueuedConnection );
        }

        void registerTable( QskHintAnimatorTable* table )
        {
            auto it = std::lower_bound( m_tables.begin(), m_tables.end(), table );
            if ( it == m_tables.end() || *it != table )
                m_tables.insert( it, table );
        }

        void unregisterTable( QskHintAnimatorTable* table )
        {
            auto it = std::lower_bound( m_tables.begin(), m_tables.end(), table );
            if ( it != m_tables.end() && *it == table )
                m_tables.erase( it );
        }

      private Q_SLOTS:
        void cleanup()
        {
            for ( auto it = m_tables.begin(); it != m_tables.end(); )
            {
                if ( ( *it )->cleanup() )
                    it = m_tables.erase( it );
                else
                    ++it;
            }
        }

      private:
        // a vector as iteration is more important than insertion
        std::vector< QskHintAnimatorTable* > m_tables;
    };

    Q_GLOBAL_STATIC( AnimatorGuard, qskAnimatorGuard )
}

class QskHintAnimatorTable::PrivateData
{
  public:
    AnimatorMap animators; // a flat map
};

QskHintAnimatorTable::QskHintAnimatorTable()
{
}

QskHintAnimatorTable::~QskHintAnimatorTable()
{
    if ( qskAnimatorGuard )
        qskAnimatorGuard->unregisterTable( this );

    delete m_data;
}

void QskHintAnimatorTable::start( QskControl* control,
    const QskAspect aspect, int index, QskAnimationHint animationHint,
    const QVariant& from, const QVariant& to )
{
    if ( m_data == nullptr )
    {
        m_data = new PrivateData();

        if ( qskAnimatorGuard )
            qskAnimatorGuard->registerTable( this );
    }

    auto animator = m_data->animators.findOrInsert( aspect, index );

    animator->setStartValue( from );
    animator->setEndValue( to );

    animator->setDuration( animationHint.duration );
    animator->setEasingCurve( animationHint.type );
    animator->setUpdateFlags( animationHint.updateFlags );

    animator->setControl( control );
    animator->setWindow( control->window() );

    animator->start();

    qskSendAnimatorEvent( aspect, index, true, control );
}

const QskHintAnimator* QskHintAnimatorTable::animator( QskAspect aspect, int index ) const
{
    if ( m_data )
        return m_data->animators.find( aspect, index );

    return nullptr;
}

QVariant QskHintAnimatorTable::currentValue( QskAspect aspect, int index ) const
{
    if ( m_data )
    {
        if ( auto animator = m_data->animators.find( aspect, index ) )
        {
            if ( animator->isRunning() )
                return animator->currentValue();
        }
    }

    return QVariant();
}

bool QskHintAnimatorTable::cleanup()
{
    if ( m_data == nullptr )
        return true;

    auto& animators = m_data->animators;

    for ( auto it = animators.begin(); it != animators.end(); )
    {
        auto animator = *it;

        // remove all terminated animators
        if ( !animator->isRunning() )
        {
            const auto control = animator->control();
            const auto aspect = animator->aspect();
            const auto index = animator->index();

            delete animator;

            it = animators.erase( it );

            if ( control )
                qskSendAnimatorEvent( aspect, index, false, control );
        }
        else
        {
            ++it;
        }
    }

    if ( animators.empty() )
    {
        delete m_data;
        m_data = nullptr;

        return true;
    }

    return false;
}

#include "QskHintAnimator.moc"