#include <HbMenu>

#include <QApplication>

#include "radioutil.h"

    mFrequencyStrip( NULL ),

    mSkippingAction( NULL ),

    mAlternateSkipping( false )

        const bool firsTimeStart = mUiEngine->isFirstTimeStart();

        const int rowCount = mUiEngine->stationModel().rowCount();

        if ( firsTimeStart && rowCount != 0 ) {

            mUiEngine->setFirstTimeStartPerformed( true );

        }

    loadSection( DOCML::FILE_MAINVIEW, DOCML::SECTION_LAZY_LOAD );

    mCarousel->init( *mUiLoader, mUiEngine.data() );

    mFrequencyStrip->init( mUiEngine.data(), *mUiLoader );

    RadioStationModel* stationModel = &mUiEngine->stationModel();

    Radio::connect( mFrequencyStrip,            SIGNAL(frequencyChanged(uint,int,int)),

                    this,                       SLOT(setFrequencyFromWidget(uint,int,int)) );

    Radio::connect( mCarousel,                  SIGNAL(frequencyChanged(uint,int,int)),

                    this,                       SLOT(setFrequencyFromWidget(uint,int,int)) );

    Radio::connect( mUiEngine.data(),           SIGNAL(tunedToFrequency(uint,int)),

                    this,                       SLOT(setFrequencyFromEngine(uint,int)) );

    Radio::connect( mFrequencyStrip,            SIGNAL(manualSeekChanged(bool)),

                    this,                       SLOT(setManualSeekMode(bool)) );

    Radio::connect( mFrequencyStrip,            SIGNAL(skipRequested(int)),

                    this,                       SLOT(skip(int)) );

    Radio::connect( mCarousel,                  SIGNAL(skipRequested(int)),

                    this,                       SLOT(skip(int)) );

    Radio::connect( mFrequencyStrip,            SIGNAL(seekRequested(int)),

                    mUiEngine.data(),           SLOT(seekStation(int)) );

    Radio::connect( mUiEngine.data(),           SIGNAL(seekingStarted(int)),

    Radio::connect( mUiEngine.data(),           SIGNAL(antennaStatusChanged(bool)),

                    this,                       SLOT(updateAntennaStatus(bool)) );

    Radio::connect( mUiEngine.data(),           SIGNAL(audioRouteChanged(bool)),

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

                    this,                       SLOT(handleFavoriteChange(RadioStation)) );

    connectXmlElement( DOCML::MV_NAME_STATIONS_BUTTON,  SIGNAL(clicked()),

                       mMainWindow,                     SLOT(activateStationsView()) );

    connectXmlElement( DOCML::MV_NAME_SCAN_BUTTON,      SIGNAL(clicked()),

                       this,                            SLOT(toggleScanning()) );

    connectXmlElement( DOCML::MV_NAME_SPEAKER_BUTTON,   SIGNAL(clicked()),

                       mUiEngine.data(),                SLOT(toggleAudioRoute()) );

    connectCommonMenuItem( MenuItem::Exit );

    //TODO: REMOVE. THIS IS TEMPORARY TEST CODE

    toggleSkippingMode();

    menu()->addAction( "Reset start count", this, SLOT(resetFirstTimeCount()) );

    // END TEMPORARY TEST CODE

    updateAudioRoute( mUiEngine->isUsingLoudspeaker() );

#ifdef BUILD_WIN32

    Radio::connect( backAction,     SIGNAL(triggered()),

                    this,           SLOT(quit()) );

#else

    Radio::connect( backAction,     SIGNAL(triggered()),

#endif // BUILD_WIN32

    const bool firsTimeStart = mUiEngine->isFirstTimeStart();

    const int rowCount = mUiEngine->stationModel().rowCount();

    emit applicationReady();

    if ( mCarousel && mFrequencyStrip ) {

        mCarousel->setFrequency( mFrequencyStrip->frequency(), TuneReason::Unspecified );

    }

    mFrequencyScanner.reset( new RadioFrequencyScanner( *mUiEngine, this ) );

 * \reimp

 *

 */

bool RadioMainView::eventFilter( QObject* watched, QEvent* event )

{

    if ( event->type() == QEvent::ApplicationDeactivate ) {

        mFrequencyStrip->cancelManualSeek();

    }

    return RadioViewBase::eventFilter( watched, event );

}

/*!

void RadioMainView::setFrequencyFromWidget( uint frequency, int reason, int direction )

//    LOG_FORMAT( "RadioMainView::setFrequencyFromWidget: %u, reason = %d", frequency, reason );

    if ( !RadioUtil::isScannerAlive() ) {

//            mCarousel->setFrequency( frequency, reason, direction );

//            mUiEngine->tuneWithDelay( frequency, reason );

        } else if ( reason == TuneReason::ManualSeekUpdate ) {

            mCarousel->setFrequency( frequency, reason, RadioUtil::scrollDirection( direction ) );

        } else if ( reason == TuneReason::ManualSeekTune ) {

            LOG_FORMAT( "--------Manual seek tune: %u", frequency );

            mUiEngine->setFrequency( frequency, reason );

            mFrequencyStrip->setFrequency( frequency, reason, RadioUtil::scrollDirection( direction ) );

            mUiEngine->setFrequency( frequency, reason );

    LOG_FORMAT( "RadioMainView::setFrequencyFromEngine reason: %d", reason );

    if ( !RadioUtil::isScannerAlive() && !mFrequencyStrip->isInManualSeekMode() ) {

            mCarousel->setFrequency( frequency, reason, Scroll::Shortest );

            mFrequencyStrip->setFrequency( frequency, reason, Scroll::Shortest );

//    if ( !mAlternateSkipping && ( skipMode == StationSkip::PreviousFavorite || skipMode == StationSkip::NextFavorite ) &&

//        mUiEngine->stationModel().favoriteCount() == 0 ) {

//        mCarousel->setInfoText( CarouselInfoText::NoFavorites );

//    } else {

        RadioStation station;

        mUiEngine->stationModel().findFrequency( currentFrequency, station );

        if ( mAlternateSkipping ) { //TODO: Remove. Temporary test code

            if ( sender() == mFrequencyStrip ) {

                if ( skipMode == StationSkip::NextFavorite ) {

                    skipMode = StationSkip::Next;

                } else if ( skipMode == StationSkip::PreviousFavorite ) {

                    skipMode = StationSkip::Previous;

                }

            } else if ( sender() == mCarousel ) {

                if ( skipMode == StationSkip::Next ) {

                    skipMode = StationSkip::NextFavorite;

                } else if ( skipMode == StationSkip::Previous ) {

                    skipMode = StationSkip::PreviousFavorite;

                }

            }

        }

        const uint frequency = mUiEngine->skipStation( static_cast<StationSkip::Mode>( skipMode ),

                                                                currentFrequency);

        if ( currentFrequency != frequency || station.isFavorite() ) {

            const Scroll::Direction direction = RadioUtil::scrollDirectionFromSkipMode( skipMode );

            mCarousel->setFrequency( frequency, TuneReason::Skip, direction );

            mFrequencyStrip->setFrequency( frequency, TuneReason::Skip, direction );

        }

//    }

}

/*!

 * Private slot

 */

void RadioMainView::openStationsView()

{

    mFrequencyStrip->cancelManualSeek();

    mMainWindow->activateStationsView();

    mFrequencyStrip->cancelManualSeek();

        const int rowCount =  mUiEngine->stationModel().rowCount();

    if ( !RadioUtil::isScannerAlive() ) {

void RadioMainView::updateAntennaStatus( bool connected )

{

    if ( !connected ) {

        mFrequencyStrip->cancelManualSeek();

    }

    HbPushButton* scanButton = mUiLoader->findWidget<HbPushButton>( DOCML::MV_NAME_SCAN_BUTTON );

    scanButton->setEnabled( connected );

    mCarousel->updateAntennaStatus( connected );

}

/*!

 * Private slot

 */

        loudspeakerButton->setIcon( HbIcon( "qtg_mono_speaker_off" ) );

        loudspeakerButton->setIcon( HbIcon( "qtg_mono_speaker" ) );

/*!

 * Private slot

 */

void RadioMainView::setManualSeekMode( bool manualSeekActive )

{

    if ( manualSeekActive ) {

        qApp->installEventFilter( this );

    } else {

        qApp->removeEventFilter( this );

    }

    mUiEngine->setManualSeekMode( manualSeekActive );

    mCarousel->setManualSeekMode( manualSeekActive );

}

/*!

 * Private slot

 */

void RadioMainView::handleFavoriteChange( const RadioStation& station )

{

    mFrequencyStrip->updateFavorite( station );

    if ( station.isFavorite() ) {

        RadioUtil::showDiscreetNote( "Station added to Favourites." );

    } else {

        RadioUtil::showDiscreetNote( "Station removed from Favourites." );

    }

}

/*!

 * Private slot

 */

void RadioMainView::toggleSkippingMode()

{

    if ( !mSkippingAction ) {

        mSkippingAction = menu()->addAction( "", this, SLOT(toggleSkippingMode()) );

    }

    mAlternateSkipping = !mAlternateSkipping;

    mCarousel->setAlternateSkippingMode( mAlternateSkipping );

    if ( mAlternateSkipping ) {

        mSkippingAction->setText( "Normal skipping mode" );

    } else {

        mSkippingAction->setText( "Alternate skipping mode" );

    }

}

/*!

 * Private slot

 */

void RadioMainView::resetFirstTimeCount()

{

    mUiEngine->setFirstTimeStartPerformed( false );

}