/*
* 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 <qtimer>
#include <qsettings>

// User includes
#include "radioenginewrapper_win32_p.h"
#include "radiosettings.h"
#include "radiosettings_p.h"
#include "radiologger.h"
#include "radio_global.h"
#include "radiostationhandlerif.h"
#include "radioenginewrapperobserver.h"
//#include "t_radiodataparser.h"

static RadioEngineWrapperPrivate* theInstance = 0;

const QString KKeyFrequency = "CurrentFreq";
const QString KKeyOffline = "Offline";

/*!
 *
 */
RadioEngineWrapperPrivate::RadioEngineWrapperPrivate( RadioEngineWrapper* wrapper,
                                                      RadioStationHandlerIf& stationHandler,
                                                      RadioEngineWrapperObserver& observer ) :
    q_ptr( wrapper ),
    mStationHandler( stationHandler ),
    mObserver( observer ),
    mTuneTimer( new QTimer( this ) ),
    mCommandSender( 0 ),
    mUseLoudspeaker( false ),
    mIsSeeking( false ),
    mAntennaAttached( true ),
    mFrequency( 0 ),
    mVolume( 5 ),
    mMaxVolume( 10000 ),
    mFrequencyStepSize( 50000 ),
    mRegionId( RadioRegion::Default ),
    mMinFrequency( 87500000 ),
    mMaxFrequency( 108000000 )
{
    ::theInstance = this;
    mEngineSettings.reset( new QSettings( "Nokia", "QtFmRadio" ) );
    mFrequency = mEngineSettings->value( KKeyFrequency ).toUInt();
    if ( mFrequency == 0 ) {
        mFrequency = mMinFrequency;
    }

    connectAndTest( mTuneTimer, SIGNAL(timeout()), this, SLOT(frequencyEvent()) );
    mTuneTimer->setSingleShot( true );    
}

/*!
 *
 */
RadioEngineWrapperPrivate::~RadioEngineWrapperPrivate()
{
    // Destructor needs to be defined because some member variables that are forward declared
    // in the header are managed by QT's smart pointers and they require that the owning class
    // has a non-inlined destructor. Compiler generates an inlined destructor if it isn't defined.
}

/*!
 *
 */
RadioEngineWrapperPrivate* RadioEngineWrapperPrivate::instance()
{
    return ::theInstance;
}

/*!
 * Initializes the private implementation
 */
void RadioEngineWrapperPrivate::init()
{
    mUseLoudspeaker = false;
    if ( !mUseLoudspeaker ) {
        mObserver.audioRouteChanged( false );
    }

    parseData();
}

/*!
 * Starts up the radio engine
 */
bool RadioEngineWrapperPrivate::isEngineConstructed()
{
    return true;
}

/*!
 * Returns the settings handler owned by the engine
 */
RadioSettings& RadioEngineWrapperPrivate::settings()
{
    if ( !mSettings ) {
        mSettings.reset( new RadioSettings() );
//        mSettings->d_func()->init( &mEngineHandler->ApplicationSettings() );
    }
    return *mSettings;
}

/*!
 * Tunes to the given frequency
 */
void RadioEngineWrapperPrivate::tuneFrequency( uint frequency, const int sender )
{
    mFrequency = frequency;
    mEngineSettings->setValue( KKeyFrequency, mFrequency );
    mCommandSender = sender;
    mTuneTimer->stop();
    mTuneTimer->start( 500 );
}

/*!
 * Tunes to the given frequency after a delay
 */
void RadioEngineWrapperPrivate::tuneWithDelay( uint frequency, const int sender )
{
    mFrequency = frequency;
    mEngineSettings->setValue( KKeyFrequency, mFrequency );
    mCommandSender = sender;
    mTuneTimer->stop();
    mTuneTimer->start( 1500 );
}

/*!
 *
 */
RadioEngineWrapperObserver& RadioEngineWrapperPrivate::observer()
{
    return mObserver;
}

/*!
 *
 */
void RadioEngineWrapperPrivate::startSeeking( Seeking::Direction direction )
{
    mObserver.seekingStarted( direction );
}

/*!
 *
 */
QString RadioEngineWrapperPrivate::dataParsingError() const
{
    return mParsingError;
}

/*!
 *
 */
void RadioEngineWrapperPrivate::setHeadsetStatus( bool connected )
{
    mAntennaAttached = connected;
    mObserver.headsetStatusChanged( mAntennaAttached );
}

/*!
 *
 */
void RadioEngineWrapperPrivate::setVolume( int volume )
{
    mVolume = volume;
    mObserver.volumeChanged( mVolume );
}

/*!
 *
 */
void RadioEngineWrapperPrivate::addSong( const QString& artist, const QString& title )
{
    QString radioText = QString( "Now Playing: %1 - %2" ).arg( artist ).arg( title );

    const uint frequency = mStationHandler.currentFrequency();
    mStationHandler.setCurrentRadioText( frequency, radioText );
    mStationHandler.setCurrentRadioTextPlus( frequency, RtPlus::Artist, artist );
    mStationHandler.setCurrentRadioTextPlus( frequency, RtPlus::Title, title );
}

/*!
 *
 */
void RadioEngineWrapperPrivate::clearSong()
{
    mStationHandler.setCurrentRadioText( mStationHandler.currentFrequency(), "" );
}

/*!
 *
 */
bool RadioEngineWrapperPrivate::isOffline() const
{
    return mEngineSettings->value( KKeyOffline, false ).toBool();
}

/*!
 *
 */
void RadioEngineWrapperPrivate::setOffline( bool offline )
{
    mEngineSettings->setValue( KKeyOffline, offline );
}

/*!
 * Private slot
 */
void RadioEngineWrapperPrivate::frequencyEvent()
{
    mStationHandler.setCurrentStation( mFrequency );
    mObserver.tunedToFrequency( mFrequency, mCommandSender );
    mStationHandler.startDynamicPsCheck();
}

/*!
 *
 */
void RadioEngineWrapperPrivate::frequencyScannerFinished()
{
    mObserver.scanAndSaveFinished();
}

/*!
 *
 */
void RadioEngineWrapperPrivate::parseData()
{
    /*
    mDataParser.reset( new T_RadioDataParser() );
    bool ok = mDataParser->parse();
    if ( !ok ) {
        mParsingError = mDataParser->errorString();
    } else {
        if ( mDataParser->mEngineSettings.mMaxVolume > 0 ) {
            mMaxVolume = mDataParser->mEngineSettings.mMaxVolume;
        }

        if ( mDataParser->mEngineSettings.mFrequencyStepSize > 0 ) {
            mFrequencyStepSize = mDataParser->mEngineSettings.mFrequencyStepSize;
        }

        if ( mDataParser->mEngineSettings.mRegionId >= 0 ) {
            mRegionId = static_cast<RadioRegion::Region>( mDataParser->mEngineSettings.mRegionId );
        }

        if ( mDataParser->mEngineSettings.mMinFrequency > 0 ) {
            mMinFrequency = mDataParser->mEngineSettings.mMinFrequency;
        }

        if ( mDataParser->mEngineSettings.mMaxFrequency > 0 ) {
            mMaxFrequency = mDataParser->mEngineSettings.mMaxFrequency;
        }
    }
*/
}