#include <QGraphicsSceneResizeEvent>

#include <HbSwipeGesture>

#include <HbFontSpec>

#include "radiocarouselanimator.h"

#include "radiocarouselitem.h"

#include "radioutil.h"

// Constants

const int RTPLUS_CHECK_TIMEOUT = 700;

const int INFOTEXT_NOFAVORITES_TIMEOUT = 5000;

const int SET_FREQUENCY_TIMEOUT = 500;

const int FAVORITE_HINT_SHOW_DELAY = 1000;

const int FAVORITE_HINT_HIDE_DELAY = 2000;

#ifdef BUILD_WIN32

#   define SCROLLBAR_POLICY ScrollBarAlwaysOn

#else

#   define SCROLLBAR_POLICY ScrollBarAlwaysOff

#endif // BUILD_WIN32

#define CALL_TO_ALL_ITEMS( expr ) \

    mItems[LeftItem]->expr; \

    mItems[CenterItem]->expr; \

    mItems[RightItem]->expr;

RadioStationCarousel::RadioStationCarousel( QGraphicsItem* parent ) :

    HbScrollArea( parent ),

    mUiEngine( NULL ),

    mAnimator( NULL ),

    mInfoText( NULL ),

    mContainer( new HbWidget( this ) ),

    mMidScrollPos( 0 ),

    mMaxScrollPos( 0 ),

    mCurrentIndex( 0 ),

    mTargetIndex( -1 ),

    mIsCustomFreq( false ),

    mInfoTextType( CarouselInfoText::None ),

    mModel( NULL ),

    mPosAdjustmentDisabled( false ),

    mScrollDirection( Scroll::Shortest ),

    mManualSeekMode( false ),

    mAlternateSkipping( false )

    RadioUtil::setCarousel( this );

    mItems[LeftItem] = new RadioCarouselItem( *this );

    mItems[CenterItem] = new RadioCarouselItem( *this );

    mItems[RightItem] = new RadioCarouselItem( *this );

    QGraphicsLinearLayout* layout = new QGraphicsLinearLayout( Qt::Horizontal );

    layout->setContentsMargins( 0, 0, 0, 0 );

    layout->setSpacing( 0 );

    layout->addItem( mItems[LeftItem] );

    layout->addItem( mItems[CenterItem] );

    layout->addItem( mItems[RightItem] );

    mContainer->setLayout( layout );

    setContentWidget( mContainer );

    setClampingStyle( HbScrollArea::NoClamping );

    setScrollDirections( Qt::Horizontal );

    setFrictionEnabled( true );

    setHorizontalScrollBarPolicy( HbScrollArea::SCROLLBAR_POLICY );

    setVerticalScrollBarPolicy( HbScrollArea::ScrollBarAlwaysOff );

#ifdef BUILD_WIN32

    HbFontSpec spec = mInfoText->fontSpec();

    spec.setRole( HbFontSpec::Secondary );

    mInfoText->setFontSpec( spec );

#endif

//    grabGesture( Qt::SwipeGesture );

//    Radio::connect( this,           SIGNAL(scrollPositionChanged(QPointF)),

//                    this,           SLOT(scrollPosChanged(QPointF)) );

    Radio::connect( this,           SIGNAL(scrollingEnded()),

                    this,           SLOT(adjustAfterScroll()) );

    mModel = &mUiEngine->stationModel();

    Radio::connect( mModel,         SIGNAL(favoriteChanged(RadioStation)),

    Radio::connect( mModel,         SIGNAL(stationDataChanged(RadioStation)),

    Radio::connect( mModel,         SIGNAL(radioTextReceived(RadioStation)),

    Radio::connect( mModel,         SIGNAL(dynamicPsChanged(RadioStation)),

    Radio::connect( mGenericTimer,  SIGNAL(timeout()),

    Radio::connect( mModel,         SIGNAL(rowsInserted(QModelIndex,int,int)),

                    this,           SLOT(updateStations()) );

    Radio::connect( mModel,         SIGNAL(modelReset()),

                    this,           SLOT(updateStations()) );

    Radio::connect( mModel,         SIGNAL(rowsRemoved(QModelIndex,int,int)),

                    this,           SLOT(updateStations()) );

    setFrequency( mUiEngine->currentFrequency(), TuneReason::Unspecified );

        Radio::connect( mUiEngine,      SIGNAL(rdsAvailabilityChanged(bool)),

void RadioStationCarousel::setFrequency( uint frequency, int reason, Scroll::Direction direction )

    if ( mModel ) {

        if ( !mManualSeekMode ) {

            if ( mModel->rowCount() <= 1 ) {

                mItems[LeftItem]->setStation( RadioStation() );

                mItems[RightItem]->setStation( RadioStation() );

            }

            mIsCustomFreq = false;

            if ( reason == TuneReason::Skip || reason == TuneReason::StationScanFinalize ) {

                const int newIndex = mModel->indexFromFrequency( frequency );

                scrollToIndex( newIndex, direction, NoSignal );

                mCurrentIndex = newIndex;

            } else {

                if ( mModel->contains( frequency ) ) {

                    mCurrentIndex = mModel->indexFromFrequency( frequency );

                } else {

                    const RadioStation prevStation = mModel->findClosest( frequency, StationSkip::Previous );

                    if ( prevStation.isValid() ) {

                        mCurrentIndex = mModel->indexFromFrequency( prevStation.frequency() );

                    } else {

                        mCurrentIndex = -1;

                    }

                    mIsCustomFreq = true;

                }

                mItems[CenterItem]->setFrequency( frequency );

                mTimerMode = SetFrequency;

                mGenericTimer->stop();

                mGenericTimer->start( SET_FREQUENCY_TIMEOUT );

            }

            mItems[CenterItem]->setFrequency( frequency );

    return mUiEngine->isAntennaAttached();

    CALL_TO_ALL_ITEMS( setSeekLayout( scanning ) );

        if ( !mAnimator ) {

            mAnimator = new RadioCarouselAnimator( *this );

        mAnimator->startFlashingText();

        if ( mAnimator ) {

            mAnimator->stopFlashingText();

        }

        setCenterIndex( 0 );

        mTimerMode = FavoriteHintShow;

        mGenericTimer->start( FAVORITE_HINT_SHOW_DELAY );

    return RadioUtil::scanStatus() == Scan::ScanningInMainView;

    mItems[CenterItem]->cleanRdsData();

    if ( mAnimator && mUiEngine ) {

        const uint previousFrequency = mItems[CenterItem]->frequency();

        mItems[RightItem]->setFrequency( previousFrequency );

        mCurrentIndex = mModel->indexFromFrequency( station.frequency() );

        mAnimator->startNumberScroll( previousFrequency, station.frequency() );

void RadioStationCarousel::cancelAnimation()

    if ( mAnimator ) {

        mAnimator->stopAll();

    if ( type == CarouselInfoText::NoFavorites || type == CarouselInfoText::FavoriteIconHint ) {

//        mInfoText->setPlainText( hbTrId( "txt_rad_dialog_long_press_arrow_keys_to_search_str" ) );

    //TODO: Remove hardcoding. Temporarily hardcoded for usability testing

        mInfoText->setPlainText( "Tap star to mark favourites" );

        mItems[CenterItem]->setItemVisibility( RadioCarouselItem::IconVisible );

        if ( !mAnimator ) {

            mAnimator = new RadioCarouselAnimator( *this );

        }

        mAnimator->startFlashingIcon();

    } else if ( type == CarouselInfoText::ManualSeek ) {

        mInfoText->setAlignment( Qt::AlignBottom | Qt::AlignHCenter );

        mInfoText->setPlainText( "Manual Seek Mode" );

        if ( mAnimator ) {

            mAnimator->stopFlashingIcon();

        }

        mItems[CenterItem]->setItemVisibility( RadioCarouselItem::AllVisible );

    }

}

/*!

 *

 */

void RadioStationCarousel::setManualSeekMode( bool manualSeekActive )

{

    mManualSeekMode = manualSeekActive;

    setEnabled( !manualSeekActive );

    mItems[CenterItem]->setSeekLayout( manualSeekActive );

    if ( manualSeekActive ) {

        setInfoText( CarouselInfoText::ManualSeek );

    } else {

        clearInfoText();

        setFrequency( mUiEngine->currentFrequency(), TuneReason::Unspecified );

    }

}

/*!

 * TODO: Remove this! This is test code

 */

void RadioStationCarousel::setAlternateSkippingMode( bool alternateSkipping )

{

    mAlternateSkipping = alternateSkipping;

}

/*!

 * Private slot

 *

 */

void RadioStationCarousel::scrollPosChanged( const QPointF& newPosition )

{

    Q_UNUSED( newPosition );

//    const int xPos = static_cast<int>( newPosition.x() );

//    mItems[CenterItem]->setPos( xPos - mMidScrollPos, 0 );

}

/*!

 * Private slot

 ''

 */

void RadioStationCarousel::adjustAfterScroll()

{

    if ( isInScanningMode() ) {

        return;

    }

    if ( mTargetIndex != -1 ) {

        setCenterIndex( mTargetIndex );

 *

    if ( !mManualSeekMode && !isInScanningMode() ) {

        for ( int i = LeftItem; i <= RightItem; ++i ) {

            if ( mItems[i]->frequency() == station.frequency() ) {

                mItems[i]->update( &station );

            }

        }

            mItems[CenterItem]->setRadioText( "" );

            mGenericTimer->setInterval( RTPLUS_CHECK_TIMEOUT );

void RadioStationCarousel::updateStations()

    if ( isInScanningMode() ) {

        return;

    setFrequency( mUiEngine->currentFrequency(), TuneReason::Unspecified );