/*

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

 *

 */

#include <hbmessagebox.h>

#include <QTimer>

#ifdef Q_CC_NOKIAX86

#include <QFile>

#include <QTextStream>

#endif

#ifdef HS_WIDGET_ENABLED

#include <QSettings>

#endif

#include "irplaycontroller.h"

#include "irapplication.h"

#include "irqmediaplayer.h"

#include "irviewmanager.h"

#include "irqisdsdatastructure.h"

#include "irlastplayedstationinfo.h"

#include "irqnetworkcontroller.h" 

#include "irqsonghistoryengine.h"

#include "irqmetadata.h"

#include "irqsettings.h"

#include "irqfavoritesdb.h"

#include "irqstatisticsreporter.h"

#include "irenummapper.h" 

#include "irqlogger.h"

#ifdef HS_WIDGET_ENABLED

#include "irservicedef.h"

#endif

#ifdef Q_CC_NOKIAX86

void getRadioServerAddress(QString & aUrl);

#endif

BEGIN_ENUM_MAP( KTerminationTypeMap )

    ENUM_MAP_ITEM( EIRQUserTerminated, IRQStatisticsReporter::EIRUserTerminated ),

    ENUM_MAP_ITEM( EIRQNoConnectionToServer, IRQStatisticsReporter::EIRNoConnToServer ),

    ENUM_MAP_ITEM( EIRQNoConnectionToNetwork, IRQStatisticsReporter::EIRNoConnToNetwork )            

END_ENUM_MAP( KTerminationTypeMap )

#define MAP_TO_ENGINE_TerminationType(ui_enum) \

          MAP_TO_ENGINE_ENUM( IRQTerminatedType, \

             IRQStatisticsReporter::IRTerminatedType, \

             ui_enum, KTerminationTypeMap )

BEGIN_ENUM_MAP( KServerResultMap )

    ENUM_MAP_ITEM( EIRQPlayerErrorServerFull, IRQStatisticsReporter::EIRServerFull ),

    ENUM_MAP_ITEM( EIRQPlayerErrorTimeOut, IRQStatisticsReporter::EIRTimeOut ),

    ENUM_MAP_ITEM( EIRQPlayerErrorConnectingFailed, IRQStatisticsReporter::EIRConnectFailed )              

END_ENUM_MAP( KServerResultMap )

#define MAP_TO_ENGINE_ServerResult(ui_enum) \

          MAP_TO_ENGINE_ENUM( IRQError, \

             IRQStatisticsReporter::IRServerResult, \

             ui_enum, KServerResultMap )

BEGIN_ENUM_MAP( KConnectedFromMap )

    ENUM_MAP_ITEM( EIRQIsds, IRQStatisticsReporter::EIRIsds ),

    ENUM_MAP_ITEM( EIRQPresetAdhoc, IRQStatisticsReporter::EIRPresetAdhoc ),

    ENUM_MAP_ITEM( EIRQPresetIsds, IRQStatisticsReporter::EIRPresetIsds ),

    ENUM_MAP_ITEM( EIRQHistoryAdhoc, IRQStatisticsReporter::EIRHistoryAdhoc ),

    ENUM_MAP_ITEM( EIRQHistoryIsds, IRQStatisticsReporter::EIRHistoryIsds ),

    ENUM_MAP_ITEM( EIRQAdhocManual, IRQStatisticsReporter::EIRAdhocManual ),                

    ENUM_MAP_ITEM( EIRQAdhocExternal, IRQStatisticsReporter::EIRAdhocExternal )            

END_ENUM_MAP( KConnectedFromMap )

#define MAP_TO_ENGINE_ConnectedFrom(ui_enum) \

          MAP_TO_ENGINE_ENUM( IRQConnectedFrom, \

             IRQStatisticsReporter::IRConnectedFrom, \

             ui_enum, KConnectedFromMap )                 

static bool loadStationLogoFlag();

static void saveStationLogoFlag(bool aIsStationLogoAvailable);

//                                        public functions

/*

 * Description : constructor

 */

IRPlayController::IRPlayController(IRApplication* aApplication) :

    iApplication(aApplication),

    iMediaPlayer(new IRQMediaPlayer()),

    iStatisticsReporter(NULL),

    iGetServerResult(false),

    iNowPlayingPreset(new IRQPreset()),

    iNowPlayingPresetBackup(new IRQPreset()),

    iConnectedFrom(EIRQIsds),

    iConnectedFromBackup(EIRQIsds),

    iStationLogoAvailable(false),

    iStationLogoAvailableBackup(false),

    iMetaData(NULL),

    iPlayState(EIdle),

    iResuming(false),

    iTryingBitrate(0),

    iUrlArray(0),

    iRealBitrate(0),

    iLastError(EIRQErrorNone),

    iStopReason(EIRQUnknownTermination),

    iErrorNote(NULL)

{

    // use the last played station to initiliaze the backup value.

    // can regard the player is bootup, and initilize its LCD screen with last played station info if available.

    if (lastPlayedPreset)

    {

        *iNowPlayingPreset      =   *lastPlayedPreset;

        iLastPlayedUrl          =   getFirstTryUrl(lastPlayedPreset);

        iConnectedFrom          =   iApplication->getLastPlayedStationInfo()->connectedFrom();

        iStationLogoAvailable   =   loadStationLogoFlag();

    }

    if (iNowPlayingPreset->getChannelURLCount())

    {

        iPlayState = EStopped;

    }

    else

    {

        iPlayState = EIdle;

    }    

    connectSignalSlot(); 

    iStatisticsReporter = IRQStatisticsReporter::openInstance();

}

/*

 * Description : destructor

 */

IRPlayController::~IRPlayController()

{

    stop(EIRQUserTerminated);

    delete iMediaPlayer;

    iMediaPlayer = NULL;

    delete iNowPlayingPreset;

    iNowPlayingPreset = NULL;

    delete iNowPlayingPresetBackup;

    iNowPlayingPresetBackup = NULL;

    delete iUrlArray;

    iUrlArray = NULL;

    delete iErrorNote;

    iErrorNote = NULL;

    saveStationLogoFlag(iStationLogoAvailable);

    if (iSongHistoryEngine)

    {

        iSongHistoryEngine->closeInstance();

        iSongHistoryEngine = NULL;

    }

    if (iStatisticsReporter)

    {

        iStatisticsReporter->closeInstance();

    }

}

/*

 * Description : connect to a channel specified by aPreset.

 * Parameters  : aPreset : the preset of the channel

 */

void IRPlayController::connectToChannel(IRQPreset *aPreset, IRQConnectedFrom aConnectedFrom)

{

    if (!aPreset)

    {

        return;

    }

    if (iMediaPlayer)

    {       

        QString firstTryUrl = getFirstTryUrl(aPreset);

        if (firstTryUrl.isEmpty())

        {

            return;

        }

        *iNowPlayingPresetBackup = *iNowPlayingPreset;         

        iLastPlayedUrlBackup = iLastPlayedUrl;

        iConnectedFromBackup = iConnectedFrom;

        *iNowPlayingPreset = *aPreset;           

        iLastPlayedUrl = firstTryUrl;

        iConnectedFrom = aConnectedFrom;

        iResuming = false;

        doPlay(iLastPlayedUrl);

    }

}

QString IRPlayController::getFirstTryUrl(IRQPreset *aPreset)

{

    QString firstTryUrl;

    // sort the URL by ascending order and get all available rates.

    // iAvailableBitrate is cleared in getAvailableBitrates().

    aPreset->sortURLArray();

    aPreset->getAvailableBitrates(iAvailableBitrate);

    if (iAvailableBitrate.count() == 0)

    {

        return firstTryUrl;

    }

    int selectedBitRate = 0;

    IRQPreferredQuality preferredQuality = iApplication->getSettings()->getPreferredQuality();

    switch(preferredQuality)

    {

        case EIRQStandardQuality:

            selectedBitRate = iAvailableBitrate.first();

            break;

        case EIRQHighQuality:

            selectedBitRate = iAvailableBitrate.last();

            break;

        default:

            selectedBitRate = iAvailableBitrate.first();

            break;

    }

    // get URL to play

    iTryingBitrate = selectedBitRate;

    delete iUrlArray;

    iUrlArray = NULL;

    iUrlArray = aPreset->getURLsForBitrate(selectedBitRate);

    if (iUrlArray)

    {

        firstTryUrl = iUrlArray->at(0);

#ifdef Q_CC_NOKIAX86

        getRadioServerAddress(firstTryUrl);

#endif

    }

    return firstTryUrl;

}

/*

 * Description : RESUME playing after play is stopped.

 *               Use the last played url as station's url.

 */

void IRPlayController::resume()

{

    qDebug("IRPlayController::resume(), Entering");

    if (iMediaPlayer && (EStopped == iPlayState))

    {

        iResuming = true;

        if (iLastPlayedUrl != "")

        {

            qDebug("IRPlayController::resume(), iLastPlayedUrl is not empty, doPlay()");

            doPlay(iLastPlayedUrl);

        }

    }

    qDebug("IRPlayController::resume(), Exiting");

}

/*

 * Description : stop playing

 */

void IRPlayController::stop(IRQTerminatedType aStopReason)

{

    qDebug("IRPlayController::stop, Entering, aStopReason=%d", aStopReason);        

    switch (iPlayState)

    {   

        case EPlaying:

            iPlayState = EStopped; 

            iStopReason = aStopReason;

            if (iMediaPlayer)

            {

                iMediaPlayer->disableStereoEffect();

                iMediaPlayer->stop(); 

            }

            // playingStarted is emitted while iPlaying is set to true,

            // so when stop() is called and iPlaying is true, playingStopped

            // should be emitted.

            qDebug("IRPlayController::stop, emit playingStopped()");             

            emit playingStopped();              

            break;

#ifdef HS_WIDGET_ENABLED			

        case EConnecting:     

            // No need to restore because when connecting occurs, because the connectToChannel() has NOT been invoked yet. 

            // Only need to reset the player state                  

            if (iNowPlayingPreset->getChannelURLCount())

            {

                iPlayState = EStopped;

            }

            else

            {

                iPlayState = EIdle;

            }

            // Only need to restore the station logo flag since we may force it to be false when connecting started.   

            // force logo to be default when current view is NOT nowplaying view && is not resuming (start playing a different station.) 

            if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId()

                && iConnectingStationName != iNowPlayingPreset->name)

            {

                iStationLogoAvailable = iStationLogoAvailableBackup;

                emit stationLogoUpdated(iStationLogoAvailable);             

            }                      

            emit connectingCancelled(iNowPlayingPreset->name);

            break;

#endif

        case EBuffering:

            if (iMediaPlayer)

            {

                iMediaPlayer->disableStereoEffect();

                iMediaPlayer->stop(); 

            }

            // when player is forced to stop in bufferring state, we have to revert to backup preset.

            // only with exception when current view is nowplaying view.

            // in IR case, user can only stay in nowplaying view when buffering:

            // 1. starging view is now playing view; 2. open a pls file with only one url

            if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId())

            {

                iLastPlayedUrl        = iLastPlayedUrlBackup;

                *iNowPlayingPreset    = *iNowPlayingPresetBackup;

                iConnectedFrom        = iConnectedFromBackup;               

            }

            if (iNowPlayingPreset->getChannelURLCount())

            {

                iPlayState = EStopped;

            }

            else

            {

                iPlayState = EIdle;

            }

            iStopReason = aStopReason;

#ifdef HS_WIDGET_ENABLED            

            // Need to restore the station logo flag since we may force it to be false when buffering started.  

            // force logo to be default when current view is NOT nowplaying view && is not resuming (start playing a different station.) 

            if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId()

                && !iResuming)

            {

                iStationLogoAvailable = iStationLogoAvailableBackup;

                emit stationLogoUpdated(iStationLogoAvailable);             

            }                         

            emit bufferingCancelled(iNowPlayingPreset->name);

#endif

            break;

        case EIdle:

        case EStopped:		

        default:              

            break;

    }

	endSession(aStopReason);

	qDebug("IRPlayController::stop, Exiting");

}

/*

 * Description : End Session

 */

void IRPlayController::endSession(IRQTerminatedType aStopReason)

{

    if(iStatisticsReporter)

    {

        if(!iGetServerResult)

        {

            iStatisticsReporter->logServerResult(iLastPlayedUrl,IRQStatisticsReporter::EIRConnectFailed);

        }

        iStatisticsReporter->sessionEnded(MAP_TO_ENGINE_TerminationType(aStopReason));

    }

}

/*

 * Description : get current volume setting from media player or

 *               central repository

 * Return      : current volume

 */

int IRPlayController::getVolume() const

{

    if (EPlaying == iPlayState)

    {

        return iMediaPlayer->getVolume();

    }

    else

    {

        return iApplication->getSettings()->getVolumeSetting();

    }

}

/*

 * Description : set volume to media player and central repository

 * Parameters  : aVolume : volume value, between 0 and 100

 */

void IRPlayController::setVolume(int aVolume)

{

    if (EPlaying == iPlayState)

    {

        iMediaPlayer->setVolume(aVolume);

    }

    iApplication->getSettings()->setVolumeSetting(aVolume);

}

#ifdef HS_WIDGET_ENABLED

void IRPlayController::setConnectingStationName(const QString &aStationName, bool aForceConnecting)

{

    iConnectingStationName = aStationName;

    if (aForceConnecting

         || !iApplication->getNetworkController()->getNetworkStatus())

    {

        LOG_FORMAT("IRPlayController::setConnectingStationName, the station name is %s", STRING2CHAR(aStationName));

        iPlayState = EConnecting;   

        // force logo to be default when current view is NOT nowplaying view && is not resuming (start playing a different station.) 

        if (EIRView_PlayingView != iApplication->getViewManager()->currentViewId()

            && iConnectingStationName != iNowPlayingPreset->name)

        {

            emitStationLogoUpdated(false);

        }        

        emit connectingStarted(aStationName);

    }

}

QString IRPlayController::getConnectingStationName() const

{

    return iConnectingStationName;

}

void IRPlayController::reloadNowplayingPreset(IRQPreset *aPreset, bool aIsLogoAvailable, IRQConnectedFrom aConnectedFrom)

{

    if (aPreset)

    {

        *iNowPlayingPreset      =   *aPreset;

        iLastPlayedUrl          =   getFirstTryUrl(aPreset);

        iConnectedFrom          =   aConnectedFrom;

        iStationLogoAvailable   =   aIsLogoAvailable;

    }

    if (iNowPlayingPreset->getChannelURLCount())

    {

        iPlayState = EStopped;

    }

    else

    {

        iPlayState = EIdle;

    }     

}

bool IRPlayController::isStationLogoAvailable() const

{

    return iStationLogoAvailable;

}

void IRPlayController::emitStationLogoUpdated(bool aIsLogoAvailable)

{

    iStationLogoAvailableBackup = iStationLogoAvailable;

    iStationLogoAvailable = aIsLogoAvailable;

    emit stationLogoUpdated(iStationLogoAvailable);

}

bool loadStationLogoFlag()

{

    QSettings settings(KIrSettingOrganization, KIrSettingApplication);

    return settings.value(KIrSettingStationLogoAvailable,false).toBool();

}

#endif

IRPlayController::EPlayState IRPlayController::state() const

{

    return iPlayState;

}