/*

* 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 <QScopedPointer>

#include <QProcess>

#include <QFile>

#include <QTimer>

#ifdef BUILD_WIN32

#   include <QSettings>

#else

#   include <XQSettingsManager>

#endif // WIN32_BUILD

// User includes

#include "radiouiengine.h"

#include "radiouiengine_p.h"

#include "radioenginewrapper.h"

#include "radiostationmodel.h"

#include "radiohistorymodel.h"

#include "radiohistoryitem.h"

#include "radiosettings.h"

#include "radioscannerengine.h"

#include "radiogenrelocalizer.h"

#include "radiologger.h"

// Constants

const uint DEFAULT_MIN_FREQUENCY = 87500000;

const uint RADIO_CENREP_UID = 0x2002FF52;

const uint RADIO_CENREP_FREQUENCY_KEY = 0x207;

/*!

 *

 */

uint RadioUiEngine::lastTunedFrequency()

{

    uint frequency = DEFAULT_MIN_FREQUENCY;

#ifdef BUILD_WIN32

    QScopedPointer<QSettings> settings( new QSettings( "Nokia", "QtFmRadio" ) );

    frequency = settings->value( "CurrentFreq", DEFAULT_MIN_FREQUENCY ).toUInt();

    if ( frequency == 0 ) {

        frequency = DEFAULT_MIN_FREQUENCY;

    }

#else

    QScopedPointer<XQSettingsManager> settings( new XQSettingsManager() );

    XQSettingsKey key( XQSettingsKey::TargetCentralRepository, RADIO_CENREP_UID, RADIO_CENREP_FREQUENCY_KEY );

    frequency = settings->readItemValue( key, XQSettingsManager::TypeInt ).toUInt();

    if ( frequency == 0 ) {

        frequency = DEFAULT_MIN_FREQUENCY;

    }

#endif

    return frequency;

}

/*!

 *

 */

RadioUiEngine::RadioUiEngine( QObject* parent ) :

    QObject( parent ),

    d_ptr( new RadioUiEnginePrivate( this ) )

{

}

/*!

 *

 */

RadioUiEngine::~RadioUiEngine()

{

}

/*!

 *

 */

bool RadioUiEngine::isInitialized() const

{

    Q_D( const RadioUiEngine );

    return !d->mEngineWrapper.isNull();

}

/*!

 *

 */

bool RadioUiEngine::init()

{

    Q_D( RadioUiEngine );

    return d->init();

}

/*!

 *

 */

bool RadioUiEngine::isFirstTimeStart()

{

    Q_D( RadioUiEngine );

    return d->mEngineWrapper->settings().isFirstTimeStart();

}

/*!

 *

 */

void RadioUiEngine::setFirstTimeStartPerformed( bool firstTimeStartPerformed )

{

    Q_D( RadioUiEngine );

    d->mEngineWrapper->settings().setFirstTimeStartPerformed( firstTimeStartPerformed );

}

/*!

 *

 */

void RadioUiEngine::setPowerOn()

{

    setMute( false );

    Q_D( RadioUiEngine );

    if ( d->mPowerOffTimer ) {

        d->mPowerOffTimer->stop();

        d->mPowerOffTimer->deleteLater();

        d->mPowerOffTimer = NULL;

    }

}

/*!

 *

 */

void RadioUiEngine::setPowerOff( int delay )

{

    Q_D( RadioUiEngine );

    d->mEngineWrapper->setMute( true, false );

    if ( delay > 0 ) {

        if ( !d->mPowerOffTimer ) {

            d->mPowerOffTimer = new QTimer( this );

            Radio::connect( d->mPowerOffTimer,  SIGNAL(timeout()),

                            this,               SIGNAL(powerOffRequested()) );

        }

        d->mPowerOffTimer->start( delay );

    } else {

        emit powerOffRequested();

    }

}

/*!

 *

 */

bool RadioUiEngine::isPoweringOff() const

{

    Q_D( const RadioUiEngine );

    return d->mPowerOffTimer && d->mPowerOffTimer->isActive();

}

/*!

 * Returns the settings handler owned by the engine

 */

RadioSettingsIf& RadioUiEngine::settings()

{

    Q_D( RadioUiEngine );

    return d->mEngineWrapper->settings();

}

/*!

 * Returns the station model

 */

RadioStationModel& RadioUiEngine::stationModel()

{

    Q_D( RadioUiEngine );

    return *d->mStationModel;

}

/*!

 * Returns the history model

 */

RadioHistoryModel& RadioUiEngine::historyModel()

{

    Q_D( RadioUiEngine );

    return *d->mHistoryModel;

}

/*!

 */

{

    Q_D( RadioUiEngine );

    if ( !d->mScannerEngine ) {

    }

    return d->mScannerEngine;

}

/*!

 *

 */

RadioScannerEngine* RadioUiEngine::scannerEngine()

{

    Q_D( RadioUiEngine );

    return d->mScannerEngine.data();

}

/*!

 *

 */

bool RadioUiEngine::isRadioOn() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->isRadioOn();

}

/*!

 *

 */

bool RadioUiEngine::isScanning() const

{

    Q_D( const RadioUiEngine );

    if ( d->mScannerEngine ) {

    }

    return false;

}

/*!

 *

 */

bool RadioUiEngine::isMuted() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->isMuted();

}

/*!

 *

 */

bool RadioUiEngine::isAntennaAttached() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->isAntennaAttached();

}

/*!

 *

 */

bool RadioUiEngine::isUsingLoudspeaker() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->isUsingLoudspeaker();

}

/*!

 * Returns the selected radio region

 */

RadioRegion::Region RadioUiEngine::region() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->region();

}

/*!

 * Returns the currently tuned frequency

 */

uint RadioUiEngine::currentFrequency() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->currentFrequency();

}

/*!

 * Returns the minimum frequency

 */

uint RadioUiEngine::minFrequency() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->minFrequency();

}

/*!

 * Returns the maximum frequency

 */

uint RadioUiEngine::maxFrequency() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->maxFrequency();

}

/*!

 * Returns the frequency step size from the selected region

 */

uint RadioUiEngine::frequencyStepSize() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->frequencyStepSize();

}

/*!

 * Sets the mute status

 */

void RadioUiEngine::setMute( bool muted )

{

    Q_D( RadioUiEngine );

    d->mEngineWrapper->setMute( muted );

}

/*!

 *

 */

QList<RadioStation> RadioUiEngine::stationsInRange( uint minFrequency, uint maxFrequency )

{

    Q_D( RadioUiEngine );

    return d->mStationModel->stationsInRange( minFrequency, maxFrequency );

}

/*!

 *

 */

QString RadioUiEngine::genreToString( int genre, GenreTarget::Target target )

{

    return RadioGenreLocalizer::genreToString( region(), genre, target );

}

/*!

 *

 */

bool RadioUiEngine::isSongRecognitionAppAvailable()

{

    //TODO: Implement Shazam support

    return false;

}

/*!

 *

 */

void RadioUiEngine::addRecognizedSong( const QString& artist, const QString& title, const RadioStation& station )

{

    Q_D( RadioUiEngine );

    d->mHistoryModel->addItem( artist, title, station );

}

/*!

 *

 */

uint RadioUiEngine::skipStation( StationSkip::Mode mode, uint startFrequency )

{

    Q_D( RadioUiEngine );

    return d->skip( mode, startFrequency );

}

/*!

 *

 */

void RadioUiEngine::openMusicStore( const RadioHistoryItem& item, MusicStore store )

{

}

/*!

 * Sets or unsets the engine to manual seek mode

 */

void RadioUiEngine::setManualSeekMode( bool manualSeek )

{

    Q_D( RadioUiEngine );

    d->mEngineWrapper->setManualSeekMode( manualSeek );

}

/*!

 * Checks if the engine is in manual seek mode

 */

bool RadioUiEngine::isInManualSeekMode() const

{

    Q_D( const RadioUiEngine );

    return d->mEngineWrapper->isInManualSeekMode();

}

/*!

 * Tunes the radio engine to given frequency

 */

void RadioUiEngine::setFrequency( uint frequency, const int reason )

{

    Q_D( RadioUiEngine );

    if ( frequency != d->mStationModel->currentStation().frequency() && d->mEngineWrapper->isFrequencyValid( frequency ) ) {

        LOG_FORMAT( "RadioUiEngine::tuneFrequency, frequency: %d", frequency );

        d->cancelSeeking();

        d->mEngineWrapper->setFrequency( frequency, reason );

    }

}

/*!

 * Public slot

 * volume update command slot for the engine

 */

void RadioUiEngine::setVolume( int volume )

{

    Q_D( RadioUiEngine );

    d->mEngineWrapper->setVolume( volume );

}

/*!

 * Public slot

 *

 */

void RadioUiEngine::toggleMute()

{

    Q_D( RadioUiEngine );

    if ( !isScanning() ) {

        d->mEngineWrapper->setMute( !d->mEngineWrapper->isMuted() );

    }

}

/*!

 * Public slot

 *

 */

void RadioUiEngine::toggleAudioRoute()

{

    Q_D( RadioUiEngine );

    d->mEngineWrapper->toggleAudioRoute();

}

/*!

 * Public slot

 *

 */

void RadioUiEngine::seekStation( int seekDirection )

{

    if ( isAntennaAttached() ) {

        Q_D( RadioUiEngine );

        Seek::Direction direction = static_cast<Seek::Direction>( seekDirection );

        emitSeekingStarted( direction );

        d->mEngineWrapper->startSeeking( direction, TuneReason::Seek );

    }

}

/*!

 * Public slot

 *

 */

void RadioUiEngine::launchSongRecognition()

{

    //TODO: Implement Shazam support

}

/*!

 * Function used by the private implementation to emit a tunedToFrequency signal

 */

void RadioUiEngine::emitTunedToFrequency( uint frequency, int commandSender )

{

    emit tunedToFrequency( frequency, commandSender );

}

/*!

 * Function used by the private implementation to emit a seekingStarted signal

 */

void RadioUiEngine::emitSeekingStarted( Seek::Direction direction )

{

    emit seekingStarted( direction );

}

/*!

 * Function used by the private implementation to emit a radioStatusChanged signal

 */

void RadioUiEngine::emitRadioStatusChanged( bool radioIsOn )

{

    emit radioStatusChanged( radioIsOn );

}

/*!

 * Function used by the private implementation to emit a rdsAvailabilityChanged signal

 */

void RadioUiEngine::emitRdsAvailabilityChanged( bool available )

{