/*
* Copyright (c) 2009 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:
*
*/
/*
 * castoragetestorganize.cpp
 *
 *  Created on: 2009-08-14
 *      Author: maciej.walczynski
 */

#include "castoragetest.h"
#include "caoperationparams.h"
#include "castorage.h"
#include "caarraycleanup.inl"
#include "castoragetestsqlcommands.h"
#include "casqlcommands.h"
#include "cainnerentry.h"
#include "casqlitestorage.h"
#include "casqlquery.h"

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCAStorageTest::testOrganizeRemove()
{
    TInt err(KErrNone);

    __UHEAP_MARK;
    TRAP(err,
         RArray<TInt> entryIds;
         CleanupClosePushL(entryIds);
         entryIds.AppendL(15);
         entryIds.AppendL(16);

         TCaOperationParams organizeParams;
         organizeParams.iGroupId = 12;
         organizeParams.iOperationType = TCaOperationParams::ERemove;
         mStorage->OrganizeL(entryIds, organizeParams);

         CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
         innerQuery->SetParentId(12);
         RPointerArray<CCaInnerEntry> resultArray;
         CleanupResetAndDestroyPushL(resultArray);
         mStorage->GetEntriesL(innerQuery, resultArray);

         //    Check that entries with ids 15 and 16 are not in group 12
    for (TInt j = 0; j < entryIds.Count(); j++) {
    for (TInt i = 0; i < resultArray.Count(); i++) {
            if (resultArray[i]->GetId() == entryIds[j]) {
                err = KErrWrongData;
                break;
            }
        }
    }

    CleanupStack::PopAndDestroy(&resultArray);
    CleanupStack::PopAndDestroy(innerQuery);
    CleanupStack::PopAndDestroy(&entryIds);
        );
    __UHEAP_MARKEND;

    QCOMPARE(err, KErrNone);
}


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCAStorageTest::testOrganizeAppend()
{
    TInt err(KErrNone);

    __UHEAP_MARK;
    TRAP(err,
         RArray<TInt> entryIds;
         CleanupClosePushL(entryIds);
         entryIds.AppendL(8);
         entryIds.AppendL(7);

         TCaOperationParams organizeParams;
         organizeParams.iGroupId = 3;
         organizeParams.iOperationType = TCaOperationParams::EAppend;
         mStorage->OrganizeL(entryIds,organizeParams);

         CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
         innerQuery->SetParentId(3);
         innerQuery->SetSort(CCaInnerQuery::Default);
         RPointerArray<CCaInnerEntry> resultArray;
         CleanupResetAndDestroyPushL(resultArray);
         mStorage->GetEntriesL(innerQuery, resultArray);

         TInt j = resultArray.Count() - 1;
    for (TInt i = entryIds.Count() - 1; i >= 0; i--, j--) {
    if (resultArray[j]->GetId() != entryIds[i]) {
            err = KErrWrongData;
        }
    }

    CleanupStack::PopAndDestroy(&resultArray);
    CleanupStack::PopAndDestroy(innerQuery);
    CleanupStack::PopAndDestroy(&entryIds);
        );

    __UHEAP_MARKEND;

    QCOMPARE(err, KErrNone);
}


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCAStorageTest::testOrganizePrepend()
{
    TInt err(KErrNone);

    __UHEAP_MARK;
    TRAP(err,
         RArray<TInt> entryIds;
         CleanupClosePushL(entryIds);
         entryIds.AppendL(8);
         entryIds.AppendL(7);

         TCaOperationParams organizeParams;
         organizeParams.iGroupId = 3;
         organizeParams.iOperationType = TCaOperationParams::EPrepend;
         mStorage->OrganizeL(entryIds,organizeParams);

         CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
         innerQuery->SetParentId(3);
         innerQuery->SetSort(CCaInnerQuery::Default);
         RPointerArray<CCaInnerEntry> resultArray;
         CleanupResetAndDestroyPushL(resultArray);
         mStorage->GetEntriesL(innerQuery, resultArray);

         TInt j = 0;
    for (TInt i = 0; i < entryIds.Count(); i++, j++) {
    if (resultArray[j]->GetId() != entryIds[i]) {
            err = KErrWrongData;
        }
    }

    CleanupStack::PopAndDestroy(&resultArray);
    CleanupStack::PopAndDestroy(innerQuery);
    CleanupStack::PopAndDestroy(&entryIds);
        );
    __UHEAP_MARKEND;

    QCOMPARE(err, KErrNone);
}



// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCAStorageTest::testOrganizeInsertNewIntoGroup()
{
    TInt err(KErrNone);

    __UHEAP_MARK;
    TRAP(err,
         //insert somewhere in the middle
         RArray<TInt> entryIds;
         CleanupClosePushL(entryIds);
         TInt newInsertEntryId = 7;

         entryIds.AppendL(newInsertEntryId);

         CCaInnerQuery *innerQuery = CCaInnerQuery::NewLC();
         innerQuery->SetParentId(2);
         innerQuery->SetSort(CCaInnerQuery::Default);

         RPointerArray<CCaInnerEntry> resultArray1;
         CleanupResetAndDestroyPushL(resultArray1);
         mStorage->GetEntriesL(innerQuery, resultArray1);

         TInt count = resultArray1.Count();
         TInt insertPosition = count / 2;
         TInt beforeId = resultArray1[insertPosition - 1]->GetId();

         TCaOperationParams organizeParams;
         organizeParams.iGroupId = 2;
         organizeParams.iBeforeEntryId = beforeId;
         organizeParams.iOperationType = TCaOperationParams::EInsert;
         mStorage->OrganizeL(entryIds,organizeParams);

         RPointerArray<CCaInnerEntry> resultArray2;
         CleanupResetAndDestroyPushL(resultArray2);
         mStorage->GetEntriesL(innerQuery, resultArray2);

         TInt idNew = resultArray2[ insertPosition - 1 ]->GetId();
         err = (resultArray2[ insertPosition - 1 ]->GetId() == newInsertEntryId) ? err : KErrWrongData;
         err = (resultArray2[ insertPosition ]->GetId() == beforeId) ? err : KErrWrongData;

         //insert into 1st position (prepend)

         CCaSqLiteStorage *storage = STATIC_CAST(CCaSqLiteStorage *,mStorage);
         CCaSqlQuery *query = CCaSqlQuery::NewLC(storage->iSqlDb);
         query->SetQueryL(KSQLGetUnexistingIdFromGroup);
         query->PrepareL();
         query->BindIntL(query->iStatement.ParameterIndex(KSQLGEIdGroup), KAllCollectionsGroupId);
         TInt unexistingIdInGroup;
         query->ExecuteL(unexistingIdInGroup);
         query->CloseStatement();
         entryIds.Reset();
         entryIds.AppendL(unexistingIdInGroup);
         TInt idFirst = resultArray2[ 0 ]->GetId();
         organizeParams.iBeforeEntryId = idFirst;
         mStorage->OrganizeL(entryIds,organizeParams);

         RPointerArray<CCaInnerEntry> resultArray3;
         CleanupResetAndDestroyPushL(resultArray3);
         mStorage->GetEntriesL(innerQuery, resultArray3);

         err = (resultArray3[ 0 ]->GetId() == unexistingIdInGroup) ? err : KErrWrongData;

         //insert before unexisting item
         TInt unexistingIdInGroup1;
         TInt unexistingIdInGroup2;
         query->SetQueryL(KSQLGetUnexistingIdFromGroup);
         query->PrepareL();
         query->BindIntL(query->iStatement.ParameterIndex(KSQLGEIdGroup), KAllCollectionsGroupId);
         query->ExecuteL(unexistingIdInGroup1);
         unexistingIdInGroup2 = unexistingIdInGroup1 + 1;
         query->CloseStatement();
         organizeParams.iBeforeEntryId = unexistingIdInGroup1;
         entryIds.Reset();
         entryIds.AppendL(unexistingIdInGroup2);

         TInt unexistingBeforeIdError(KErrNone);
         TRAP(unexistingBeforeIdError, mStorage->OrganizeL(entryIds,organizeParams));
    if (KErrNone == unexistingBeforeIdError) {
    err = KErrBadParams;
}

CleanupStack::PopAndDestroy(&resultArray3);
CleanupStack::PopAndDestroy(query);
CleanupStack::PopAndDestroy(&resultArray2);
CleanupStack::PopAndDestroy(&resultArray1);
CleanupStack::PopAndDestroy(innerQuery);
CleanupStack::PopAndDestroy(&entryIds);
    );
    __UHEAP_MARKEND;
    QCOMPARE(err, KErrNone);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCAStorageTest::testOrganizeBadParams()
{
    TInt err(KErrNone);
    __UHEAP_MARK;
    TRAP(err,
         RArray<TInt> errorArray;
         CleanupClosePushL(errorArray);
         RArray<TInt> entryIds;
         CleanupClosePushL(entryIds);
         TCaOperationParams organizeParams;
         CCaSqLiteStorage *storage = STATIC_CAST(CCaSqLiteStorage *,mStorage);
         CCaSqlQuery *query = CCaSqlQuery::NewLC(storage->iSqlDb);

         query->SetQueryL(KSQLGetUnexistingIdFromGroup);
         query->PrepareL();
         query->BindIntL(query->iStatement.ParameterIndex(KSQLGEIdGroup), KAllCollectionsGroupId);
         TInt unexistingIdInGroup;
         query->ExecuteL(unexistingIdInGroup);
         query->CloseStatement();
         organizeParams.iOperationType = TCaOperationParams::ERemove;
         entryIds.Append(unexistingIdInGroup);
         entryIds.Append(unexistingIdInGroup + 1);
         TRAP(err, mStorage->OrganizeL(entryIds,organizeParams));
         errorArray.AppendL(err);
         err = KErrNone;
         entryIds.Reset();

         organizeParams.iOperationType = TCaOperationParams::EInsert;
         organizeParams.iBeforeEntryId = unexistingIdInGroup;
         entryIds.Append(unexistingIdInGroup + 1);
         TRAP(err, mStorage->OrganizeL(entryIds,organizeParams));
         errorArray.AppendL(err);
         err = KErrNone;

    for (TInt i = 0; i < errorArray.Count(); i++) {
    if (errorArray[i] == 0) {
            err = KErrBadParams;
            break;
        }
    }

    CleanupStack::PopAndDestroy(query);
    CleanupStack::PopAndDestroy(&entryIds);
    CleanupStack::PopAndDestroy(&errorArray);
        );
    __UHEAP_MARKEND;
    QCOMPARE(err, KErrNone);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCAStorageTest::testCustomSort()
{
    TInt err(KErrNone);
    __UHEAP_MARK;
    TRAP(err,
         const TInt KGroupId = 12;

         RArray<TInt> entryIds;
         CleanupClosePushL(entryIds);
         RArray<TInt> entryIdsFromDb;
         CleanupClosePushL(entryIdsFromDb);

         // array with custom sorted ids
         entryIds.AppendL(14);   // 13
         entryIds.AppendL(15);   // 14
         entryIds.AppendL(13);   // 15
         entryIds.AppendL(16);   // 16
         entryIds.AppendL(17);   // 17

         // test
         mStorage->CustomSortL(entryIds, KGroupId);

         // check results
         CCaSqLiteStorage *storage = STATIC_CAST(CCaSqLiteStorage *, mStorage);
         CCaSqlQuery *query = CCaSqlQuery::NewLC(storage->iSqlDb);
         query->SetQueryL(KSQLGetEntryIdsFromGroupInPositionOrder);
         query->PrepareL();
         query->BindIntL(query->iStatement.ParameterIndex(KSQLGEIdGroup), KGroupId);
         TInt count = query->ExecuteL(entryIdsFromDb, CCaSqlQuery::EGroupTable);
         query->CloseStatement();

    for (TInt i=0; i<entryIds.Count(); i++) {
    if (entryIds[i] != entryIdsFromDb[i]) {
            err = KErrBadParams;
            break;
        }
    }

    CleanupStack::PopAndDestroy(query);
    CleanupStack::PopAndDestroy(&entryIdsFromDb);
    CleanupStack::PopAndDestroy(&entryIds);
        );
    __UHEAP_MARKEND;
    QCOMPARE(err, KErrNone);
}