/*

* Copyright (c) 2006-2006 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:  Implementation of the songhistory database

*

*/

/* ---------------------------------------------------------------------------

*  Version history:

*  Template version:

*  <ccm_history>

*

* 

*  Version: 3, Thu Apr 14 12:00:00 2008 by Rohit

*  Ref:

*  Pc lint fixes

*

*  Version: 2, Thu Apr 10 20:00:00 2008 by Rohit

*  Ref:

*  Implemented SongHistory changes for channelwise songs

*

*  </ccm_history>

* ============================================================================

*/

#include <bautils.h>

#include <badesca.h>    // CDesCArrayFlat

#include <s32file.h>    // CFileStore & CPermanentFileStore

#include <bautils.h>    // file helpers

#include <eikenv.h>

#include "irsonghistorydb.h"

#include "irsonghistoryinfo.h"

#include "irdebug.h"

#include "irsettings.h"

_LIT( KSongHistoryDBTable,              "ChannelHistoryTable"  );

_LIT( KSongHistoryDBTable2,             "SongHistoryTable"  );

_LIT( KSongHistoryDBSongNameColumn,     "SongName"	   );

_LIT( KSongHistoryDBArtistNameColumn,   "ArtistName"   );

_LIT( KSongHistoryDBChannelNameColumn,  "ChannelName"  );

_LIT( KSongHistoryDBChannelUrlColumn,   "ChannelUrl"  );

_LIT( KSongHistoryDBChannelTypeColumn,   "ChannelType"  );

_LIT( KSongHistoryDBChannelIdColumn,   "ChannelId"  );

_LIT( KSongHistoryDBBitrateColumn,   "Bitrate"  );

_LIT( KSongHistoryDBChannelDescColumn,   "ChannelDescription"  );

_LIT( KSongHistoryDBImageUrlColumn,   "ImageUrl"  );

_LIT( KSongHistoryDBGenreNameColumn,   "GenreName"  );

_LIT( KSongHistoryDBCountryNameColumn,   "CountryName"  );

_LIT( KSongHistoryDBLanguageNameColumn,   "LanguageName"  );

_LIT( KSongHistoryDBMusicStatusColumn,   "MusicStoreStatus"  );

_LIT(KSongHistoryDbFile,"songhistoryDb.db");

_LIT(KNo , "No") ;

const TInt KMaxSize = 255;

TBool CIRSongHistoryDb::CompareChannelInfos(const CIRChannelInfo& aFirst,

						 const CIRChannelInfo& aSecond)

{

   return ( aFirst.iChannelName == aSecond.iChannelName && 

   					aFirst.iChannelUrl == aSecond.iChannelUrl &&

   					aFirst.iChannelType == aSecond.iChannelType);

}

// ======== MEMBER FUNCTIONS ========

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

// Function : NewL()

// two phased construction

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

//

CIRSongHistoryDb* CIRSongHistoryDb::NewL()

{

	IRLOG_DEBUG( "CIRSongHistoryDb::NewL" );

	CIRSongHistoryDb* self=CIRSongHistoryDb::NewLC();

	CleanupStack::Pop(self);

	IRLOG_DEBUG( "CIRSongHistoryDb::NewL - Exiting." );

	return self;

}

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

// Function : NewLC()

// Two phased construction

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

//

CIRSongHistoryDb* CIRSongHistoryDb::NewLC()

{

	IRLOG_DEBUG( "CIRSongHistoryDb::NewLC" );

	CIRSongHistoryDb *self=new(ELeave)CIRSongHistoryDb;

	CleanupStack::PushL(self);

	self->ConstructL();

	IRLOG_DEBUG( "CIRSongHistoryDb::NewLC - Exiting." );

	return self;

}

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

// CIRSongHistoryDb::~CIRSongHistoryDb()

// default destructor

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

//

CIRSongHistoryDb::~CIRSongHistoryDb()

{

	IRLOG_DEBUG( "CIRSongHistoryDb::~CIRSongHistoryDb" );

	CloseSongHistoryDb();

	iFsSession.Close();

	IRLOG_DEBUG( "CIRSongHistoryDb::~CIRSongHistoryDb - Exiting." );

}

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

// CIRSongHistoryDb::CreateDbCondition()

// Creates both the dbms files conditionally(only if not yet created)

// calls CreateSongHistoryDb()

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

//

void CIRSongHistoryDb::CreateDbCondition(const TFileName& aSongHistoryDbFile)

{

	IRLOG_DEBUG( "CIRSongHistoryDb::CreateDbCondition" );

	if( !BaflUtils::FileExists(iFsSession, aSongHistoryDbFile) )

	{

		TInt error = CreateSongHistoryDb(aSongHistoryDbFile);

		if( error )

		{

			IRLOG_DEBUG( "CIRSongHistoryDb::CreateDbCondition - Exiting (1)." );

		}

	}

	IRLOG_DEBUG( "CIRSongHistoryDb::CreateDbCondition - Exiting (2)." );

}

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

// CIRSongHistoryDb:AddToSongHistoryDbL()

// adds the session log entry into data base

// Returns ETure if songHistory count exceeds 30, else EFalse

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

//

TBool CIRSongHistoryDb::AddToSongHistoryDbL(const TDesC& aSongName,

                                            const TDesC& aArtistName, 

                                            const TDesC& aChannelName, 

                                            const TDesC& aChannelUrl,

                                            RBuf& aDelSongName, 

                                            RBuf& aDelArtistName, 

                                            RBuf& aDelChannelName, 

                                            RBuf& aDelChannelUrl,

                                            TInt  aChannelType,

                                            TInt aChannelId,

                                            TInt aBitrate,

                                            const TDesC& aChannelDesc,

                                            const TDesC& aImageUrl,

                                            const TDesC& aGenreName,

                                            const TDesC& aCountryName,

                                            const TDesC& aLanguageName,                                                

                                            const TDesC& aMusicFlag

                                            )

{

	IRLOG_DEBUG( "CIRSongHistoryDb::AddSongHistoryStartL" );

	TBool bRetval = EFalse;

	TInt error= 0;

	iSongHistoryTable.Reset();

	//if song history entries are  greater than or equal to 30

	if( iSongHistoryTable.CountL() >= KMaxNoChannelHistoryDbEntries )

	{

		//first row is selected

		iSongHistoryTable.FirstL();

		//the current row is selected

		iSongHistoryTable.GetL();

		//delete that entry

		CDbColSet* columns = iSongHistoryTable.ColSetL();

		TInt songColumn = columns->ColNo( KSongHistoryDBSongNameColumn );

		TInt artistColumn = columns->ColNo( KSongHistoryDBArtistNameColumn );

		TInt channelColumn = columns->ColNo( KSongHistoryDBChannelNameColumn );

		TInt channelUrlColumn = columns->ColNo( KSongHistoryDBChannelUrlColumn );

		delete columns;

		columns = NULL;

        aDelSongName.CreateL(iSongHistoryTable.ColDes( songColumn ));

        aDelArtistName.CreateL(iSongHistoryTable.ColDes( artistColumn ));

        aDelChannelName.CreateL(iSongHistoryTable.ColDes( channelColumn ));

        aDelChannelUrl.CreateL(iSongHistoryTable.ColDes( channelUrlColumn ));

        iSongHistoryTable.DeleteL();

        Compact();

        bRetval = ETrue;

	}

    CDbColSet* columns = iSongHistoryTable.ColSetL();

    CleanupStack::PushL(columns);

	const TPtrC &songName = aSongName.Left(KIRDbMaxStrLen);

	const TPtrC &artistName = aArtistName.Left(KIRDbMaxStrLen);

	const TPtrC &channelName = aChannelName.Left(KIRDbMaxStrLen);

	const TPtrC &channelUrl = aChannelUrl.Left(KIRDbMaxStrLen);

    const TPtrC &channelDesc = aChannelDesc.Left(KIRDbMaxStrLen);

    const TPtrC &imageUrl = aImageUrl.Left(KIRDbMaxStrLen);

    const TPtrC &genreName = aGenreName.Left(KIRDbMaxStrLen);

    const TPtrC &countryName = aCountryName.Left(KIRDbMaxStrLen);

    const TPtrC &languageName = aLanguageName.Left(KIRDbMaxStrLen);

	TInt songLen = aSongName.Length();

	TInt artistLen = aArtistName.Length();

	if(  songLen + artistLen > KMaxSize )

	{

		IRLOG_DEBUG3( "CIRSongHistoryDb::AddSongHistoryStartL - LONG METADATA %d, %d", songLen, artistLen );

	}

	TRAP(error,//trap start

  		iSongHistoryTable.InsertL();

		iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBSongNameColumn ), songName);

		iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBArtistNameColumn ), artistName);

		iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBChannelNameColumn ), channelName);

		iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBChannelUrlColumn ), channelUrl);

		iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBChannelTypeColumn ), aChannelType);

		iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBChannelIdColumn ), aChannelId);

		iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBBitrateColumn ), aBitrate);

        iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBChannelDescColumn ), channelDesc);

        iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBImageUrlColumn ), imageUrl);

        iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBGenreNameColumn ), genreName);

        iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBCountryNameColumn ), countryName);

        iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBLanguageNameColumn ), languageName);

        iSongHistoryTable.SetColL(columns->ColNo( KSongHistoryDBMusicStatusColumn ), aMusicFlag);

		iSongHistoryTable.PutL();

		);

 	CleanupStack::PopAndDestroy(columns); 

 	if( error!=KErrNone )

 	{

	 	User::LeaveIfError(error);

 	}

 	iSongHistoryTable.Reset();

 	IRLOG_DEBUG( "CIRSongHistoryDb::AddSongHistoryStartL - Exiting." );

	return bRetval;

}

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

// CIRSongHistoryDb:AddToSongHistoryDb2L()

// adds the history song into the db

// Returns ETure if songHistory count exceeds 100, else EFalse

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

TBool CIRSongHistoryDb::AddToSongHistoryDb2L( const TDesC& aSongName,

                                    const TDesC& aArtistName,                                   

                                    const TDesC& aChannelName,

                                    const TDesC& aMusicFlag)

{

    IRLOG_DEBUG( "CIRSongHistoryDb::AddToSongHistoryDb2L" );

    TBool bRetval = EFalse;

    TInt error= 0;

    TInt songCompareFlag = 0;

    TInt artistCompareFlag = 0;    

    iSongHistoryTable2.Reset();    

    CDbColSet* columns = iSongHistoryTable2.ColSetL();

    CleanupStack::PushL(columns);

    /* the following is to judge wether the song is already in the db */    

    if ( iSongHistoryTable2.CountL() >= 1 )

    {

        TInt songNameColumn = columns->ColNo( KSongHistoryDBSongNameColumn );

        TInt artistNameColumn = columns->ColNo( KSongHistoryDBArtistNameColumn );     

        for ( iSongHistoryTable2.LastL(); iSongHistoryTable2.AtRow(); iSongHistoryTable2.PreviousL() )

        {

            iSongHistoryTable2.GetL();

            RBuf songName;

            RBuf artistName;

			CleanupClosePushL(songName);

			CleanupClosePushL(artistName);

            songName.CreateL(iSongHistoryTable2.ColDes( songNameColumn ));

            artistName.CreateL(iSongHistoryTable2.ColDes( artistNameColumn ));

            songCompareFlag = (songName).Compare(aSongName);

            artistCompareFlag = (artistName).Compare(aArtistName);

            CleanupStack::PopAndDestroy(2);       

            if( 0 == songCompareFlag && 0 == artistCompareFlag )

            {

                CleanupStack::PopAndDestroy(columns); 

                iSongHistoryTable2.Reset();

                return bRetval;

            }

        }        

    }

	/* end  */

    //if song history entries are  greater than or equal to 100

    if( iSongHistoryTable2.CountL() >= KMaxNoSongHistoryDbEntries )

    {

        //first row is selected

        iSongHistoryTable2.FirstL();

        //the current row is selected

        iSongHistoryTable2.GetL();       

        //delete the current row

        iSongHistoryTable2.DeleteL();

        Compact();     

        bRetval = ETrue;   

    }

    const TPtrC &songName = aSongName.Left(KIRDbMaxStrLen);

    const TPtrC &artistName = aArtistName.Left(KIRDbMaxStrLen);

    const TPtrC &channelName = aChannelName.Left(KIRDbMaxStrLen);

    const TPtrC &musicFlag = aMusicFlag.Left(KIRDbMaxStrLen);

    TInt songLen = aSongName.Length();

    TInt artistLen = aArtistName.Length();

    if(  songLen + artistLen > KMaxSize || aChannelName.Length() > KMaxSize)

    {

        IRLOG_DEBUG3( "CIRSongHistoryDb::AddToSongHistoryDb2L - too long song info: %d or channel info: %d", songLen+artistLen, aChannelName.Length() );

    }

    TRAP(error,//trap start

        iSongHistoryTable2.InsertL();

        iSongHistoryTable2.SetColL(columns->ColNo( KSongHistoryDBSongNameColumn ), songName);

        iSongHistoryTable2.SetColL(columns->ColNo( KSongHistoryDBArtistNameColumn ), artistName);        

        iSongHistoryTable2.SetColL(columns->ColNo( KSongHistoryDBChannelNameColumn ), channelName);        

        iSongHistoryTable2.SetColL(columns->ColNo( KSongHistoryDBMusicStatusColumn ), musicFlag);

        iSongHistoryTable2.PutL();

        );

    CleanupStack::PopAndDestroy(columns); 

    if( error!=KErrNone )

    {

        User::LeaveIfError(error);

    }

    iSongHistoryTable2.Reset();

    IRLOG_DEBUG( "CIRSongHistoryDb::AddSongHistoryStartL - Exiting." );

    return bRetval;  

}

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

// CIRSongHistoryDb::GetAllSongHistoryListL()

//  gets all the song history entries  into an array

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

//

void CIRSongHistoryDb::GetAllSongHistoryListL(RPointerArray<CIRSongHistoryInfo>& aHistoryDataArr)

{

 	IRLOG_DEBUG( "CIRSongHistoryDb::GetAllSongHistoryListL" ); 	 

    if(iSongHistoryTable.CountL() < 1)

    {

    	return;

    }

    CDbColSet* columns = iSongHistoryTable.ColSetL();

    TInt songColumn = columns->ColNo( KSongHistoryDBSongNameColumn );

    TInt artistColumn = columns->ColNo( KSongHistoryDBArtistNameColumn );

    TInt channelColumn = columns->ColNo( KSongHistoryDBChannelNameColumn );

    TInt channelUrlColumn = columns->ColNo( KSongHistoryDBChannelUrlColumn );

    TInt channelTypeColumn = columns->ColNo( KSongHistoryDBChannelTypeColumn );

    TInt channelIdColumn = columns->ColNo( KSongHistoryDBChannelIdColumn );

    TInt bitrateColumn = columns->ColNo( KSongHistoryDBBitrateColumn );

    TInt channelDescColumn = columns->ColNo( KSongHistoryDBChannelDescColumn );

    TInt imageUrlColumn = columns->ColNo( KSongHistoryDBImageUrlColumn );

    TInt genreNameColumn = columns->ColNo( KSongHistoryDBGenreNameColumn );

    TInt countryNameColumn = columns->ColNo( KSongHistoryDBCountryNameColumn );

    TInt languageNameColumn = columns->ColNo( KSongHistoryDBLanguageNameColumn );

    TInt musicStatusColumn = columns->ColNo( KSongHistoryDBMusicStatusColumn );

    delete columns;

    columns = NULL; 	 

 	TInt song = 0;

    for ( iSongHistoryTable.LastL(); iSongHistoryTable.AtRow(); iSongHistoryTable.PreviousL() ) 	 

    {

        iSongHistoryTable.GetL();

        RBuf songName;

        RBuf artistName;

        RBuf channelName;

        RBuf channelUrl;

        TInt channelType;

        TInt channelId;

        TInt bitrate;

        RBuf channelDesc;

        RBuf imageUrl;

        RBuf genreName;

        RBuf countryName;

        RBuf languageName;

        RBuf channelMusicStatus;

        songName.CreateL(iSongHistoryTable.ColDes( songColumn ));

        songName.CleanupClosePushL();

        artistName.CreateL(iSongHistoryTable.ColDes( artistColumn ));

        artistName.CleanupClosePushL();

        channelName.CreateL(iSongHistoryTable.ColDes( channelColumn ));

        channelName.CleanupClosePushL();

        channelUrl.CreateL(iSongHistoryTable.ColDes( channelUrlColumn ));

        channelUrl.CleanupClosePushL();

        channelType=iSongHistoryTable.ColUint8( channelTypeColumn );

        channelId=iSongHistoryTable.ColUint16( channelIdColumn );

        bitrate=iSongHistoryTable.ColUint16( bitrateColumn );

        channelDesc.CreateL(iSongHistoryTable.ColDes( channelDescColumn ));

        channelDesc.CleanupClosePushL();

        imageUrl.CreateL(iSongHistoryTable.ColDes( imageUrlColumn ));

        imageUrl.CleanupClosePushL();

        genreName.CreateL(iSongHistoryTable.ColDes( genreNameColumn ));

        genreName.CleanupClosePushL();

        countryName.CreateL(iSongHistoryTable.ColDes( countryNameColumn ));

        countryName.CleanupClosePushL();

        languageName.CreateL(iSongHistoryTable.ColDes( languageNameColumn ));

        languageName.CleanupClosePushL();

        channelMusicStatus.CreateL(iSongHistoryTable.ColDes( musicStatusColumn ));

        channelMusicStatus.CleanupClosePushL();

        aHistoryDataArr[song]->SetHistoryInfoL(songName, artistName, channelUrl,

                         channelName,channelType,channelId,bitrate,channelDesc ,

                         imageUrl, genreName, countryName, languageName, channelMusicStatus);

        ++song;        

        CleanupStack::PopAndDestroy(&channelMusicStatus);

        CleanupStack::PopAndDestroy(&languageName);

        CleanupStack::PopAndDestroy(&countryName);

        CleanupStack::PopAndDestroy(&genreName);

        CleanupStack::PopAndDestroy(&imageUrl);

        CleanupStack::PopAndDestroy(&channelDesc);

        CleanupStack::PopAndDestroy(&channelUrl);

        CleanupStack::PopAndDestroy(&channelName);

        CleanupStack::PopAndDestroy(&artistName);

        CleanupStack::PopAndDestroy(&songName);

    }        

	IRLOG_DEBUG( "CIRSongHistoryDb::GetAllSongHistoryListL - Exiting." );

}

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

// CIRSongHistoryDb::GetAllSongHistoryList2L()

//  gets all the song history entries  into an array

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

//

void CIRSongHistoryDb::GetAllSongHistoryList2L(RPointerArray<CIRSongHistoryInfo>& aSongEntries)

{

    IRLOG_DEBUG( "CIRSongHistoryDb::GetAllSongHistoryList2L" );    

    if(iSongHistoryTable2.CountL() < 1)

    {

        return;

    }

    CDbColSet* columns = iSongHistoryTable2.ColSetL();

    TInt songColumn = columns->ColNo( KSongHistoryDBSongNameColumn );

    TInt artistColumn = columns->ColNo( KSongHistoryDBArtistNameColumn );     

    TInt channelNameColumn = columns->ColNo( KSongHistoryDBChannelNameColumn );     

    TInt musicStatusColumn = columns->ColNo( KSongHistoryDBMusicStatusColumn );

    delete columns;

    columns = NULL;

    TInt song = 0;

    for ( iSongHistoryTable2.LastL(); iSongHistoryTable2.AtRow(); iSongHistoryTable2.PreviousL() )

    {

        iSongHistoryTable2.GetL();

        RBuf songName;

        RBuf artistInfo, channelName;

        RBuf musicStatus;

        CleanupClosePushL(songName);

        CleanupClosePushL(artistInfo);

        CleanupClosePushL(channelName);

        CleanupClosePushL(musicStatus);

        songName.CreateL(iSongHistoryTable2.ColDes( songColumn ));

        artistInfo.CreateL(iSongHistoryTable2.ColDes( artistColumn ));

        channelName.CreateL(iSongHistoryTable2.ColDes( channelNameColumn ));

        musicStatus.CreateL(iSongHistoryTable2.ColDes(musicStatusColumn));

        aSongEntries[song]->SetSongNameL(songName);

        aSongEntries[song]->SetArtistL(artistInfo);

        aSongEntries[song]->SetChannelNameL(channelName);

        aSongEntries[song]->SetChannelMusicStatusL(musicStatus);

        ++song;         

        CleanupStack::PopAndDestroy(4);