/*

* Copyright (c) 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:  Implements the base class for the various lookup tables

*

*/

// INCLUDE FILES

#include <sqldb.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxlog.h>

#include "mpxdbcommonutil.h"

#include "mpxdbcommondef.h"

#include "mpxdbmanager.h"

#include "mpxdbutil.h"

#include "mpxpodcastcollectiondbdef.h"

#include "mpxpodcastcollectiondbstd.h"

#include "mpxpodcastdbpluginqueries.h"

#include "mpxdbcategory.h"

// CONSTANTS

// maximum number of table name entries per query

const TInt KMaxTableNameCount = 2;

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

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

// Two-phased constructor.

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

//

CMPXDbCategory* CMPXDbCategory::NewL(

    CMPXDbManager& aDbManager,

    TMPXGeneralCategory aCategory)

    {

    MPX_FUNC("CMPXDbCategory::NewL");

    CMPXDbCategory* self = CMPXDbCategory::NewLC(aDbManager, aCategory);

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor, leave object in cleanup stack.

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

//

CMPXDbCategory* CMPXDbCategory::NewLC(

    CMPXDbManager& aDbManager,

    TMPXGeneralCategory aCategory)

    {

    MPX_FUNC("CMPXDbCategory::NewLC");

    CMPXDbCategory* self = new (ELeave) CMPXDbCategory(aDbManager, aCategory);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Destructor.

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

//

CMPXDbCategory::~CMPXDbCategory()

    {

    MPX_FUNC("CMPXDbCategory::~CMPXDbCategory");

    delete iTableName;

    }

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

// Constructor

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

//

CMPXDbCategory::CMPXDbCategory(

    CMPXDbManager& aDbManager,

    TMPXGeneralCategory aCategory) :

    CMPXDbTable(aDbManager),

    iCategory(aCategory)

    {

    MPX_FUNC("CMPXDbCategory::CMPXDbCategory");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXDbCategory::ConstructL()

    {

    MPX_FUNC("CMPXDbCategory::ConstructL");

    BaseConstructL();

    iTableName = MPXDbUtil::TableNameForCategoryL(iCategory).AllocL();

    }

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

// Add a row containing the name to the lookup table

// If the name already exists in the table, increment the count

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

//

TUint32 CMPXDbCategory::AddItemL(

    const TDesC& aName,

    TInt aDriveId,

    TBool& aNewRecord,

    TBool aCaseSensitive)

    {

    MPX_FUNC("CMPXDbCategory::AddItemL");

    // try to find the item first

    TUint32 rowId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), iCategory, aName, aCaseSensitive));

    aNewRecord = !CategoryItemExistsL(aDriveId, rowId);

    if (aNewRecord)

        {

        // insert new

        HBufC* query = PreProcessStringLC(KQueryCategoryInsert);

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

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

        CleanupStack::PopAndDestroy(name);

        CleanupStack::PopAndDestroy(query);

        }

    else

        {

        // increment the number of episodes for the category

        HBufC* query = PreProcessStringLC(KQueryCategoryIncrementEpisodeCount);

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

        CleanupStack::PopAndDestroy(query);

        }

    return rowId;

    }

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

// Get the name of the row matching the given ID

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

//

HBufC* CMPXDbCategory::GetNameL(

    TUint32 aId)

    {

    MPX_FUNC("CMPXDbCategory::GetNameL");

    RSqlStatement recordset(GetCategoryRecordL(aId));

    CleanupClosePushL(recordset);

    if (recordset.Next() != KSqlAtRow)

        {

        User::LeaveIfError(KErrNotFound);

        }

    HBufC* name = MPXDbCommonUtil::GetColumnTextL(recordset, ECategoryName).AllocL();

    CleanupStack::PopAndDestroy(&recordset);

    return name;

    }

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

// Count the total number of items

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

//

TInt CMPXDbCategory::CountL()

    {

    MPX_FUNC("CMPXDbCategory::CountL");

    HBufC* query = PreProcessStringLC(KQueryCategoryCount);

    TInt count(ExecuteSumQueryL(*query));

    CleanupStack::PopAndDestroy(query);

    return count;

    }

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

// Find record(s) that match(es) the selection criteria

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

//

void CMPXDbCategory::FindAllL(

    const CMPXMedia& aCriteria,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbCollection::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; ++i)

        {

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

        if (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 + 1);

    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) != iCategory)

                {

                User::Leave(KErrNotSupported);

                }

            HBufC* critStr = PreProcessStringLC(KCriterionCategoryUniqueId);

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

            CleanupStack::PopAndDestroy(critStr);

            }

        else if (criterion == KMPXMediaGeneralTitle)

            {

            HBufC* critStr = PreProcessStringLC(KCriterionCategoryName);

            HBufC* title = MPXDbCommonUtil::ProcessPatternCharsLC(

                aCriteria.ValueText(KMPXMediaGeneralTitle));

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

            CleanupStack::PopAndDestroy(2, critStr); // title & Str

            }

        else if (criterion == KMPXMediaGeneralCount)

            {

            criteriaCounterSet = ETrue;

            criteriaCounter = aCriteria.ValueTObjectL<TInt>(KMPXMediaGeneralCount);

            }

        else

            {

            // ignore attribute

            }

        }

    // construct criteria string

    HBufC* criteriaStr = MPXDbCommonUtil::StringFromArrayLC(*criteriaArray, KMCAndKeyword);

    // either get all items or items filtered based on criteria

    HBufC* query = PreProcessStringLC(criteriaStr->Length() ?

        KQueryCategoryItems() : KQueryCategoryAll());

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

    CleanupStack::PopAndDestroy(query);

    CleanupStack::PopAndDestroy(criteriaStr);

    CleanupStack::PopAndDestroy(criteriaArray);

    CleanupClosePushL(recordset);

    // It is possible to get multiple records with the same ID in the case where the same category

    // name is present on more than one drive (the unique ID is constructed from the name alone

    // for categories). The records have to be processed manually as the songs count cannot be

    // summed in the query.

    //

    // Unknown artist/album/genre/composer is stored in the database as NULL (name field). This

    // ensures the unknown artist/album/genre/composer to be the 1st found record if it exists.

    // This will save time in searching for the unknown record among the results and avoid

    // performing descriptor comparison.

    // If the 1st record is the unknown artist/album/genre/composer, it won't be appended to the

    // array until all other records have been put in the array.

    //

    // NOTE: putting unknown artist/album/genre/composer to the end of the array only takes place

    //       when title field is requested. normal sorting algorithm occurs if title isn't requested,

    //       i.e. client requests for Id only. The Id of the unknown record will be the 1st item in

    //       the array if it exists.

    //

    TBool firstGroup(ETrue);

    CMPXMedia* unknownMedia(NULL);

    CMPXMedia* media(NULL);

    TUint32 prevId(0);

    TUint32 currId(0);

    TUint32 accumulatedCounter(0);

    TInt err(KErrNone);

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

        {

        // Setup basic info - with first record of a group

        currId = recordset.ColumnInt64(ECategoryUniqueId);

        if (currId != prevId)

            {

            // first or new set of records

            if (media)

                {

                // valid previous record set

                if (criteriaCounterSet && (criteriaCounter != accumulatedCounter))

                    {

                    // the counter criterion does not match

                    // discard the media and unknownMedia

                    CleanupStack::PopAndDestroy(media);

                    if (firstGroup && unknownMedia)

                        {

                        unknownMedia = NULL;

                        }

                    }

                else

                    {

                    if (!firstGroup || !unknownMedia)

                        {

                        // append the media to the array

                        if (counterRequested)

                            {

                            media->SetTObjectValueL<TInt>(KMPXMediaGeneralCount, accumulatedCounter);

                            }

                        aMediaArray.AppendL(*media);

                        CleanupStack::PopAndDestroy(media);

                        }

                    firstGroup = EFalse;

                    }

                }

            // start a new media object

            media = CMPXMedia::NewL();

            CleanupStack::PushL(media);

            media->SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXItem);

            media->SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, iCategory);

            media->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, currId);

            if (titleRequested)

                {

                TPtrC name = MPXDbCommonUtil::GetColumnTextL(recordset, ECategoryName);

                if (firstGroup && (name.Length() == 0))

                    {

                    unknownMedia = media;

                    }

                media->SetTextValueL(KMPXMediaGeneralTitle, name);

                }

            accumulatedCounter = 0;

            prevId = currId;

            }

        accumulatedCounter += GetEpisodeCountL(KDbManagerAllDrives, currId);

        }

    // process last record

    if (media)

        {

        // valid previous record set

        if (criteriaCounterSet && (criteriaCounter != accumulatedCounter))

            {

            // the counter criterion does not match

            // discard the media and unknownMedia

            CleanupStack::PopAndDestroy(media);

            if (firstGroup && unknownMedia)

                {

                unknownMedia = NULL;

                }

            }

        else

            {

            if (!firstGroup || !unknownMedia)

                {

                // append the media to the array

                if (counterRequested)

                    {

                    media->SetTObjectValueL<TInt>(KMPXMediaGeneralCount, accumulatedCounter);

                    }

                aMediaArray.AppendL(*media);

                CleanupStack::PopAndDestroy(media);

                }

            }

        }

    if (unknownMedia)

        {

        aMediaArray.AppendL(*unknownMedia);

        CleanupStack::PopAndDestroy(unknownMedia); // the first media that contains unknown title

        }

    CleanupStack::PopAndDestroy(&recordset);

    if (err != KSqlAtEnd)

        {

        User::LeaveIfError(err);

        }

    }

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

// Decrement the number of episodes in the row. If the count gets to 0, remove the row.

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

//

void CMPXDbCategory::DecrementEpisodesForCategoryL(

    const TUint32 aId,

    TInt aDriveId,

    CMPXMessageArray* aItemChangedMessages)

    {

    MPX_FUNC("CMPXDbCategory::DecrementEpisodesForCategoryL");

    // if just one episode uses this category, use <= just in case

    if (GetEpisodeCountL(aDriveId, aId) <= 1)

        {

        // delete the category

        DeleteCategoryL(aId, aDriveId);

        if (aItemChangedMessages)

            {

            // add the item changed message

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

                iCategory, KDBPluginUid);

            }

        }

    else

        {

        // decrement the number of episodes for the category

        HBufC* query = PreProcessStringLC(KQueryCategoryDecrementEpisodeCount);

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

        CleanupStack::PopAndDestroy(query);

        }

    }

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

// CMPXDbCategory::DeleteCategoryL

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

//

void CMPXDbCategory::DeleteCategoryL(

    TUint32 aId,

    TInt aDriveId)

    {

    MPX_FUNC("CMPXDbCategory::DeleteCategoryL");

    HBufC* query = PreProcessStringLC(KQueryCategoryDelete);

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

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbCategory::GetCategoryItemL

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

//

void CMPXDbCategory::GetCategoryItemL(

    TUint32 aId,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aMedia)

    {

    MPX_FUNC("CMPXDbCategory::GetCategoryItemL");

    HBufC* query = PreProcessStringLC(KQueryCategoryItem);

    ExecuteMediaQueryL(aAttrs, aMedia, *query, aId);

    CleanupStack::PopAndDestroy(query);

    }

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

// CMPXDbCategory::GetCategoryItemsL

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

//

void CMPXDbCategory::GetCategoryItemsL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMediaArray& aMediaArray)

    {

    MPX_FUNC("CMPXDbCategory::GetCategoryItemsL");

    // have to run one query to get all items as opposed to individual queries

    // because of the sorting

    // construct the unique ID criteria string

    // (UniqueId = %u OR UniqueId = %u ...)

    TInt itemCount(aMediaArray.Count());

    HBufC* criteria = HBufC::NewLC((2 * KCriterionCategoryUniqueId().Length() +

        KMCIntegerLen + KMCOrKeyword().Length() + 2) * itemCount);

    TPtr ptr(criteria->Des());

    ptr.Append(KMCOpenBracket);

    for (TInt index = 0; index < itemCount; ++index)

        {

        CMPXMedia* media = aMediaArray[index];

        HBufC* critStr = PreProcessStringLC(KCriterionCategoryUniqueId);

        HBufC* criterion = MPXDbCommonUtil::SqlCriterionLC(*critStr,

            media->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));

        ptr.Append(*criterion);

        CleanupStack::PopAndDestroy(criterion);

        CleanupStack::PopAndDestroy(critStr);

        if (index < itemCount - 1)

            {

            ptr.Append(KMCOrKeyword);

            }

        }

    ptr.Append(KMCCloseBracket);

    // the array has to be reset as the items have to be returned in a different sort order

    aMediaArray.Reset();

    HBufC* query = PreProcessStringLC(KQueryCategoryItems);

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

    CleanupStack::PopAndDestroy(query);

    CleanupStack::PopAndDestroy(criteria);

    CleanupClosePushL(recordset);

    ProcessRecordsetL(aAttrs, recordset, aMediaArray);

    CleanupStack::PopAndDestroy(&recordset);