/*

* 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 interaction with the playlist tables.

*

*/

// INCLUDE FILES

#include <f32file.h>

#include <mpxlog.h>

#include <mpxmediacontainerdefs.h>

#include "mpxdbcommonutil.h"

#include "mpxdbcommondef.h"

#include "mpxdbcommonstd.h"

#include "mpxcollectiondbdef.h"

#include "mpxdbmanager.h"

#include "mpxdbutil.h"

#include "mpxdbpluginqueries.h"

#include "mpxdbplaylistsongs.h"

#include "mpxdbplaylist.h"

// CONSTANTS

// UniqueID column in Uris requests

const TInt KColUniqueID = 0;

// URI column in Uris requests

const TInt KColUri = 1;

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

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

// Two-phased constructor.

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

//

CMPXDbPlaylist* CMPXDbPlaylist::NewL(

    CMPXDbManager& aDbManager,

	MMPXDbPlaylistObserver& aObserver)

    {

    MPX_FUNC("CMPXDbPlaylist::NewL");

    CMPXDbPlaylist* self = CMPXDbPlaylist::NewLC(aDbManager, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXDbPlaylist* CMPXDbPlaylist::NewLC(

    CMPXDbManager& aDbManager,

	MMPXDbPlaylistObserver& aObserver)

    {

    MPX_FUNC("CMPXDbPlaylist::NewLC");

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXDbPlaylist::~CMPXDbPlaylist()

    {

    MPX_FUNC("CMPXDbPlaylist::~CMPXDbPlaylist");

    delete iPlaylistSongs;

    }

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

// Constructor

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

//

CMPXDbPlaylist::CMPXDbPlaylist(

    CMPXDbManager& aDbManager,

    MMPXDbPlaylistObserver& aObserver) :

    CMPXDbTable(aDbManager),

	iObserver(aObserver)

    {

    MPX_FUNC("CMPXDbPlaylist::CMPXDbPlaylist");

    }

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

// Second phase constructor.

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

//

void CMPXDbPlaylist::ConstructL()

    {

    MPX_FUNC("CMPXDbPlaylist::ConstructL");

    BaseConstructL();

    iPlaylistSongs = CMPXDbPlaylistSongs::NewL(iDbManager);

    }

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

// CMPXDbPlaylist::AddPlaylistL

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

//

TUint32 CMPXDbPlaylist::AddPlaylistL(

    const CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXDbPlaylist::AddPlaylistL");

    // make sure the playlist and the corresponding songs are deleted

    TUint32 playlistId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXPlaylist,

        aMedia.ValueText(KMPXMediaGeneralUri), EFalse));

    DeletePlaylistNoUriL(playlistId);

    // add the playlist

    return DoAddPlaylistL(aMedia, TDriveUnit(aMedia.ValueText(KMPXMediaGeneralUri)));

    }

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

// CMPXDbPlaylist::AddSongsL

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

//

void CMPXDbPlaylist::AddSongsL(

    TUint32 aPlaylistId,

    const CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbPlaylist::AddSongsL");

    // get the drive ID of corresponding playlist

    TInt drive(GetDriveIdL(aPlaylistId));

    // add the songs

    iPlaylistSongs->AddSongsL(aPlaylistId, aMediaArray, drive);

    // update the time for the playlist

    UpdatePlaylistTimeL(aPlaylistId, drive);

    }

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

// CMPXDbPlaylist::UpdatePlaylistL

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

//

void CMPXDbPlaylist::UpdatePlaylistL(

    const CMPXMedia& aMedia,

    CMPXMessage& aMessage,

    TInt aDriveId)

    {

    MPX_FUNC("CMPXDbPlaylist::UpdatePlaylistL");

    TUint32 playlistId((aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2);

    DoUpdatePlaylistL(playlistId, aMedia, aDriveId, aMessage);

    }

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

// CMPXDbPlaylist::UpdateSongL

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

//

TBool CMPXDbPlaylist::UpdateSongL(

    const CMPXMedia& aMedia,

    TBool aResetFlags,

    CMPXMessageArray* aItemChangedMessages /* = NULL */)

    {

    MPX_FUNC("CMPXDbPlaylist::UpdateSongL");

    // find the song ID

    TInt oldSongId(0);

    TInt newSongId(0);

    if (aMedia.IsSupported(KMPXMediaGeneralId))

        {

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

        }

    if (aMedia.IsSupported(KMPXMediaGeneralUri))

        {

        newSongId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXCollection,

            aMedia.ValueText(KMPXMediaGeneralUri), EFalse);

        }

    if ( !aMedia.IsSupported( KMPXMediaGeneralId ) && !aMedia.IsSupported( KMPXMediaGeneralUri ))

        {

        User::Leave( KErrArgument );

        }

    if ( newSongId <= 0 )

        {

        newSongId = oldSongId;

        }

    if ( oldSongId <= 0 )

        {

        oldSongId = newSongId;

        }

    // update the PlaylistSongs and PlaylistSongInfo tables first

    TBool updated(EFalse);

    TBool visible(iPlaylistSongs->UpdateSongL( oldSongId, aMedia, aResetFlags, updated ));

    TBool bSongInPlaylists( EFalse );

    if (updated)

        {

        UpdatePlaylistsForSongL( newSongId, aItemChangedMessages,bSongInPlaylists );

        }

    return visible;

    }

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

// CMPXDbPlaylist::DeleteSongL

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

//

void CMPXDbPlaylist::DeleteSongL(

    TUint32 aSongId,

    CMPXMessageArray& aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbPlaylist::DeleteSongL");

    TBool bSongInPlaylists(EFalse);

    // add item changed messages for all playlists that contain the song

    UpdatePlaylistsForSongL (aSongId, &aItemChangedMessages, bSongInPlaylists);

    if (bSongInPlaylists)

        {

        // delete the song from the PlaylistSongs and PlaylistSongInfo tables

        iPlaylistSongs->DeleteSongL (aSongId);

        }

    }

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

// CMPXDbPlaylist::DeleteSongL

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

//

void CMPXDbPlaylist::DeleteSongL(

    TUint32 aPlaylistId,

    TUint32 aSongId,

    TInt aOrdinal)

    {

    MPX_FUNC("CMPXDbPlaylist::DeleteSongL");

    // get playlist drive

    TInt drive(GetDriveIdL(aPlaylistId));

    // delete the song from the PlaylistSongs / PlaylistSongInfo tables

    iPlaylistSongs->DeleteSongL(aPlaylistId, aSongId, aOrdinal, drive);

    // update the time for the playlist

    UpdatePlaylistTimeL(aPlaylistId, drive);

    }

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

// CMPXDbPlaylist::DeletePlaylistL

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

//

HBufC* CMPXDbPlaylist::DeletePlaylistL(

    TUint32 aPlaylistId)

    {

    MPX_FUNC("CMPXDbPlaylist::DeletePlaylistL");

    // get the uri

    HBufC* uri = GetUriL(aPlaylistId);

    if (uri)

        {

        CleanupStack::PushL(uri);

        TDriveUnit drive(*uri);

        // delete the songs from the PlaylistSongs table

        iPlaylistSongs->DeleteSongsL(aPlaylistId, drive);

        // delete the playlist record from the Playlist table

        iDbManager.ExecuteQueryL(drive, KQueryPlaylistDelete, aPlaylistId);

        CleanupStack::Pop(uri);

        }

    return uri;

    }

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

// CMPXDbPlaylist::DeletePlaylistNoUriL

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

//

void CMPXDbPlaylist::DeletePlaylistNoUriL(

    TUint32 aPlaylistId)

    {

    MPX_FUNC("CMPXDbPlaylist::DeletePlaylistNoUriL");

    TInt drive(0);

    MPX_TRAPD(err, drive = GetDriveIdL(aPlaylistId));

    if (err != KErrNotFound)

        {

        User::LeaveIfError(err);

        // delete the songs from the PlaylistSongs table

        iPlaylistSongs->DeleteSongsL(aPlaylistId, drive);

        // delete the playlist record from the Playlist table

        iDbManager.ExecuteQueryL(drive, KQueryPlaylistDelete, aPlaylistId);

        }

    }

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

// CMPXDbPlaylist::DeleteAllPlaylistsL

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

//

void CMPXDbPlaylist::DeleteAllPlaylistsL()

    {

    MPX_FUNC("CMPXDbPlaylist::DeleteAllPlaylistsL");

    // delete the songs from the PlaylistSongs table

    iPlaylistSongs->DeleteAllSongsL();

    // delete all playlists

    iDbManager.ExecuteQueryL(KDbManagerAllDrives, KQueryPlaylistDeleteAll);

    }

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

// CMPXDbPlaylist::CountL

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

//

TInt CMPXDbPlaylist::CountL()

    {

    MPX_FUNC("CMPXDbPlaylist::CountL");

    return ExecuteSumQueryL(KQueryPlaylistCount);

    }

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

// CMPXDbPlaylist::GetPlaylistL

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

//

void CMPXDbPlaylist::GetPlaylistL(

    TUint32 aPlaylistId,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXDbPlaylist::GetPlaylistL");

    ExecuteMediaQueryL(aAttrs, aMedia, KQueryPlaylistGet, aPlaylistId);

    }

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

// CMPXDbPlaylist::GetAllPlaylistsL

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

//

void CMPXDbPlaylist::GetAllPlaylistsL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbPlaylist::GetAllPlaylistsL");

    ExecuteMediaQueryL(aAttrs, aMediaArray, KQueryPlaylistGetAll);

    }

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

// CMPXDbPlaylist::GetNameL

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

//

HBufC* CMPXDbPlaylist::GetNameL(

    TUint32 aPlaylistId)

    {

    MPX_FUNC("CMPXDbPlaylist::GetNameL");

    RSqlStatement recordset(GetPlaylistRecordL(aPlaylistId));

    CleanupClosePushL(recordset);

    HBufC* name(NULL);

    TInt err(KErrNone);

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

        {

        name = MPXDbCommonUtil::GetColumnTextL(recordset, EPlaylistName).AllocL();

        }

    CleanupStack::PopAndDestroy(&recordset);

    if (err != KSqlAtEnd)

        {

        User::LeaveIfError(err);

        }

    if (name == NULL)

        {

        User::LeaveIfError(KErrNotFound);

        }

    return name;

    }

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

// CMPXDbPlaylist::GetUriL

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

//

HBufC* CMPXDbPlaylist::GetUriL(

    TUint32 aPlaylistId)

    {

    MPX_FUNC("CMPXDbPlaylist::GetUriL");

    RSqlStatement recordset(GetPlaylistRecordL(aPlaylistId));

    CleanupClosePushL(recordset);

    HBufC* uri(NULL);

    TInt err(KErrNone);

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

        {

        uri = MPXDbCommonUtil::CreateFullPathL(

            MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(),

            recordset.ColumnInt64(EPlaylistVolumeId)),

            MPXDbCommonUtil::GetColumnTextL(recordset, EPlaylistUri));

        }

    CleanupStack::PopAndDestroy(&recordset);

    if (err != KSqlAtEnd)

        {

        User::LeaveIfError(err);

        }

    if (uri == NULL)

        {

        User::LeaveIfError(KErrNotFound);

        }

    return uri;

    }

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

// CMPXDbPlaylist::GetIdL

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

//

TUint32 CMPXDbPlaylist::GetIdL(

    const TDesC& aUri)

    {

    MPX_FUNC("CMPXDbPlaylist::GetIdL");

    HBufC* uri = MPXDbCommonUtil::ProcessPatternCharsLC( aUri );

    TUint32 ret = ExecuteIntQueryL(

        KQueryLikePlaylistId, uri->Mid( KMCPathStartPos ) );

   	CleanupStack::PopAndDestroy( uri );

    return ret;

    }

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

// CMPXDbPlaylist::FindAllL

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

//

void CMPXDbPlaylist::FindAllL(

    const CMPXMedia& aCriteria,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbPlaylist::FindAllL");

    // process the requested attributes

    // the UniqueId is always requested

    TBool titleRequested(EFalse);

    TBool counterRequested(EFalse);

    TInt viewingColumnCount(aAttrs.Count());

    for (TInt i = 0; (i < viewingColumnCount) && !(titleRequested && counterRequested); ++i)

        {

        if (aAttrs[i].ContentId() == KMPXMediaIdGeneral)

            {

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

            if (attributeId & EMPXMediaGeneralTitle)

                {

                titleRequested = ETrue;

                }

            if (attributeId & EMPXMediaGeneralCount)

                {

                counterRequested = ETrue;

                }

            }

        }

    TMPXGeneralType type = aCriteria.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);

    const TArray<TMPXAttribute> criteria = aCriteria.Attributes();

    TInt criteriaCount(criteria.Count());

    // process the criteria and construct the criteria string

    CDesCArrayFlat* criteriaArray = new (ELeave) CDesCArrayFlat(criteriaCount);

    CleanupStack::PushL(criteriaArray);

    TBool criteriaCounterSet(EFalse);

    TInt criteriaCounter(0);

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

        {

        const TMPXAttribute& criterion = criteria[i];

        if (type == EMPXItem && criterion == KMPXMediaGeneralId)

            {

            TUint32 itemId((aCriteria.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId)).iId2);

            if (MPX_ITEM_CATEGORY(itemId) != EMPXPlaylist)

                {

                User::Leave(KErrNotSupported);

                }

            MPXDbCommonUtil::AddSqlCriterionL(*criteriaArray, KCriterionPlaylistUniqueId, itemId);

            }

        else if (criterion == KMPXMediaGeneralTitle)

            {

            HBufC* title = MPXDbCommonUtil::ProcessPatternCharsLC(

                aCriteria.ValueText(KMPXMediaGeneralTitle));

            if( type == EMPXOtherType )

                {

                MPXDbCommonUtil::AddSqlCriterionL(*criteriaArray, KCriterionPlaylistTitle, *title);

                }

            else

                {

            MPXDbCommonUtil::AddSqlCriterionL(*criteriaArray, KCriterionPlaylistLikeTitle, *title);

                }

            CleanupStack::PopAndDestroy(title);

            }

        else if (criterion == KMPXMediaGeneralUri)

            {

            MPXDbCommonUtil::AddSqlCriterionL(*criteriaArray, KCriterionPlaylistUniqueId,

                MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXPlaylist,

                aCriteria.ValueText(KMPXMediaGeneralUri), EFalse));

            }

        else if (criterion == KMPXMediaGeneralDrive)

            {

            const TDesC& drive(aCriteria.ValueText(KMPXMediaGeneralDrive));

            TDriveUnit driveUnit(drive);

            MPXDbCommonUtil::AddSqlCriterionL(*criteriaArray, KCriterionPlaylistVolumeId,

                MPXDbCommonUtil::GetVolIdMatchDriveIdL(iDbManager.Fs(), driveUnit));

            }

        else if (criterion == KMPXMediaGeneralSynchronized)

            {

            MPXDbCommonUtil::AddSqlCriterionL(*criteriaArray, KCriterionPlaylistSync,

                aCriteria.ValueTObjectL<TBool>(KMPXMediaGeneralSynchronized));

            }