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

#include "QskBoundedValueInput.h"
#include "QskFunctions.h"

#include <qlocale.h>
#include <cfloat>

static qreal qskAlignedValue( const QskBoundedValueInput* input, qreal value )
{
    value = input->boundedValue( value );

    if ( value > input->minimum() && value < input->maximum() )
    {
        if ( input->isSnapping() && input->stepSize() )
        {
            const auto step = input->stepSize();

            value = qRound( value / step ) * step;
            value = input->boundedValue( value );
        }
    }

    return value;
}

class QskBoundedValueInput::PrivateData
{
  public:
    qreal value = 0.0;
    int decimals = 2;
};

QskBoundedValueInput::QskBoundedValueInput( QQuickItem* parent )
    : Inherited( parent )
    , m_data( new PrivateData )
{
}

QskBoundedValueInput::~QskBoundedValueInput()
{
}

void QskBoundedValueInput::setDecimals( int decimals )
{
    decimals = qBound( 0, decimals, DBL_MAX_10_EXP + DBL_DIG );
    if ( decimals != m_data->decimals )
    {
        m_data->decimals = decimals;

        update();
        resetImplicitSize();
    }
}

int QskBoundedValueInput::decimals() const
{
    return m_data->decimals;
}

void QskBoundedValueInput::keyPressEvent( QKeyEvent* event )
{
    switch( event->key() )
    {
        case Qt::Key_Home:
            setValue( minimum() );
            break;

        case Qt::Key_End:
            setValue( maximum() );
            break;
    }

    Inherited::keyPressEvent( event );
}

void QskBoundedValueInput::alignInput()
{
    auto value = qskAlignedValue( this, m_data->value );
    value = fixupValue( value );

    setValueInternal( value );
}

qreal QskBoundedValueInput::fixupValue( qreal value ) const
{
    return value;
}

void QskBoundedValueInput::setValueAsRatio( qreal ratio )
{
    ratio = qBound( 0.0, ratio, 1.0 );
    setValue( minimum() + ratio * boundaryLength() );
}

qreal QskBoundedValueInput::valueAsRatio() const
{
    return valueAsRatio( m_data->value );
}

void QskBoundedValueInput::setValue( qreal value )
{
    if ( isComponentComplete() )
    {
        value = qskAlignedValue( this, value );
        value = fixupValue( value );
    }

    setValueInternal( value );
}

qreal QskBoundedValueInput::value() const
{
    return m_data->value;
}

void QskBoundedValueInput::increment( qreal offset )
{
    setValue( m_data->value + offset );
}

void QskBoundedValueInput::setValueInternal( qreal value )
{
    if ( !qskFuzzyCompare( value, m_data->value ) )
    {
        m_data->value = value;
        Q_EMIT valueChanged( value );

        update();
    }
}

QString QskBoundedValueInput::valueText() const
{
    return textFromValue( value() );
}

QString QskBoundedValueInput::textFromValue( qreal value ) const
{
    return locale().toString( value, 'f', m_data->decimals );
}

#include "moc_QskBoundedValueInput.cpp"