/*

* 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 "irsonghistoryinfo.h"

#include "irsonghistorydb.h"

#include "irqsonghistoryinfo.h"

#include "irqisdsdatastructure.h"

#include "irqmetadata.h"

#include "irqsonghistoryengine.h"

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::openInstance()

// Static function to get a singleton instance of IRQSongHistoryEngine

// @return IRQSongHistoryEngine *

// ---------------------------------------------------------------------------

//

EXPORT_C IRQSongHistoryEngine* IRQSongHistoryEngine::openInstance()

{

    // Get singleton instance

    IRQSongHistoryEngine* irqSongHistoryEngine =

                           reinterpret_cast<IRQSongHistoryEngine*>(Dll::Tls());

    if (NULL == irqSongHistoryEngine)

    {

        TRAPD(error, irqSongHistoryEngine = createInstanceL());

        if (KErrNone != error)

        {

            delete irqSongHistoryEngine;

            irqSongHistoryEngine = NULL;

            Dll::SetTls(NULL);

        }

    }

    else

    {

        irqSongHistoryEngine->iSingletonInstances++;

    }

    return irqSongHistoryEngine;

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::closeInstance()

// Close a singleton instance of IRQSongHistoryEngine

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSongHistoryEngine::closeInstance()

{

    iSingletonInstances--;

    if (0 == iSingletonInstances)

    {

        Dll::SetTls(NULL);

        delete this;

    }

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::createInstanceL()

// Creates IRQSongHistoryEngine instance

// @return IRQSongHistoryEngine*

// ---------------------------------------------------------------------------

//

IRQSongHistoryEngine* IRQSongHistoryEngine::createInstanceL()

{

    IRQSongHistoryEngine* irqSongHistoryEngine = new (ELeave) IRQSongHistoryEngine();

    irqSongHistoryEngine->constructL();

    User::LeaveIfError(Dll::SetTls(irqSongHistoryEngine));

    irqSongHistoryEngine->iSingletonInstances = 1;

    return irqSongHistoryEngine;

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::constructL()

// Two-Phase Constructor.

// ---------------------------------------------------------------------------

//

void IRQSongHistoryEngine::constructL()

{

    iSongHistoryDb = CIRSongHistoryDb::NewL();

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::IRQSongHistoryEngine()

// standard C++ Constructor

// ---------------------------------------------------------------------------

//

IRQSongHistoryEngine::IRQSongHistoryEngine()

{

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::~IRQSongHistoryEngine()

// standard C++ destructor

// ---------------------------------------------------------------------------

//

IRQSongHistoryEngine::~IRQSongHistoryEngine()

{

    delete iSongHistoryDb;

    iSongHistoryDb = NULL;

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::handleMetaDataReceivedL()

// Invoked when channel name or song & artist name are changed.

// ---------------------------------------------------------------------------

//

EXPORT_C void IRQSongHistoryEngine::handleMetaDataReceived(const IRQMetaData& aMetaData,

        const IRQPreset& aPreset)

{

    TRAPD(error, handleMetaDataReceivedL(aMetaData, aPreset));

    if (KErrNone != error)

    {

    }

}

EXPORT_C void IRQSongHistoryEngine::handleSongMetaDataReceived(const IRQMetaData& aMetaData,

        const IRQPreset& aPreset)

{

    TRAPD(error, handleSongMetaDataReceivedL(aMetaData,aPreset));

    if (KErrNone != error)

    {        

    }

}

EXPORT_C void IRQSongHistoryEngine::handleSongMetaDataReceivedL(const IRQMetaData& aMetaData,

        const IRQPreset& aPreset)

{

    TPtrC songName(reinterpret_cast<const TUint16*>(aMetaData.getSongName().utf16()), aMetaData.getSongName().length());

    TPtrC artistName(reinterpret_cast<const TUint16*>(aMetaData.getArtistName().utf16()), aMetaData.getArtistName().length());    

    TPtrC channelName(reinterpret_cast<const TUint16*>(aPreset.name.utf16()), aPreset.name.length());

    TPtrC musicFlag(reinterpret_cast<const TUint16*>(aPreset.musicStoreStatus.utf16()), aPreset.musicStoreStatus.length());    

    TBool bExceededMax = iSongHistoryDb->AddToSongHistoryDb2L(songName,

                             artistName,

                             channelName,

                             musicFlag);                            

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::handleMetaDataReceivedL()

// ---------------------------------------------------------------------------

//

void IRQSongHistoryEngine::handleMetaDataReceivedL(const IRQMetaData& aMetaData,

        const IRQPreset& aPreset)

{

    // Read Channel properties

    TPtrC songName(reinterpret_cast<const TUint16*>(aMetaData.getSongName().utf16()), aMetaData.getSongName().length());

    TPtrC artistName(reinterpret_cast<const TUint16*>(aMetaData.getArtistName().utf16()), aMetaData.getArtistName().length());

    TPtrC channelUrl(reinterpret_cast<const TUint16*>(aMetaData.getStreamUrl().utf16()), aMetaData.getStreamUrl().length());

    TPtrC channelName(reinterpret_cast<const TUint16*>(aPreset.name.utf16()), aPreset.name.length());

    TPtrC channelDesc(reinterpret_cast<const TUint16*>(aPreset.description.utf16()), aPreset.description.length());

    TPtrC imageUrl(reinterpret_cast<const TUint16*>(aPreset.imgUrl.utf16()), aPreset.imgUrl.length());

    TPtrC countryName(reinterpret_cast<const TUint16*>(aPreset.countryName.utf16()), aPreset.countryName.length());

    TPtrC languageName(reinterpret_cast<const TUint16*>(aPreset.languageName.utf16()), aPreset.languageName.length());

    TPtrC musicFlag(reinterpret_cast<const TUint16*>(aPreset.musicStoreStatus.utf16()), aPreset.musicStoreStatus.length());

    TUint8 channelType = aPreset.type;

    TUint16 channelId = aPreset.presetId;

    TUint16 bitrate = aMetaData.getBitrate();

    if (channelType == 1)

    {

        TInt ret = iSongHistoryDb->GetIdPresentInDbL( channelId );

        if(ret)

        {

            TInt modified = iSongHistoryDb->UpdateSongHistoryDbL( channelId ,

                       channelUrl ,imageUrl ,genreName, countryName, languageName, musicFlag);   

            // TODO notify uplayer to change layout?

        }

    }

    else if (channelType != 0)

    {

        // the channel type can only be 1 (isds channel) or 0 (user defined channel)

        channelType = 0;

    }

    iSongHistoryDb->SearchAndDeleteRecordL(channelName, channelUrl, channelType, channelId);

	RBuf delSongName;

	delSongName.CleanupClosePushL();

	RBuf delArtistName;

	delArtistName.CleanupClosePushL();

	RBuf delChannelName;

	delChannelName.CleanupClosePushL();

	RBuf delChannelUrl;

	delChannelUrl.CleanupClosePushL();

    TBool bExceededMax = iSongHistoryDb->AddToSongHistoryDbL(songName,

                         artistName,

                         channelName,

                         channelUrl,

                         delSongName,

                         delArtistName,

                         delChannelName,

                         delChannelUrl ,

                         channelType,

                         channelId,

                         bitrate,

                         channelDesc,

                         imageUrl,

                         genreName,

                         countryName,

                         languageName,

                         musicFlag);

    CleanupStack::PopAndDestroy(4, &delSongName);

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::detectSongHistoryItemChangesL()

// To detect any change in the song history items.

// ---------------------------------------------------------------------------

//

IRQSongHistoryEngine::TSongHistoryItemChange IRQSongHistoryEngine::detectSongHistoryItemChangesL(

        const IRQMetaData& aMetaData, const QString& aChannelName)

{

	if(aChannelName.length() == 0)

	{

		return EBLANKENTRIES;

	}

	RBuf song;

	song.CleanupClosePushL();

	RBuf artist;

	artist.CleanupClosePushL();

	RBuf channel;

	channel.CleanupClosePushL();

	RBuf url;

	url.CleanupClosePushL();

	iSongHistoryDb->GetLastHistoryItemL(song, artist, channel, url);

	TSongHistoryItemChange retval = ENOCHANGE;

    QString tmpsong = QString::fromUtf16(song.Ptr(), song.Length());

    QString tmpartist = QString::fromUtf16(artist.Ptr(), artist.Length());

    QString tmpchannel = QString::fromUtf16(channel.Ptr(), channel.Length());

    QString tmpurl = QString::fromUtf16(url.Ptr(), url.Length());

	if (tmpsong == aMetaData.getSongName() && tmpartist == aMetaData.getArtistName()

	       && tmpchannel == aChannelName && tmpurl == aMetaData.getStreamUrl())

	{

		retval = ENOCHANGE;

	}

	else

	{

		retval = ECHANNELCHANGED;

	}

    CleanupStack::PopAndDestroy(4, &song);

	return retval;

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::getAllHistory

// Invoked when when UI request.

// Getting the data from SongHistoryDb.

// ---------------------------------------------------------------------------

EXPORT_C void IRQSongHistoryEngine::getAllHistory(QList<IRQSongHistoryInfo *>& aSongHistoryArr)

{

    TRAP_IGNORE(getAllHistoryL(aSongHistoryArr));

}

EXPORT_C void IRQSongHistoryEngine::getAllSongHistory(QList<IRQSongInfo *>& aSongHistoryArr)

{

    TRAP_IGNORE(getAllSongHistoryL(aSongHistoryArr));

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::getAllHistoryL

// Invoked when when UI request.

// Getting the data from SongHistoryDb.

// ---------------------------------------------------------------------------

void IRQSongHistoryEngine::getAllHistoryL(QList<IRQSongHistoryInfo *>& aSongHistoryArr)

{

    // clear the array

    while (!aSongHistoryArr.isEmpty())

    {

        delete aSongHistoryArr.takeFirst();

    }

    int songCount = iSongHistoryDb->CountSongHistoryDb();

    if (songCount == 0)

    {

        return;

    }

    // get song history list

    RPointerArray<CIRSongHistoryInfo> historyDataArr;

    for (int arrCount = 0 ; arrCount < songCount ; arrCount++ )

    {

        CIRSongHistoryInfo *songHistory = CIRSongHistoryInfo::NewL();

        CleanupStack::PushL(songHistory);

        historyDataArr.AppendL(songHistory);

        CleanupStack::Pop(songHistory);

    }

    iSongHistoryDb->GetAllSongHistoryListL(historyDataArr);

    // create IRQSongHistoryInfo array and set

    QString songName;

    QString artist;

    QString streamUrl;

    QString channelName;

    int channelType;

    int channelId;

    int bitrate;

    QString channelDesc;

    QString imageUrl;

    QString genreName;

    QString countryName;

    QString languageName;

    QString musicStoreStatus;

    for (int arrCount = 0 ; arrCount < songCount ; arrCount++ )

    {

        songName = QString::fromUtf16(historyDataArr[arrCount]->GetSongInfo().Ptr(),

                             historyDataArr[arrCount]->GetSongInfo().Length());

        artist = QString::fromUtf16(historyDataArr[arrCount]->GetArtistInfo().Ptr(),

                             historyDataArr[arrCount]->GetArtistInfo().Length());

        streamUrl = QString::fromUtf16(historyDataArr[arrCount]->GetStreamUrl().Ptr(),

                             historyDataArr[arrCount]->GetStreamUrl().Length());

        channelName = QString::fromUtf16(historyDataArr[arrCount]->GetChannelName().Ptr(),

                             historyDataArr[arrCount]->GetChannelName().Length());

        channelType = historyDataArr[arrCount]->GetChannelType();

        channelId = historyDataArr[arrCount]->GetChannelId();

        bitrate = historyDataArr[arrCount]->GetBitrate();

        channelDesc = QString::fromUtf16(historyDataArr[arrCount]->GetChannelDesc().Ptr(),

                             historyDataArr[arrCount]->GetChannelDesc().Length());

        imageUrl = QString::fromUtf16(historyDataArr[arrCount]->GetImageUrl().Ptr(),

                                     historyDataArr[arrCount]->GetImageUrl().Length());

        genreName = QString::fromUtf16(historyDataArr[arrCount]->GetGenreName().Ptr(),                

                                     historyDataArr[arrCount]->GetGenreName().Length());

        countryName = QString::fromUtf16(historyDataArr[arrCount]->GetCountryName().Ptr(),

                                     historyDataArr[arrCount]->GetCountryName().Length());

        languageName = QString::fromUtf16(historyDataArr[arrCount]->GetLanguageName().Ptr(),

                                     historyDataArr[arrCount]->GetLanguageName().Length());

        musicStoreStatus = QString::fromUtf16(historyDataArr[arrCount]->GetChannelMusicStatus().Ptr(),

                             historyDataArr[arrCount]->GetChannelMusicStatus().Length());

       IRQSongHistoryInfo* irqsongHistory = new IRQSongHistoryInfo();

       if (NULL == irqsongHistory)

       {

           break;

       }

       irqsongHistory->setHistoryInfo(artist, songName, streamUrl, channelName, channelDesc 

                                      , imageUrl, genreName, countryName, languageName, musicStoreStatus, channelType, channelId, bitrate);

       aSongHistoryArr.append(irqsongHistory);

    }

    historyDataArr.ResetAndDestroy();

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::getAllHistoryL

// Invoked when when UI request.

// Getting the data from SongHistoryDb.

// ---------------------------------------------------------------------------

void IRQSongHistoryEngine::getAllSongHistoryL(QList<IRQSongInfo *>& aSongHistoryArr)

{

    // clear the array

    while (!aSongHistoryArr.isEmpty())

    {

        delete aSongHistoryArr.takeFirst();

    }

    int songCount = iSongHistoryDb->CountSongHistoryDb2();

    if (songCount == 0)

    {

        return;

    }

    // get song history list

    RPointerArray<CIRSongHistoryInfo> historyDataArr;

    for (int arrCount = 0 ; arrCount < songCount ; arrCount++ )

    {

        CIRSongHistoryInfo *songHistory = CIRSongHistoryInfo::NewL();

        CleanupStack::PushL(songHistory);

        historyDataArr.AppendL(songHistory);

        CleanupStack::Pop(songHistory);

    }

    iSongHistoryDb->GetAllSongHistoryList2L(historyDataArr);

    // create IRQSongHistoryInfo array and set

    QString songName;

    QString artist;     

    QString stationName;     

    QString musicStoreStatus;

    for (int arrCount = 0; arrCount < songCount; arrCount++)

    {

        songName = QString::fromUtf16(

                historyDataArr[arrCount]->GetSongInfo().Ptr(),

                historyDataArr[arrCount]->GetSongInfo().Length());

        artist = QString::fromUtf16(

                historyDataArr[arrCount]->GetArtistInfo().Ptr(),

                historyDataArr[arrCount]->GetArtistInfo().Length());

        stationName = QString::fromUtf16(

                historyDataArr[arrCount]->GetChannelName().Ptr(),

                historyDataArr[arrCount]->GetChannelName().Length());

        musicStoreStatus = QString::fromUtf16(

                historyDataArr[arrCount]->GetChannelMusicStatus().Ptr(),

                historyDataArr[arrCount]->GetChannelMusicStatus().Length());

        IRQSongInfo* irqsong = new IRQSongInfo();

        irqsong->setAllInfo(songName, artist, stationName, musicStoreStatus);

        aSongHistoryArr.append(irqsong);

    }

    historyDataArr.ResetAndDestroy();

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::clearAllHistory

// Invoked when when UI request.

// Clears the SongHistoryDb.

// ---------------------------------------------------------------------------

 EXPORT_C int IRQSongHistoryEngine::clearAllHistory( )

 {

     return iSongHistoryDb->ClearAllSongHistoryFromDb();

 }

 EXPORT_C int IRQSongHistoryEngine::clearAllSongHistory( )

 {

     return iSongHistoryDb->ClearAllSongHistoryFromDb2();

 }

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::syncHistory

// Invoked when when UI request.

// Synchronises the Song history DB with the new data in the ISDS.

// ---------------------------------------------------------------------------

EXPORT_C void IRQSongHistoryEngine::syncHistory(int aChannelId)

{

    TRAPD(err,iSongHistoryDb->SyncSongHistoryDbL(aChannelId));

    if (err)

    {

    }

}

// ---------------------------------------------------------------------------

// IRQSongHistoryEngine::updateSongHistoryDb

// Invoked when when UI request.

// Synchronises the Song history DB with the new data in the ISDS.

// ---------------------------------------------------------------------------

EXPORT_C void IRQSongHistoryEngine::updateSongHistoryDb(int aChannelId,

        const QString& aChannelName,

        const QString& aChannelUrl,

        const QString& aImageUrl,

        const QString& aGenreName,

        const QString& aCountryName,

        const QString& aLanguageName,

        const QString& aMusicFlag)

{

    TInt ret = KErrNone ;

    TUint16 channelId = aChannelId; // prevent data overflow

    TRAPD(err,ret = iSongHistoryDb->GetIdPresentInDbL( channelId ));

    if (err)

    {

        return;

    }

    if (ret)

    {

        TPtrC channelName(reinterpret_cast<const TUint16*>(aChannelName.utf16()));

        TPtrC channelUrl(reinterpret_cast<const TUint16*>(aChannelUrl.utf16()));

        TPtrC imageUrl(reinterpret_cast<const TUint16*>(aImageUrl.utf16()));

        TPtrC genreName(reinterpret_cast<const TUint16*>(aGenreName.utf16()));

        TPtrC countryName(reinterpret_cast<const TUint16*>(aCountryName.utf16()));

        TPtrC languageName(reinterpret_cast<const TUint16*>(aLanguageName.utf16()));

        TPtrC musicFlag(reinterpret_cast<const TUint16*>(aMusicFlag.utf16()));

        TRAP_IGNORE(iSongHistoryDb->UpdateSongHistoryDbL( channelId ,

                channelUrl,

                imageUrl,

                genreName,

                countryName,

                languageName,

                musicFlag));

    }

}

EXPORT_C bool IRQSongHistoryEngine::deleteOneItem(int aIndex)

{    

    int retValue = 0;

    retValue = iSongHistoryDb->DeleteOneHistory(aIndex);

    if( KErrNone != retValue )

    {

        return false;

    }

    return true;

}

EXPORT_C bool IRQSongHistoryEngine::deleteOneSongHistoryItem(int aIndex)

{    

    int retValue = 0;

    retValue = iSongHistoryDb->DeleteOneSongHistory(aIndex);

    if( KErrNone != retValue )

    {

        return false;

    }