/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

// System includes

#include <QPainter>

#include <QStringListModel>

#include <QGraphicsSceneResizeEvent>

#include <QPen>

#include <HbPushButton>

#include <QTimer>

#include "radiofrequencystrip.h"

#include "radiofrequencyitem.h"

#include "radiouiengine.h"

#include "radiostation.h"

#include "radiouiutilities.h"

#include "radiologger.h"

// Frequency lines

const int KTabHeightSmall = 10;

const int KTabHeightBig = 15;

//const int KTabHeightFavorite = 15;

const int KTabWidthFavorite = 4;

const qreal KIndicatorWidth = 2.0;

const qreal KRounder = 0.5;

const int KSelectorWidth = 2;

const int KSelectorZPos = 100;

const int K100Khz = 100000;

//const int KTouchPosThreshold = 30;

const QString KSlideToLeft      = "SlideToLeft";

const QString KSlideFromLeft    = "SlideFromLeft";

const QString KSlideToRight     = "SlideToRight";

const QString KSlideFromRight   = "SlideFromRight";

/*!

 *

 */

static QLineF makeTab( qreal pos, int height )

{

    return QLineF( pos, KHeight - height, pos, KHeight );

}

/*!

 *

 */

    RadioStripBase( 0 ),

    mSelectorImage( new QGraphicsPixmapItem( this ) ),

    mSeparatorPos( 0.0 ),

    mMaxWidth( 0 ),

    mSelectorPos( 0.0 ),

    mFavoriteSelected( false ),

    mLeftButton( new HbPushButton( this ) ),

    mRightButton( new HbPushButton( this ) ),

    mButtonTimer( new QTimer( this ) ),

{

    mButtonTimer->setInterval( 500 );

    mButtonTimer->setSingleShot( true );

    connectAndTest( mButtonTimer, SIGNAL(timeout()), this, SLOT(toggleButtons()) );

    //TODO: Remove. Stepsize hardcoded to 100 Khz in europe region during demo

    if ( mFrequencyStepSize < K100Khz ) {

        mFrequencyStepSize = K100Khz;

    }

    setScrollingStyle( HbScrollArea::PanOrFlick );

    setItemSize( QSizeF( KWidth, KHeight ) );

    setFrictionEnabled( true );

    initModel();

    initSelector();

    initItems();

    initButtons();

}

/*!

 *

 */

void RadioFrequencyStrip::setLeftButtonIcon( const HbIcon& leftButtonIcon )

{

    mLeftButtonIcon = leftButtonIcon;

    if ( mLeftButton ) {

        mLeftButton->setIcon( mLeftButtonIcon );

    }

}

/*!

 *

 */

HbIcon RadioFrequencyStrip::leftButtonIcon() const

{

    return mLeftButtonIcon;

}

/*!

 *

 */

void RadioFrequencyStrip::setRightButtonIcon( const HbIcon& rightButtonIcon )

{

    mRightButtonIcon = rightButtonIcon;

    if ( mRightButton ) {

        mRightButton->setIcon( mRightButtonIcon );

    }

}

/*!

 *

 */

HbIcon RadioFrequencyStrip::rightButtonIcon() const

{

    return mRightButtonIcon;

}

/*!

 *

 */

uint RadioFrequencyStrip::frequency( bool* favorite ) const

{

    if ( favorite ) {

        *favorite = mFrequencies.value( mFrequency ).mFavorite;

    }

    return mFrequency;

}

/*!

 *

 */

void RadioFrequencyStrip::connectLeftButton( const char* signal, QObject* receiver, const char* slot )

{

    connectAndTest( mLeftButton, signal, receiver, slot );

}

/*!

 *

 */

void RadioFrequencyStrip::connectRightButton( const char* signal, QObject* receiver, const char* slot )

{

    connectAndTest( mRightButton, signal, receiver, slot );

}

/*!

 * Public slot

 *

 */

void RadioFrequencyStrip::favoriteChanged( const RadioStation& station )

{

    LOG_SLOT_CALLER;

    FrequencyPos pos = mFrequencies.value( station.frequency() );

    updateFavorites( pos.mItem );

    emitFavoriteSelected( station.isFavorite() );

}

/*!

 * Public slot

 *

 */

void RadioFrequencyStrip::stationAdded( const RadioStation& station )

{

    LOG_SLOT_CALLER;

    FrequencyPos pos = mFrequencies.value( station.frequency() );

    updateFavorites( pos.mItem );

}

/*!

 * Public slot

 *

 */

void RadioFrequencyStrip::stationRemoved( const RadioStation& station )

{

    LOG_SLOT_CALLER;

    uint frequency = station.frequency();

    if ( mFrequencies.contains( frequency ) ) {

        FrequencyPos pos = mFrequencies.value( frequency );

        updateFavorites( pos.mItem );

    }

}

/*!

 * Public slot

 *

 */

{

//    LOG_SLOT_CALLER;

//    LOG_FORMAT( "RadioFrequencyStrip::setFrequency, frequency: %d, sender: %d", frequency, commandSender );

         frequency != mFrequency &&                         // Different from the current

         mFrequencies.contains( frequency ) )               // 0 frequency means any illegal value

    {

        scrollToFrequency( frequency, mAutoScrollTime );

        emitFrequencyChanged( frequency );

    }

}

/*!

 * Private slot

 *

 */

void RadioFrequencyStrip::leftGesture( int DEBUGVAR( speedPixelsPerSecond ) )

{

    LOG_FORMAT( "RadioFrequencyStrip::leftGesture. speed: %d", speedPixelsPerSecond );

    mButtonTimer->stop();

    mButtonTimer->start();

    emit swipedLeft();

}

/*!

 * Private slot

 *

 */

void RadioFrequencyStrip::rightGesture( int DEBUGVAR( speedPixelsPerSecond ) )

{

    LOG_FORMAT( "RadioFrequencyStrip::rightGesture. speed: %d", speedPixelsPerSecond );

    mButtonTimer->stop();

    mButtonTimer->start();

    emit swipedRight();

}

/*!

 * Private slot

 *

 */

void RadioFrequencyStrip::panGesture( const QPointF& point )

{

    RadioStripBase::panGesture( point );

    mIsPanGesture = true;

}

/*!

 * Private slot

 */

void RadioFrequencyStrip::toggleButtons()

{

    HbEffect::start( mLeftButton, KSlideFromLeft );

    HbEffect::start( mRightButton, KSlideFromRight );

}

/*!

 * \reimp

 */

void RadioFrequencyStrip::updateItemPrimitive( QGraphicsItem* itemToUpdate, int itemIndex )

{

    QGraphicsPixmapItem* item = static_cast<QGraphicsPixmapItem*>( itemToUpdate );

    if ( itemIndex < mFrequencyItems.count() ) {

        item->setPixmap( mFrequencyItems.at( itemIndex )->updatePrimitive( item ) );

    }

}

/*!

 * \reimp

 */

QGraphicsItem* RadioFrequencyStrip::createItemPrimitive( QGraphicsItem* parent )

{

    return new QGraphicsPixmapItem( parent );

}

/*!

 * \reimp

 */

void RadioFrequencyStrip::scrollPosChanged( QPointF newPosition )

{

    Q_UNUSED( newPosition );

    if ( isDragging() ) {

        const int pos = selectorPos();

        emitFrequencyChanged( mPositions.value( pos ) );

    }

}

/*!

 * \reimp

 */

void RadioFrequencyStrip::resizeEvent ( QGraphicsSceneResizeEvent* event )

{

    LOG_METHOD_ENTER;

    RadioStripBase::resizeEvent( event );

    mSelectorPos = event->newSize().width() / 2;

    mSelectorImage->setOffset( mSelectorPos - (KIndicatorWidth / 2), 0.0 );

    const int stripHeight = event->newSize().height();

    if ( !mLeftButtonIcon.isNull() ) {

//        mLeftButtonIcon.setSize( QSizeF( stripHeight, stripHeight ) );

        mLeftButton->resize( stripHeight, stripHeight );

        mLeftButton->setBackground( mLeftButtonIcon );

    }

    if ( !mRightButtonIcon.isNull() ) {

//        mRightButtonIcon.setSize( QSizeF( stripHeight, stripHeight ) );

        mRightButton->resize( stripHeight, stripHeight );

        mRightButton->setBackground( mRightButtonIcon );

    }

    mRightButton->setPos( QPointF( size().width() - mRightButton->size().width(), 0 ) );

    scrollToFrequency( mFrequency, 0 );

}

/*!

 * \reimp

 */

void RadioFrequencyStrip::showEvent( QShowEvent* event )

{

    Q_UNUSED( event );

    scrollToFrequency( mFrequency, 0 );

}

/*!

 * \reimp

 */

void RadioFrequencyStrip::mousePressEvent( QGraphicsSceneMouseEvent* event )

{

    RadioStripBase::mousePressEvent( event );

    mIsPanGesture = false;

    mButtonTimer->stop();

    HbEffect::start( mLeftButton, KSlideToLeft );

    HbEffect::start( mRightButton, KSlideToRight );

}

/*!

 * \reimp

 */

void RadioFrequencyStrip::mouseReleaseEvent( QGraphicsSceneMouseEvent* event )

{

    RadioStripBase::mouseReleaseEvent( event );

    // Check if the selector is in the invalid area where the strip loops around

    const int selectorPosition = selectorPos();

    if ( !mPositions.contains( selectorPosition ) ) {

        if ( selectorPosition < mMaxWidth - KWidth + mSeparatorPos ) {

            scrollToFrequency( mMaxFrequency, 500 );

            emitFrequencyChanged( mMaxFrequency );

        } else {

            scrollToFrequency( mMinFrequency, 500 );

            emitFrequencyChanged( mMinFrequency );

        }

    }

//    if ( !mIsPanGesture ) {

//        const qreal touchDelta = event->pos().x() - mSelectorPos;

//        const int touchPos = selectorPosition + touchDelta;

//        const uint frequencyAtPos = mPositions.value( touchPos );

//

//        uint foundFrequency = 0;

//        for ( int i = 0; i < 10; ++i ) {

//            const uint delta = i * mFrequencyStepSize;

//            FrequencyPos leftFreq = mFrequencies.value( frequencyAtPos - delta );

//            FrequencyPos rightFreq = mFrequencies.value( frequencyAtPos + delta );

//

//            if ( touchPos - leftFreq.mPosition > KTouchPosThreshold ) {

//                break;

//            }

//

//            if ( leftFreq.mFavorite || leftFreq.mLocalStation ) {

//                foundFrequency = frequencyAtPos - delta;

//                break;

//            } else if ( rightFreq.mFavorite || rightFreq.mLocalStation ) {

//                foundFrequency = frequencyAtPos + delta;

//                break;

//            }

//        }

//

//        if ( foundFrequency > 0 ) {

//            setFrequency( foundFrequency, 0 );

//        }

//    }

    mButtonTimer->stop();

    mButtonTimer->start();

}

/*!

 *

 */

void RadioFrequencyStrip::initModel()

{

    const uint minFreq = uint( qreal(mMinFrequency) / KOneHertz + KRounder );

    const uint maxFreq = uint( qreal(mMaxFrequency) / KOneHertz + 0.9 ); // always round up

    QStringList list;

    QString freqText;

    for ( uint i = minFreq; i <= maxFreq; ++i ) {

        freqText = QString::number( i );

        list.append( freqText );

        mFrequencyItems.append( new RadioFrequencyItem( freqText ) );

    }

    mFrequencyItems.append( new RadioFrequencyItem( "" ) );

    list.append( "" );

    mMaxWidth = list.count() * KWidth;

    mSeparatorPos = qreal(KWidth) / 2;

    const uint minDrawableFreq = minFreq * KOneHertz - KHalfHertz;;

    const uint maxDrawableFreq = maxFreq * KOneHertz + KHalfHertz;

    mSeparatorPos += qreal( ( mMinFrequency  - minDrawableFreq ) / 2 ) / KPixelInHz;

    mSeparatorPos -= qreal( ( maxDrawableFreq - mMaxFrequency ) / 2 ) / KPixelInHz;

    setModel( new QStringListModel( list, this ) );

}

/*!

 *

 */

void RadioFrequencyStrip::initSelector()

{

    QPixmap selectorPixmap = QPixmap( QSize( KSelectorWidth, KHeight ) );

    selectorPixmap.fill( Qt::red );

    mSelectorImage->setPixmap( selectorPixmap );

    mSelectorImage->setZValue( KSelectorZPos );

}

/*!

 *

 */

void RadioFrequencyStrip::initItems()

{

    LOG_METHOD;

    foreach ( RadioFrequencyItem* item, mFrequencyItems ) {

        updateFavorites( item );

    }

        foreach ( const RadioStation& station, stations ) {

            if ( station.isFavorite() ) {

                mFrequencies[ station.frequency() ].mFavorite = true;

            }

            if ( station.isType( RadioStation::LocalStation ) ) {

                mFrequencies[ station.frequency() ].mLocalStation = true;

            }

        }

    }

    int prevPos = 0;

    int nextPos = 0;

    const int lastPos = mFrequencies.value( mMaxFrequency ).mPosition;

    for ( int i = mFrequencies.value( mMinFrequency ).mPosition; i < lastPos; ++i ) {

        if ( mPositions.contains( i ) ) {

            prevPos = i;