/*

* Copyright (c) 2007 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:  Responsible for interation with the category tables:

*                Artist, Album, Genre and Composer

*

*/

// INCLUDE FILES

#include <sqldb.h>

#include <mpxlog.h>

#include "mpxdbcommonutil.h"

#include "mpxdbcommondef.h"

#include "mpxdbmanager.h"

#include "mpxcollectiondbdef.h"

#include "mpxmediamusicdefs.h"

#include "mpxdbpluginqueries.h"

#include "mpxdbutil.h"

#include "mpxdbalbum.h"

// CONSTANTS

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

_LIT( KAbstractAlbumExt, ".alb" );

#endif // ABSTRACTAUDIOALBUM_INCLUDED

_LIT( KAlbumAlbumArtistSeperator, "\t1");

_LIT( KAlbumArtistSeperator, "\t2");

const TInt KUnknownAlbumsGranularity = 250;

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

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

// Two-phased constructor.

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

//

CMPXDbAlbum* CMPXDbAlbum::NewL(

    CMPXDbManager& aDbManager,

    TMPXGeneralCategory aCategory,

    MMPXDbAlbumObserver& aObserver)

    {

    MPX_FUNC("CMPXDbAlbum::NewL");

    CMPXDbAlbum* self = CMPXDbAlbum::NewLC(aDbManager, aCategory, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXDbAlbum* CMPXDbAlbum::NewLC(

    CMPXDbManager& aDbManager,

    TMPXGeneralCategory aCategory,

    MMPXDbAlbumObserver& aObserver)

    {

    MPX_FUNC("CMPXDbAlbum::NewLC");

    CMPXDbAlbum* self = new (ELeave) CMPXDbAlbum(aDbManager, aCategory, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXDbAlbum::~CMPXDbAlbum()

    {

    MPX_FUNC("CMPXDbAlbum::~CMPXDbAlbum");

    iUnknownArtists.ResetAndDestroy();

    iUnknownAlbums.ResetAndDestroy();

    }

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

// Constructor

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

//

CMPXDbAlbum::CMPXDbAlbum(

    CMPXDbManager& aDbManager,

    TMPXGeneralCategory aCategory,

    MMPXDbAlbumObserver& aObserver) :

    CMPXDbCategory(aDbManager, aCategory),

    iObserver(aObserver),

    iUnknownArtists(KUnknownAlbumsGranularity),

    iUnknownAlbums(KUnknownAlbumsGranularity)

    {

    MPX_FUNC("CMPXDbAlbum::CMPXDbAlbum");

    }

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

// Second phase constructor.

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

//

void CMPXDbAlbum::ConstructL()

    {

    MPX_FUNC("CMPXDbAlbum::ConstructL");

    BaseConstructL();

    }

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

// CMPXDbAlbum::AddItemL

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

//

TUint32 CMPXDbAlbum::AddItemL(

    TMPXGeneralCategory /*aCategory*/,        

    const CMPXMedia& aMedia,

    TInt aDriveId,

    TBool& aNewRecord,

    TBool aCaseSensitive)

    {

    MPX_FUNC("CMPXDbAlbum::AddItemL");

    TPtrC album(KNullDesC);

    TPtrC albumArtist(KNullDesC);

    TPtrC artist(KNullDesC);

    TPtrC albumArt(KNullDesC);

    // try to find the item first

    TUint32 rowId(GenerateUniqueIdL(aMedia));

    // retrieve the existing record

    HBufC* query = PreProcessStringLC(KQueryCategoryItem);

    RSqlStatement recordset(

        iDbManager.ExecuteSelectQueryL(aDriveId, *query, rowId));

    CleanupStack::PopAndDestroy(query);

    CleanupClosePushL(recordset);

    TInt result = recordset.Next();   

    if (result == KSqlAtEnd)

        {

        aNewRecord = result;

        // check Album attribute

        if (aMedia.IsSupported(KMPXMediaMusicAlbum))     

            {

            album.Set(aMedia.ValueText(KMPXMediaMusicAlbum).Left(KMCMaxTextLen));

            }

        // check AlbumArt attirbute

        if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName))

            {

            albumArt.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen));

            }

        // insert new

        HBufC* name = MPXDbCommonUtil::ProcessSingleQuotesLC(album);

        TUint32 artistId(0);

        HBufC* artistName = NULL;        

        if (RetrieveAlbumArtistL(aMedia, albumArtist))

            {

            artistId = iObserver.AddAlbumArtistL(albumArtist, albumArt, aDriveId);

            artistName = MPXDbCommonUtil::ProcessSingleQuotesLC(albumArtist);

            }

        else

            {

            RetrieveArtist(aMedia, artist);

            artistId = iObserver.AddAlbumArtistL(artist, albumArt, aDriveId);

            artistName = MPXDbCommonUtil::ProcessSingleQuotesLC(artist);

            }

        HBufC* art = MPXDbCommonUtil::ProcessSingleQuotesLC(albumArt);

        iDbManager.ExecuteQueryL(aDriveId, KQueryAlbumInsert, rowId, name, 1, artistId, artistName,art); 

        CleanupStack::PopAndDestroy(art);

        CleanupStack::PopAndDestroy(artistName);

        CleanupStack::PopAndDestroy(name);

        }

    else if (result == KSqlAtRow)

        {       

        // retrieve Art from Album table

        TPtrC art(KNullDesC);

        art.Set(MPXDbCommonUtil::GetColumnTextL(recordset, EAlbumArt));

        // the current one is Unknown and the new one is Not Unknown

        if ( art == KNullDesC && albumArt != KNullDesC )

            {

            HBufC* artReplaceSingleQuote = 

                MPXDbCommonUtil::ProcessSingleQuotesLC( albumArt );

            TPtrC criteria(KCriterionArt);

            HBufC* setStr = HBufC::NewLC(criteria.Length() + artReplaceSingleQuote->Length()); 

            setStr->Des().Format( KCriterionArt, artReplaceSingleQuote );

            iDbManager.ExecuteQueryL(aDriveId, KQueryAlbumUpdate, setStr, rowId);

            CleanupStack::PopAndDestroy(setStr);

            CleanupStack::PopAndDestroy(artReplaceSingleQuote);

            }

        // increment the number of songs for the category

        query = PreProcessStringLC(KQueryCategoryIncrementSongCount);

        iDbManager.ExecuteQueryL(aDriveId, *query, rowId);

        CleanupStack::PopAndDestroy(query);

        } // existing record

    else

        {

        MPX_DEBUG2("SQL error %d", result);

        User::Leave(result);

        }

    CleanupStack::PopAndDestroy(&recordset);

    return rowId;

    }

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

// CMPXDbAlbum::DecrementSongsForAlbumL

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

//

void CMPXDbAlbum::DecrementSongsForAlbumL(

    const TUint32 aId,

    TInt aDriveId,

    CMPXMessageArray* aItemChangedMessages,

    TBool& aItemExist,

    const TDesC& aArt)       

    {

    MPX_FUNC("CMPXDbAlbum::DecrementSongsForAlbumL");

    // retrieve the existing record

    HBufC* query = PreProcessStringLC(KQueryCategoryItem);

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(*query, aId));

    CleanupStack::PopAndDestroy(query);

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::Leave(KErrNotFound);

        }

    // if just one song uses this category. Use <= just in case

    if (recordset.ColumnInt64(EAlbumSongCount) <= 1)

        {

        aItemExist = EFalse;

        // Decrement albums count on artist       

        TUint32 albumArtistId = recordset.ColumnInt64(EAlbumArtist);

        iObserver.DeleteAlbumForArtistL(albumArtistId, aDriveId, aItemChangedMessages);

        CleanupStack::PopAndDestroy(&recordset);

        // delete the category

        DeleteCategoryL(aId, aDriveId);

        if (aItemChangedMessages)

            {

            // add the item changed message

            MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aId, EMPXItemDeleted,

                iCategory, KDBPluginUid);

            }

        }

    else

        {

        aItemExist = ETrue;

        TBool itemModified = EFalse;

        TPtrC art(MPXDbCommonUtil::GetColumnTextL(recordset, EAlbumArt));        

        if (NeedToUpdateArt(aArt, art))

            {

            MPX_DEBUG2("AlbumArt of the Song to be deleted is [%S]", &aArt);

            //need to get alternative art in the same album to display

            HBufC* newArt = AlbumartForAlbumL(aId, aArt);

            CleanupStack::PushL(newArt);

            //update Album table only if alternative albumart found

            if (newArt)

                {

                MPX_DEBUG1("CMPXDbAlbum::DecrementSongsForAlbumL, get newArt");

                HBufC* artReplaceSingleQuote = MPXDbCommonUtil::ProcessSingleQuotesLC( *newArt );

                TPtrC criteria(KCriterionArt);   

                HBufC* setStr = HBufC::NewLC(criteria.Length() + artReplaceSingleQuote->Length()); 

                setStr->Des().Format( KCriterionArt, artReplaceSingleQuote );

                iDbManager.ExecuteQueryL(aDriveId, KQueryAlbumUpdate, setStr, aId);

                CleanupStack::PopAndDestroy(setStr);

                CleanupStack::PopAndDestroy(artReplaceSingleQuote);

                itemModified = ETrue;                     

                }

            CleanupStack::PopAndDestroy(newArt);             

            }

        if (aItemChangedMessages && itemModified)

            {

            // add the item changed message

            MPXDbCommonUtil::AddItemAlbumChangedMessageL(*aItemChangedMessages, aId, EMPXItemModified,

                EMPXAlbum, KDBPluginUid, ETrue, 0 );

            }

        CleanupStack::PopAndDestroy(&recordset);

        // decrement the number of songs for the category

        query = PreProcessStringLC(KQueryCategoryDecrementSongCount);

        iDbManager.ExecuteQueryL(aDriveId, *query, aId);

        CleanupStack::PopAndDestroy(query);

        }

    }

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

// CMPXDbAlbum::GetAllCategoryItemsL

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

//

void CMPXDbAlbum::GetAllCategoryItemsL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbAlbum::GetAllCategoryItemsL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryAlbumAll));

    CleanupClosePushL(recordset);

    TRAPD(err, ProcessAlbumRecordSetL(aAttrs, recordset, aMediaArray));

    if (err != KErrNone)

        {

        iUnknownArtists.ResetAndDestroy();

        iUnknownAlbums.ResetAndDestroy();

        User::LeaveIfError(err);

        }

    CleanupStack::PopAndDestroy(&recordset);

    }

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

// CMPXDbAlbum::GetAllCategoryItemsMediaWallL

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

//

void CMPXDbAlbum::GetAllCategoryItemsMediaWallL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbAlbum::GetAllCategoryItemsL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryAlbumAllMediaWall));

    CleanupClosePushL(recordset);

    TRAPD(err, ProcessMediaWallAlbumRecordSetL(aAttrs, recordset, aMediaArray));

    if (err != KErrNone)

        {

        iUnknownArtists.ResetAndDestroy();

        iUnknownAlbums.ResetAndDestroy();

        User::LeaveIfError(err);

        }

    CleanupStack::PopAndDestroy(&recordset);

    }

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

// CMPXDbCategory::GetSubCategoryItemsL

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

//

void CMPXDbAlbum::GetSubCategoryItemsL(

    TMPXGeneralCategory aParentCategory,

    TUint32 aParentId,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbCategory::GetSubCategoryItemsL");

    // this is only valid for albums belonging to an artist

    ASSERT((iCategory == EMPXAlbum) && (aParentCategory == EMPXArtist));

    // to handle the UREL warning

    (void)aParentCategory;

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicGetAlbumsforArtist, aParentId));

    CleanupClosePushL(recordset);

    ProcessAlbumRecordSetL(aAttrs, recordset, aMediaArray);

    CleanupStack::PopAndDestroy(&recordset);

    }

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

// CMPXDbAlbum::UpdateItemL

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

//

void CMPXDbAlbum::UpdateItemL(

    TUint32 aId,

    const CMPXMedia& aMedia,

    TInt aDriveId,

    CMPXMessageArray* aItemChangedMessages)

	{

	MPX_FUNC("CMPXDbAlbum::UpdateItemL");

	CDesCArrayFlat* fields = new (ELeave) CDesCArrayFlat(EAlbumFieldCount);

	CleanupStack::PushL(fields);

	CDesCArrayFlat* values = new (ELeave) CDesCArrayFlat(EAlbumFieldCount);

	CleanupStack::PushL(values);

	// process the media parameter and construct the fields and values array

	GenerateAlbumFieldsValuesL(aMedia, *fields, *values);

	// construct the SET string

	HBufC* setStr = MPXDbCommonUtil::StringFromArraysLC(*fields, *values, KMCEqualSign, KMCCommaSign);

    if (setStr->Length())

        {

        // execute the query

        iDbManager.ExecuteQueryL(aDriveId, KQueryAlbumUpdate, setStr, aId);

        MPXDbCommonUtil::AddItemAlbumChangedMessageL(*aItemChangedMessages, aId, EMPXItemModified,

        		EMPXAlbum, KDBPluginUid, ETrue, 0 );    

        }

	CleanupStack::PopAndDestroy(setStr);

	CleanupStack::PopAndDestroy(values);

	CleanupStack::PopAndDestroy(fields);

	}

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

// CMPXDbAlbum::GetSongsCountInAlbumMatchingArtistL

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

//

TInt CMPXDbAlbum::GetSongsCountInAlbumMatchingArtistL(TUint32 aArtistId, TUint32 aAlbumId)

	{

	MPX_FUNC("CMPXDbAlbum::GetSongsCountInAlbumMatchingArtistL");

	return ExecuteSumQueryL(KQuerySongsInArtistAlbum, aArtistId, aAlbumId);

	}

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

// CMPXDbAlbum::UpdateMediaL

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

//

void CMPXDbAlbum::UpdateMediaL(

    RSqlStatement& aRecord,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXDbAlbum::UpdateMediaL");

    TInt count(aAttrs.Count());

    for (TInt i = 0; i < count; ++i)

        {

        TInt contentId(aAttrs[i].ContentId());

        TUint attributeId(aAttrs[i].AttributeId());

        if (contentId == KMPXMediaIdGeneral)

            {

            if (attributeId & EMPXMediaGeneralId)

                {

                MPX_DEBUG1("    EMPXMediaGeneralId");

                aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId,

                    aRecord.ColumnInt64(EAlbumUniqueId));

                }

            if (attributeId & EMPXMediaGeneralTitle)

                {

                MPX_DEBUG1("    EMPXMediaGeneralTitle");

                TPtrC album( MPXDbCommonUtil::GetColumnTextL(aRecord, EAlbumName) );

                aMedia.SetTextValueL(KMPXMediaGeneralTitle,

                    MPXDbCommonUtil::GetColumnTextL(aRecord, EAlbumName));

                MPX_DEBUG2("	Album[%S]", &album );

                }

            if (attributeId & EMPXMediaGeneralCount)

                {

                MPX_DEBUG1("    EMPXMediaGeneralCount");

				TInt songCount = GetSongsCountL(KDbManagerAllDrives,

					aRecord.ColumnInt64(EAlbumUniqueId));

                aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralCount, songCount );

				MPX_DEBUG2("	SongCount[%d]", songCount );

                }

            } // end if contentId == KMPXMediaIdGeneral

		else if ( contentId == KMPXMediaIdMusic )

			{

			if (attributeId & EMPXMediaMusicArtist)

				{

				MPX_DEBUG1("	EMPXMediaMusicArtist");

				TPtrC artistName(MPXDbCommonUtil::GetColumnTextL(aRecord, EAlbumArtistName));

				aMedia.SetTextValueL(KMPXMediaMusicArtist, artistName);

				MPX_DEBUG2("	Artist[%S]", &artistName);

				}

			if (attributeId & EMPXMediaMusicAlbum)

				{

				MPX_DEBUG1("	EMPXMediaMusicAlbum");

				TPtrC albumName(KNullDesC);

                TPtrC album( MPXDbCommonUtil::GetColumnTextL(aRecord, EAlbumName) );

				// if album is unknown

				if ( album != KNullDesC)

					{

					albumName.Set(album);

					}

				aMedia.SetTextValueL(KMPXMediaMusicAlbum, albumName);

				MPX_DEBUG2("	Album[%S]", &albumName);

				}

			if (attributeId & EMPXMediaMusicAlbumArtFileName)

				{

				MPX_DEBUG1("	EMPXMediaMusicAlbumArtFileName");

				TPtrC art(MPXDbCommonUtil::GetColumnTextL(aRecord, EAlbumArt));

				aMedia.SetTextValueL(KMPXMediaMusicAlbumArtFileName, art);

				MPX_DEBUG2("	Art[%S]", &art);

				}

			}

		} // end for

    aMedia.SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXItem);

    aMedia.SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, iCategory);

    }

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

// CMPXDbAlbum::GenerateAlbumFieldsValuesL

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

//

void CMPXDbAlbum::GenerateAlbumFieldsValuesL(const CMPXMedia& aMedia, CDesCArray& aFields, CDesCArray& aValues)

	{