/*
* 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";

const uint KScanFrequencies[] = {
    87500000,
    88100000,
    89400000,
    96000000,
    97600000,
    100600000,
    101300000,
    102600000,
    103500000,
    104100000,
    105500000,
    107500000
};

const int KScanFrequencyCount = sizeof( KScanFrequencies ) / sizeof( KScanFrequencies[0] );

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

    Radio::connect( 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
 */
bool RadioEngineWrapperPrivate::init()
{
    mUseLoudspeaker = false;
    if ( !mUseLoudspeaker ) {
        RUN_NOTIFY_LOOP( mObservers, audioRouteChanged( false ) );
    }

    parseData();
    return true;
}

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

/*!
 * Tunes to the given frequency
 */
void RadioEngineWrapperPrivate::setFrequency( uint frequency, const int reason )
{
    mNextFrequency = frequency;
    mTuneReason = reason;

    mTuneTimer->stop();
    if ( !mManualSeekMode ) {
        mTuneTimer->start( 500 );
    } else {
        frequencyEvent();
    }
}

/*!
 *
 */
ObserverList& RadioEngineWrapperPrivate::observers()
{
    return mObservers;
}

/*!
 *
 */
void RadioEngineWrapperPrivate::startSeeking( Seek::Direction direction, const int reason )
{
    mTuneReason = reason;
    mNextFrequency = 0;

    // Find the previous and next favorite from current frequency
    uint previous = 0;
    uint next = 0;
    for( int i = 0; i < KScanFrequencyCount; ++i ) {
        const uint testFreq = KScanFrequencies[i];
        if ( KScanFrequencies[i] > mFrequency ) {
            next = testFreq;
            break;
        }
        previous = testFreq;
    }


    if ( direction == Seek::Up ) {
        if ( next == 0 ) {
            next = KScanFrequencies[0];
        }
        mNextFrequency = next;
    } else {
        if ( previous == 0 ) {
            previous = KScanFrequencies[KScanFrequencyCount - 1];
        }
        mNextFrequency = previous;
    }

    mTuneTimer->start( 1000 );
}

/*!
 *
 */
void RadioEngineWrapperPrivate::cancelSeeking()
{
    mTuneTimer->stop();
    mNextFrequency = 0;
}

/*!
 *
 */
void RadioEngineWrapperPrivate::toggleAudioRoute()
{
    mUseLoudspeaker = !mUseLoudspeaker;
    RUN_NOTIFY_LOOP( mObservers, audioRouteChanged( mUseLoudspeaker ) );
}

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

/*!
 *
 */
void RadioEngineWrapperPrivate::setHeadsetStatus( bool connected )
{
    mAntennaAttached = connected;
    RUN_NOTIFY_LOOP( mObservers, antennaStatusChanged( mAntennaAttached ) );
}

/*!
 *
 */
void RadioEngineWrapperPrivate::setVolume( int volume )
{
    mVolume = volume;
    RUN_NOTIFY_LOOP( mObservers, volumeChanged( mVolume ) );
}

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

    const uint frequency = mStationHandler.currentFrequency();
    mStationHandler.setCurrentRadioText( frequency, radioText );

    QTimer::singleShot( 500, this, SLOT(addSongTags()) );
}

/*!
 *
 */
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()
{
    if ( mNextFrequency > 0 ) {
        mFrequency = mNextFrequency;
        mEngineSettings->setValue( KKeyFrequency, mFrequency );
    }

    if ( !mManualSeekMode ) {
        RUN_NOTIFY_LOOP( mObservers, tunedToFrequency( mNextFrequency, mTuneReason ) );
    }
}

/*!
 * Private slot
 */
void RadioEngineWrapperPrivate::addSongTags()
{
    const uint frequency = mStationHandler.currentFrequency();
    mStationHandler.setCurrentRadioTextPlus( frequency, RtPlus::Artist, mArtist );
    mStationHandler.setCurrentRadioTextPlus( frequency, RtPlus::Title, mTitle );
    mArtist = "";
    mTitle = "";
}

/*!
 *
 */
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;
        }
    }
*/
}