/*

* 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 music table.

*

*/

// INCLUDE FILES

#include <mpxlog.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediamtpdefs.h>

#include <mpxcollectiondbhgres.rsg>

#include "mpxdbcommondef.h"

#include "mpxdbcommonstd.h"

#include "mpxdbcommonutil.h"

#include "mpxresource.h"

#include "mpxcollectiondbdef.h"

#include "mpxcollectiondbstd.h"

#include "mpxdbpluginqueries.h"

#include "mpxdbutil.h"

#include "mpxdbmanager.h"

#include "mpxdbmusic.h"

// CONSTANTS

// This is what KNullDesC album computes to for the hash

// to-do: generate this Id through

//        MPXDbUtil::GenerateUniqueIdL(EMPXAlbum, KNullDesC, EFalse)

//        instead of hard-coding the number so if GenerateUniqueIdL

//        is modified, this constant doesn't need to be redefined

const TInt KUnknownAlbumID = 1770790356;

// UniqueID column in Uris requests

const TInt KColUniqueID = 0;

// URI column in Uris requests

const TInt KColUri = 1;

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

_LIT( KAbstractAlbumExt, ".alb" );

#endif // ABSTRACTAUDIOALBUM_INCLUDED

const TInt KAllSongsQueryResultGranularity = 250;

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

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

// Two-phased constructor.

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

//

CMPXDbMusic* CMPXDbMusic::NewL(

    CMPXDbManager& aDbManager,

    CMPXResource& aResource,

    MMPXDbMusicObserver& aObserver)

    {

    MPX_FUNC("CMPXDbMusic::NewL");

    CMPXDbMusic* self = CMPXDbMusic::NewLC(aDbManager, aResource, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXDbMusic* CMPXDbMusic::NewLC(

    CMPXDbManager& aDbManager,

    CMPXResource& aResource,

    MMPXDbMusicObserver& aObserver)

    {

    MPX_FUNC("CMPXDbMusic::NewLC");

    CMPXDbMusic* self = new (ELeave) CMPXDbMusic(aDbManager, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aResource);

    return self;

    }

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

// Destructor

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

//

CMPXDbMusic::~CMPXDbMusic()

    {

    MPX_FUNC("CMPXDbMusic::~CMPXDbMusic");

    delete iExtensionsDrm;

    iAllSongsQueryResult.ResetAndDestroy();

    }

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

// Constructor

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

//

CMPXDbMusic::CMPXDbMusic(

    CMPXDbManager& aDbManager,

    MMPXDbMusicObserver& aObserver) :

    CMPXDbTable(aDbManager),

    iObserver(aObserver)

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

    ,iArtNeedUpdated(ETrue)

#endif

    ,iAllSongsQueryResult(KAllSongsQueryResultGranularity)

    {

    MPX_FUNC("CMPXDbMusic::CMPXDbMusic");

    }

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

// Second phase constructor.

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

//

void CMPXDbMusic::ConstructL(

    CMPXResource& aResource)

    {

    MPX_FUNC("CMPXDbMusic::ConstructL");

    BaseConstructL();

    iExtensionsDrm = aResource.ReadDesCArrayL(R_MC_FILE_EXTENSIONS_DRM);

    }

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

// CMPXDbMusic::AddSongL

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

//

TUint32 CMPXDbMusic::AddSongL(

    const CMPXMedia& aMedia,

    TInt aDrive,

    CMPXMessageArray* aMessageArray)

    {

    MPX_FUNC("CMPXDbMusic::AddSongL");

    TUint32 songId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXCollection,

        aMedia.ValueText(KMPXMediaGeneralUri), EFalse));

    if (SongExistsL(songId))

        {

        // Delete the existing record first and start from scratch

        DeleteSongL(songId, aDrive, ETrue);

        }

    // add the song

    DoAddSongL(songId, aMedia, aDrive, aMessageArray);

    return songId;

    }

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

// CMPXDbMusic::DoAddSongL

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

//

TBool CMPXDbMusic::DoAddSongL(

    TUint32 aSongId,

    const CMPXMedia& aMedia,

    TInt aDrive,

    CMPXMessageArray* aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbMusic::DoAddSongL");

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

    CleanupStack::PushL(fields);

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

    CleanupStack::PushL(values);

    // add known fields

    MPXDbCommonUtil::AppendValueL(*fields, *values, KMCMusicUniqueId, aSongId);

    MPXDbCommonUtil::AppendValueL(*fields, *values, KMCMusicDel, 0);

    TTime time;

    time.HomeTime();

    HBufC* timeAdded = MPXDbCommonUtil::TTimeToDesLC(time);

    MPXDbCommonUtil::AppendValueL(*fields, *values, KMCMusicTimeAdded, *timeAdded);

    CleanupStack::PopAndDestroy(timeAdded);

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

    //update ContainEmbeddedArt

    const TDesC& albumArtFilename = aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen);

    if (albumArtFilename.Length() > 0)

        {

        MPXDbCommonUtil::AppendValueL(*fields, *values, KMCMusicContainEmbeddedArt, 1);

        }

#endif // ABSTRACTAUDIOALBUM_INCLUDED

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

    TBool visible(GenerateMusicFieldsValuesL(aSongId, aMedia, aItemChangedMessages,

        NULL, *fields, *values, aDrive));

    // create the fields and values strings

    HBufC* fieldStr = MPXDbCommonUtil::StringFromArrayLC(*fields, KMCCommaSign);

    HBufC* valueStr = MPXDbCommonUtil::StringFromArrayLC(*values, KMCCommaSign);

    // execute the query

    iDbManager.ExecuteQueryL(aDrive, KQueryMusicInsert, fieldStr, valueStr);

    CleanupStack::PopAndDestroy(valueStr);

    CleanupStack::PopAndDestroy(fieldStr);

    CleanupStack::PopAndDestroy(values);

    CleanupStack::PopAndDestroy(fields);

    return visible;

    }

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

// CMPXDbMusic::UpdateSongL

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

//

CMPXDbActiveTask::TChangeVisibility CMPXDbMusic::UpdateSongL(

    TUint32 aSongId,

    const CMPXMedia& aMedia,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbMusic::UpdateSongL");

    return DoUpdateSongL(aSongId, aMedia, &aItemChangedMessages);

    }

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

// CMPXDbMusic::DoUpdateSongL

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

//

CMPXDbActiveTask::TChangeVisibility CMPXDbMusic::DoUpdateSongL(

    TUint32 aSongId,

    const CMPXMedia& aMedia,

    CMPXMessageArray* aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbMusic::DoUpdateSongL");

    CMPXDbActiveTask::TChangeVisibility visible(CMPXDbActiveTask::ENotVisibile);

    if (IsSupported(aMedia))

        {

        // retrieve the existing record

        TInt oldSongId(0);

        oldSongId = (aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2;

        if ( oldSongId <= 0 )

            {

            oldSongId = aSongId;

            }

        RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicGetSong, oldSongId));

        CleanupClosePushL(recordset);

        if (recordset.Next() != KSqlAtRow)

            {

            User::Leave(KErrNotFound);

            }

        TDriveUnit driveUnit(MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),

          recordset.ColumnInt64(EMusicVolumeId)));

        visible = DoUpdateSongL(aSongId, aMedia, driveUnit, aItemChangedMessages,

          recordset);

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

        if(iArtNeedUpdated)

            {

#endif // ABSTRACTAUDIOALBUM_INCLUDED

	        // Update Album table

	        if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName) || aMedia.IsSupported(KMPXMediaMusicArtist))

	            {

	            TUint32 albumId = recordset.ColumnInt64(EMusicAlbum);

	            iObserver.UpdateCategoryItemL(EMPXAlbum, albumId, aMedia, driveUnit, aItemChangedMessages);

	            }

	        // Update Artist table

	        if ( aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName) )

	            {

	            TUint32 artistId = recordset.ColumnInt64(EMusicArtist);

	            iObserver.UpdateCategoryItemL(EMPXArtist, artistId, aMedia, driveUnit, aItemChangedMessages);

	            }

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

            }

        iArtNeedUpdated = ETrue;  //reset flag

#endif // ABSTRACTAUDIOALBUM_INCLUDED

        CleanupStack::PopAndDestroy(&recordset);

        }

    return visible;

    }

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

// CMPXDbMusic::DoUpdateSongL

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

//

CMPXDbActiveTask::TChangeVisibility CMPXDbMusic::DoUpdateSongL(

    TUint32 aSongId,

    const CMPXMedia& aMedia,

    TInt aDrive,

    CMPXMessageArray* aItemChangedMessages,

    RSqlStatement& aRecordset)

    {

    MPX_FUNC("CMPXDbMusic::DoUpdateSongL");

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

    CleanupStack::PushL(fields);

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

    CleanupStack::PushL(values);

    TInt oldSongId(0);

    oldSongId = (aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2;

    if ( oldSongId <= 0 )

        {

        oldSongId = aSongId;

        }

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

    CMPXDbActiveTask::TChangeVisibility visible(GenerateMusicFieldsValuesL(oldSongId, aMedia, aItemChangedMessages,

        &aRecordset, *fields, *values, aDrive));

    // construct the SET string

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

    if (setStr->Length())

        {

        // execute the query

        iDbManager.ExecuteQueryL(aDrive, KQueryMusicUpdate, setStr, oldSongId);

        }

    CleanupStack::PopAndDestroy(setStr);

    CleanupStack::PopAndDestroy(values);

    CleanupStack::PopAndDestroy(fields);

    return visible;

    }

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

// CMPXDbMusic::DeleteSongL

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

//

void CMPXDbMusic::DeleteSongL(

    TUint32 aSongId,

    TInt aDrive,

    TBool aDeleteRecord /* = EFalse */)

    {

    MPX_FUNC("CMPXDbMusic::DeleteSongL");

    TPtrC query(aDeleteRecord ? KQueryMusicDelete() : KQueryMusicDeleteUpdate());

    iDbManager.ExecuteQueryL(aDrive, query, aSongId);

    }

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

// CMPXDbMusic::DeleteCategoryL

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

//

void CMPXDbMusic::DeleteCategoryL(

    TMPXGeneralCategory aCategory,

    TUint32 aCategoryId,

    CDesCArray& /* aUriArray */,

    CMPXMessageArray& /* aItemChangedMessages */,

    TInt aDrive)

    {

    MPX_FUNC("CMPXDbMusic::DeleteCategoryL");

    TPtrC ptr(MPXDbUtil::MusicFieldNameForCategoryL(aCategory));

    iDbManager.ExecuteQueryL(aDrive, KQueryMusicDeleteForCategory, &ptr, aCategoryId);

    }

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

// CMPXDbMusic::CleanupL

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

//

void CMPXDbMusic::CleanupL()

    {

    MPX_FUNC("CMPXDbMusic::CleanupL");

    iDbManager.ExecuteQueryL(KDbManagerAllDrives, KQueryMusicCleanup);

    }

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

// CMPXDbMusic::GetNameL

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

//

HBufC* CMPXDbMusic::GetNameL(

    TUint32 aSongId)

    {

    MPX_FUNC("CMPXDbMusic::GetNameL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicGetTitle, aSongId));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::LeaveIfError(KErrNotFound);

        }

    HBufC* title = MPXDbCommonUtil::GetColumnTextL(recordset, KMPXTableDefaultIndex).AllocL();

    CleanupStack::PopAndDestroy(&recordset);

    return title;

    }

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

// CMPXDbMusic::GetUriL

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

//

HBufC* CMPXDbMusic::GetUriL(

    TUint32 aSongId)

    {

    MPX_FUNC("CMPXDbMusic::GetUriL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicGetUri, aSongId));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::LeaveIfError(KErrNotFound);

        }

    // query fields

    enum

        {

        EMusicUriLocation = 0,

        EMusicUriVolId

        };

    TUint volId(recordset.ColumnInt64(EMusicUriVolId));

    HBufC* fullUri = MPXDbCommonUtil::CreateFullPathL(

        MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), volId),

        MPXDbCommonUtil::GetColumnTextL(recordset, EMusicUriLocation));

    CleanupStack::PopAndDestroy(&recordset);

    return fullUri;

    }

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

// CMPXDbMusic::GetDriveL

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

//

TInt CMPXDbMusic::GetDriveL(

    TUint32 aSongId)

    {

    MPX_FUNC("CMPXDbMusic::GetDriveL");

    return MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),

        ExecuteIntQueryL(KQueryMusicVolume, aSongId));

    }

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

// CMPXDbMusic::GetSongInfoL

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

//

HBufC* CMPXDbMusic::GetSongInfoL(

    TUint32 aSongId,

    TUint32& aArtistId,

    TUint32& aAlbumId,

    TUint32& aGenreId,

    TUint32& aComposerId,

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

    TUint32& aAbstractAlbumId,

#endif // ABSTRACTAUDIOALBUM_INCLUDED

    TInt& aDriveId,

    HBufC*& aArt)

    {

    MPX_FUNC("CMPXDbMusic::GetSongInfoL");

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicInfo, aSongId));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::Leave(KErrNotFound);

        }

    aDriveId = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),

        recordset.ColumnInt64(EMusicVolumeId));

    aArtistId = recordset.ColumnInt64(EMusicArtist);

    aAlbumId = recordset.ColumnInt64(EMusicAlbum);

    aGenreId = recordset.ColumnInt64(EMusicGenre);

    aComposerId = recordset.ColumnInt64(EMusicComposer);

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

    aAbstractAlbumId = recordset.ColumnInt64(EMusicAbstractAlbum);

#endif // ABSTRACTAUDIOALBUM_INCLUDED

    aArt = MPXDbCommonUtil::GetColumnTextL(recordset, EMusicArt).AllocL();

    HBufC* uri = ConstructUriL(recordset, aSongId);

    CleanupStack::PopAndDestroy(&recordset);

    return uri;

    }

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

// CMPXDbMusic::GetSongL

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

//

TInt CMPXDbMusic::GetSongL(

    const CMPXMedia& aCriteria,

    CMPXMedia*& aMedia)

    {

    MPX_FUNC("CMPXDbMusic::GetSongL");

    TUint32 songId(0);

    // find song Id, title, URI, and general flags from its Id and/or URI. Do not use "aCriteria"

    // because it may contain attributes other than Id and URI. We don't want to search the

    // song by fields other than the ID and URI because other attributes for the song may have

    // been changed in the collection since the song was added

    CMPXMedia* criteria = CMPXMedia::NewL();

    CleanupStack::PushL(criteria);

    if (aCriteria.IsSupported(KMPXMediaGeneralId))

        {

        songId = (aCriteria.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2;

        criteria->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, songId);

        }

    else if (aCriteria.IsSupported(KMPXMediaGeneralUri))

        {

        criteria->SetTextValueL(KMPXMediaGeneralUri,

            aCriteria.ValueText(KMPXMediaGeneralUri));

        }

    // get the criteria string

    HBufC* criteriaStr = GenerateMusicMatchingCriteriaLC(songId, 0, EMPXItem, *criteria);

    // execute the query

    RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryMusicSong, criteriaStr));

    CleanupClosePushL(recordset);

    TInt err(KErrNone);

    if ((err = recordset.Next()) == KSqlAtRow)

        {

        RArray<TMPXAttribute> attributes;

        CleanupClosePushL(attributes);

        attributes.AppendL(TMPXAttribute(KMPXMediaIdGeneral,