#include <e32test.h>

#include <cntdef.h>

#include <cntdb.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntfldst.h>

#include <cntviewbase.h>

_LIT(KTestName, "T_PreferencesBug");

_LIT(KTestDbName, "c:T_PreferencesBug.cdb");

const TInt KEventWaitTime = 2;

LOCAL_D RTest test(KTestName);

enum TPanicCode

    {

    EPanicNoReadyEventFromView = 1

    };

static void Panic(TInt aReason)

    {

    User::Panic(KTestName, aReason);

    }

class CTestResources : public CBase

    {

    public: // Interface

        static CTestResources* NewLC();

        void ConstructL();

        void CreateTestViewsL

            (TContactViewPreferences aAddViewPreferences=static_cast<TContactViewPreferences>(0));

        ~CTestResources();

        enum TTestViews

            {

            ETestViewContactsOnly, 

            ETestViewGroupsOnly, 

            ETestViewContactsAndGroups

            };

        CContactDatabase& Db() const { return *iDb; }

        CContactDbEventQueue& DbEvents() const { return *iDbEvents; }

        CContactViewBase& TestView(TTestViews aViewIndex) const

            {

            return *iTestViews[aViewIndex].iView;

            }

        CContactViewEventQueue& TestViewEvents(TTestViews aViewIndex) const

            {

            return *iTestViews[aViewIndex].iViewEvents;

            }

    private: // Implementation

        struct TTestViewInit

            {

            enum { KMaxSortOrderLen = 5 };

            TContactViewPreferences iViewPrefs;

            TInt iSortOrder[KMaxSortOrderLen];

            };

        class TTestView

            {

            public:

                TTestView();

                void InitLC

                    (CContactDatabase& aDb, 

                    TContactViewPreferences aAddViewPreferences,

                    const TTestViewInit& aInit);

                void Destroy();

                RContactViewSortOrder iSortOrder;

                CContactViewEventQueue* iViewEvents;

                CContactLocalView* iView;

            private:

                static void Cleanup(TAny* aPtr);

            };

    private:  // Data

        static const TTestViewInit iTestViewInit[];

        CContactDatabase* iDb;

        CContactDbEventQueue* iDbEvents;

        RArray<TTestView> iTestViews;

    };

// Constant data for creating the test views

const CTestResources::TTestViewInit CTestResources::iTestViewInit[] =

    {

        { EContactsOnly, 

        { KUidContactFieldFamilyNameValue, KUidContactFieldGivenNameValue, KUidContactFieldCompanyNameValue, KNullUidValue } },

        { EGroupsOnly, 

        { KUidContactFieldTemplateLabelValue, KNullUidValue } },

        { EContactAndGroups, 

        { KUidContactFieldFamilyNameValue, KUidContactFieldGivenNameValue, KUidContactFieldCompanyNameValue, KUidContactFieldTemplateLabelValue, KNullUidValue } },

        { static_cast<TContactViewPreferences>(0), { KNullUidValue } }

    };

CTestResources* CTestResources::NewLC()

    {

    CTestResources* self = new(ELeave) CTestResources;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

void CTestResources::ConstructL()

    {

    iDb = CContactDatabase::ReplaceL(KTestDbName);

    iDbEvents = CContactDbEventQueue::NewL(iDb);

    }

void CTestResources::CreateTestViewsL(TContactViewPreferences aAddViewPreferences)

    {

    for (const TTestViewInit* initData = iTestViewInit; 

        initData->iSortOrder[0]!=KNullUidValue;

        ++initData)

        {

        TTestView testView;

        testView.InitLC(*iDb,aAddViewPreferences,*initData);

        User::LeaveIfError(iTestViews.Append(testView));

        CleanupStack::Pop();  // testView

        }

    // Wait for the views to get ready

    for (TInt i=0; i<iTestViews.Count(); ++i)

        {

        TContactViewEvent event;

        __ASSERT_ALWAYS(iTestViews[i].iViewEvents->ListenForEvent(10,event),

            Panic(EPanicNoReadyEventFromView));

        __ASSERT_ALWAYS(event.iEventType==TContactViewEvent::EReady,

            Panic(EPanicNoReadyEventFromView));

        }

    }

CTestResources::~CTestResources()

    {

    for (TInt i=iTestViews.Count()-1; i>=0; --i)

        {

        iTestViews[i].Destroy();

        }

    iTestViews.Close();

    delete iDbEvents;

    delete iDb;

    TRAP_IGNORE(CContactDatabase::DeleteDatabaseL(KTestDbName));

    }

CTestResources::TTestView::TTestView()

    : iViewEvents(NULL), iView(NULL)

    {

    }

void CTestResources::TTestView::InitLC

        (CContactDatabase& aDb, 

        TContactViewPreferences aAddViewPreferences,

        const TTestViewInit& aInit)

    {

    CleanupStack::PushL(TCleanupItem(Cleanup,this));

    for (const TInt* fieldType=aInit.iSortOrder; *fieldType!=KNullUidValue; ++fieldType)

        {

        iSortOrder.AppendL(TUid::Uid(*fieldType));

        }

    iViewEvents = CContactViewEventQueue::NewL();

    iView = CContactLocalView::NewL

        (*iViewEvents, 

        aDb, 

        iSortOrder, 

        static_cast<TContactViewPreferences>(aInit.iViewPrefs|aAddViewPreferences));

    }

void CTestResources::TTestView::Destroy()

    {

    if (iView) iView->Close(*iViewEvents);

    delete iViewEvents;

    iSortOrder.Close();

    }

void CTestResources::TTestView::Cleanup(TAny* aPtr)

    {

    static_cast<TTestView*>(aPtr)->Destroy();

    }

LOCAL_C void AddFieldToContactL

        (CContactItem& aContact, TFieldType aFieldType, const TDesC& aText)

    {

    CContactItemField* field = CContactItemField::NewLC(KStorageTypeText, aFieldType);

    field->TextStorage()->SetTextL(aText);

    aContact.AddFieldL(*field);

    CleanupStack::Pop(field);

    }

LOCAL_C TContactItemId CreateTestContactL

        (CContactDatabase& aDb,

        const TDesC& aFamilyName, 

        const TDesC& aGivenName, 

        const TDesC& aCompanyName)

    {

    CContactCard* card = CContactCard::NewLC();

    AddFieldToContactL(*card, KUidContactFieldFamilyName, aFamilyName);

    AddFieldToContactL(*card, KUidContactFieldGivenName, aGivenName);

    AddFieldToContactL(*card, KUidContactFieldCompanyName, aCompanyName);

    const TContactItemId id = aDb.AddNewContactL(*card);

    CleanupStack::PopAndDestroy(card);

    return id;

    }

LOCAL_C TContactItemId CreateTestGroupL

        (CContactDatabase& aDb,

        const TDesC& aLabel) 

    {

    CContactItem* group = aDb.CreateContactGroupLC(aLabel);

    const TContactItemId id = group->Id();

    CleanupStack::PopAndDestroy(group);

    return id;

    }

/**

 * Returns ETrue if aView contains all the contacts in aContacts.

 */

LOCAL_C TBool ContainsAllContactsL

        (const CContactViewBase& aView, const CContactIdArray& aContacts)

    {

    for (TInt i=0; i < aContacts.Count(); ++i)

        {

        if (aView.FindL(aContacts[i])==KErrNotFound)

            {

            return EFalse;

            }

        }

    return ETrue;

    }

/**

 * Returns ETrue if aView doesn't contain _any_ contact of aContacts.

 */

LOCAL_C TBool DoesNotContainsContactsL

        (const CContactViewBase& aView, const CContactIdArray& aContacts)

    {

    for (TInt i=0; i < aContacts.Count(); ++i)

        {

        if (aView.FindL(aContacts[i])!=KErrNotFound)

            {

            return EFalse;

            }

        }

    return ETrue;

    }

// TEST CODE

LOCAL_C void TestOpenViewsWithExistingDataL

        (TContactViewPreferences aAddPrefs)

    {

    CTestResources* res = CTestResources::NewLC();

    // Create test contacts and a group

    CContactIdArray* groups = CContactIdArray::NewLC();

    groups->AddL(groupId);

    CContactIdArray* unsortedGroups = CContactIdArray::NewLC();

    groupId = CreateTestGroupL(res->Db(), _L(""));

    unsortedGroups->AddL(groupId);

    CContactIdArray* contacts = CContactIdArray::NewLC();

    contacts->AddL(id);

    res->Db().AddContactToGroupL(id,(*groups)[0]);

    contacts->AddL(id);

    res->Db().AddContactToGroupL(id,(*groups)[0]);

    contacts->AddL(id);

    CContactIdArray* unsortedContacts = CContactIdArray::NewLC();

    id = CreateTestContactL(res->Db(), _L(""), _L(""), _L(""));

    unsortedContacts->AddL(id);

    id = CreateTestContactL(res->Db(), _L(" "), _L(" "), _L(" "));

    if (aAddPrefs & ESingleWhiteSpaceIsEmptyField)

        {

        unsortedContacts->AddL(id);

        }

    else

        {

        contacts->AddL(id);

        }

    // Eat all DB events

    TContactDbObserverEvent dbEvent;

    while (res->DbEvents().ListenForEvent(KEventWaitTime,dbEvent))

        {

        }

    // Create the test contact views

    res->CreateTestViewsL(aAddPrefs);

    // Check the test view states

    test.Next(_L("Check EContactsOnly view contains all the contacts"));

    test(ContainsAllContactsL(res->TestView(CTestResources::ETestViewContactsOnly), *contacts));

    if (res->TestView(CTestResources::ETestViewContactsOnly).ContactViewPreferences() & EIgnoreUnSorted)

        {

        test(DoesNotContainsContactsL(res->TestView(CTestResources::ETestViewContactsOnly), *unsortedContacts));

        }

    else

        {

        test(ContainsAllContactsL(res->TestView(CTestResources::ETestViewContactsOnly), *unsortedContacts));

        }

    test.Next(_L("Check EGroupsOnly view contains all the groups"));

    test(ContainsAllContactsL(res->TestView(CTestResources::ETestViewGroupsOnly), *groups));

    if (res->TestView(CTestResources::ETestViewGroupsOnly).ContactViewPreferences() & EIgnoreUnSorted)

        {

        test(DoesNotContainsContactsL(res->TestView(CTestResources::ETestViewGroupsOnly), *unsortedGroups));

        }

    else

        {

        test(ContainsAllContactsL(res->TestView(CTestResources::ETestViewGroupsOnly), *unsortedGroups));

        }

    test.Next(_L("Check EContactAndGroups view contains all contacts and groups"));

    test(ContainsAllContactsL(res->TestView(CTestResources::ETestViewContactsAndGroups), *groups));

    test(ContainsAllContactsL(res->TestView(CTestResources::ETestViewContactsAndGroups), *contacts));

    if (res->TestView(CTestResources::ETestViewContactsAndGroups).ContactViewPreferences() & EIgnoreUnSorted)

        {

        test(DoesNotContainsContactsL(res->TestView(CTestResources::ETestViewContactsAndGroups), *unsortedContacts));

        test(DoesNotContainsContactsL(res->TestView(CTestResources::ETestViewContactsAndGroups), *unsortedGroups));

        }

    else

        {

        test(ContainsAllContactsL(res->TestView(CTestResources::ETestViewContactsAndGroups), *unsortedContacts));

        test(ContainsAllContactsL(res->TestView(CTestResources::ETestViewContactsAndGroups), *unsortedGroups));

        }

    test.Next(_L("Check EContactsOnly view does not contain any groups"));

    test(DoesNotContainsContactsL(res->TestView(CTestResources::ETestViewContactsOnly), *groups));

    test(DoesNotContainsContactsL(res->TestView(CTestResources::ETestViewContactsOnly), *unsortedGroups));

    test.Next(_L("Check EGroupsOnly view does not contain any contacts"));

    test(DoesNotContainsContactsL(res->TestView(CTestResources::ETestViewGroupsOnly), *contacts));

    test(DoesNotContainsContactsL(res->TestView(CTestResources::ETestViewGroupsOnly), *unsortedContacts));

    test.Next(_L("Check EContactsOnly view count"));

    if (res->TestView(CTestResources::ETestViewContactsOnly).ContactViewPreferences() & EIgnoreUnSorted)

        {

        test(res->TestView(CTestResources::ETestViewContactsOnly).CountL() == contacts->Count());

        }

    else

        {

        test(res->TestView(CTestResources::ETestViewContactsOnly).CountL() == contacts->Count()+unsortedContacts->Count());

        }

    test.Next(_L("Check EGroupsOnly view count"));

    if (res->TestView(CTestResources::ETestViewGroupsOnly).ContactViewPreferences() & EIgnoreUnSorted)

        {

        test(res->TestView(CTestResources::ETestViewGroupsOnly).CountL() == groups->Count());

        }

    else

        {

        test(res->TestView(CTestResources::ETestViewGroupsOnly).CountL() == groups->Count()+unsortedGroups->Count());

        }

    test.Next(_L("Check EContactAndGroups view count"));

    if (res->TestView(CTestResources::ETestViewContactsAndGroups).ContactViewPreferences() & EIgnoreUnSorted)

        {

        const TInt count = contacts->Count()+groups->Count();

        test(res->TestView(CTestResources::ETestViewContactsAndGroups).CountL() == count);

        }

    else

        {

        const TInt count = contacts->Count()+unsortedContacts->Count()+groups->Count()+unsortedGroups->Count();

        test(res->TestView(CTestResources::ETestViewContactsAndGroups).CountL() == count);

        }

    CleanupStack::PopAndDestroy(5,res);

    }

LOCAL_C void TestOpenViewsWithExistingDataL()

    {

    test.Start(_L("Open views with exisiting data (no special preferences)"));

    TestOpenViewsWithExistingDataL(static_cast<TContactViewPreferences>(0));

    // Calypso Phonebook uses these view preferences

    test.Next(_L("Open views with exisiting data (EUnSortedAtEnd | ESingleWhiteSpaceIsEmptyField)"));

    TestOpenViewsWithExistingDataL

        (static_cast<TContactViewPreferences>(EUnSortedAtEnd|ESingleWhiteSpaceIsEmptyField));

    test.Next(_L("Open views with exisiting data (EIgnoreUnSorted)"));

    TestOpenViewsWithExistingDataL(EIgnoreUnSorted);

    test.Next(_L("Open views with exisiting data (EIgnoreUnSorted|ESingleWhiteSpaceIsEmptyField)"));

    TestOpenViewsWithExistingDataL

        (static_cast<TContactViewPreferences>(EIgnoreUnSorted|ESingleWhiteSpaceIsEmptyField));

    test.Next(_L("Open views with exisiting data (EUnSortedAtBeginning)"));

    TestOpenViewsWithExistingDataL(EUnSortedAtBeginning);

    test.Next(_L("Open views with exisiting data (EUnSortedAtBeginning|ESingleWhiteSpaceIsEmptyField)"));

    TestOpenViewsWithExistingDataL

        (static_cast<TContactViewPreferences>(EUnSortedAtBeginning|ESingleWhiteSpaceIsEmptyField));

    test.Next(_L("Open views with exisiting data (EUnSortedAtEnd)"));

    TestOpenViewsWithExistingDataL(EUnSortedAtEnd);

    test.Next(_L("Open views with exisiting data (EUnSortedAtEnd|ESingleWhiteSpaceIsEmptyField)"));

    TestOpenViewsWithExistingDataL

        (static_cast<TContactViewPreferences>(EUnSortedAtEnd|ESingleWhiteSpaceIsEmptyField));

    test.Next(_L("Open views with exisiting data (ESingleWhiteSpaceIsEmptyField)"));

    TestOpenViewsWithExistingDataL(ESingleWhiteSpaceIsEmptyField);

    test.End();

    }

LOCAL_C void TestModifyContactL(CTestResources& aRes, TContactItemId aContactId)

    {

    CContactItem* contact = aRes.Db().OpenContactLX(aContactId);

    CleanupStack::PushL(contact);

    const TInt fieldIndex = contact->CardFields().Find(KUidContactFieldFamilyName);

    contact->CardFields()[fieldIndex].TextStorage()->SetTextL(_L("Modified"));

    aRes.Db().CommitContactL(*contact);

    CleanupStack::PopAndDestroy(2);

    TContactDbObserverEvent dbEvent;

    test(aRes.DbEvents().ListenForEvent(KEventWaitTime,dbEvent));

    test(dbEvent.iType==EContactDbObserverEventContactChanged && dbEvent.iContactId==aContactId);

    TContactViewEvent event;

    test(aRes.TestViewEvents(CTestResources::ETestViewContactsOnly).ListenForEvent(KEventWaitTime,event));

    test(event.iEventType==TContactViewEvent::EItemRemoved && event.iContactId==aContactId);

    test(aRes.TestViewEvents(CTestResources::ETestViewContactsOnly).ListenForEvent(KEventWaitTime,event));

    test(event.iEventType==TContactViewEvent::EItemAdded && event.iContactId==aContactId);

    test(aRes.TestView(CTestResources::ETestViewContactsOnly).FindL(aContactId)!=KErrNotFound);

    test(!aRes.TestViewEvents(CTestResources::ETestViewContactsOnly).ListenForEvent(KEventWaitTime,event));

    test(!aRes.TestViewEvents(CTestResources::ETestViewGroupsOnly).ListenForEvent(KEventWaitTime,event));

    test(aRes.TestView(CTestResources::ETestViewGroupsOnly).FindL(aContactId)==KErrNotFound);

    test(aRes.TestViewEvents(CTestResources::ETestViewContactsAndGroups).ListenForEvent(KEventWaitTime,event));

    test(event.iEventType==TContactViewEvent::EItemRemoved && event.iContactId==aContactId);

    test(aRes.TestViewEvents(CTestResources::ETestViewContactsAndGroups).ListenForEvent(KEventWaitTime,event));

    test(event.iEventType==TContactViewEvent::EItemAdded && event.iContactId==aContactId);

    test(aRes.TestView(CTestResources::ETestViewContactsAndGroups).FindL(aContactId)!=KErrNotFound);

    test(!aRes.TestViewEvents(CTestResources::ETestViewContactsAndGroups).ListenForEvent(KEventWaitTime,event));

    }

LOCAL_C void TestModifyUnsortedContactL(CTestResources& aRes, TContactItemId aContactId)

    {

    CContactItem* contact = aRes.Db().OpenContactLX(aContactId);

    CleanupStack::PushL(contact);

    aRes.Db().CommitContactL(*contact);

    CleanupStack::PopAndDestroy(2);

    TContactDbObserverEvent dbEvent;

    test(aRes.DbEvents().ListenForEvent(KEventWaitTime,dbEvent));

    test(dbEvent.iType==EContactDbObserverEventContactChanged && dbEvent.iContactId==aContactId);

    TContactViewEvent event;

    if (aRes.TestView(CTestResources::ETestViewContactsOnly).ContactViewPreferences() & EIgnoreUnSorted)

        {

        test(!aRes.TestViewEvents(CTestResources::ETestViewContactsOnly).ListenForEvent(KEventWaitTime,event));

        }

    else

        {

        test(aRes.TestViewEvents(CTestResources::ETestViewContactsOnly).ListenForEvent(KEventWaitTime,event));

        test(event.iEventType==TContactViewEvent::EItemRemoved && event.iContactId==aContactId);

        test(aRes.TestViewEvents(CTestResources::ETestViewContactsOnly).ListenForEvent(KEventWaitTime,event));

        test(event.iEventType==TContactViewEvent::EItemAdded && event.iContactId==aContactId);

        test(aRes.TestView(CTestResources::ETestViewContactsOnly).FindL(aContactId)!=KErrNotFound);

        test(!aRes.TestViewEvents(CTestResources::ETestViewContactsOnly).ListenForEvent(KEventWaitTime,event));

        }

    test(!aRes.TestViewEvents(CTestResources::ETestViewGroupsOnly).ListenForEvent(KEventWaitTime,event));

    test(aRes.TestView(CTestResources::ETestViewGroupsOnly).FindL(aContactId)==KErrNotFound);

    if (aRes.TestView(CTestResources::ETestViewContactsAndGroups).ContactViewPreferences() & EIgnoreUnSorted)

        {

        test(!aRes.TestViewEvents(CTestResources::ETestViewContactsAndGroups).ListenForEvent(KEventWaitTime,event));

        }

    else

        {

        test(aRes.TestViewEvents(CTestResources::ETestViewContactsAndGroups).ListenForEvent(KEventWaitTime,event));

        test(event.iEventType==TContactViewEvent::EItemRemoved && event.iContactId==aContactId);

        test(aRes.TestViewEvents(CTestResources::ETestViewContactsAndGroups).ListenForEvent(KEventWaitTime,event));

        test(event.iEventType==TContactViewEvent::EItemAdded && event.iContactId==aContactId);

        test(aRes.TestView(CTestResources::ETestViewContactsAndGroups).FindL(aContactId)!=KErrNotFound);

        test(!aRes.TestViewEvents(CTestResources::ETestViewContactsAndGroups).ListenForEvent(KEventWaitTime,event));

        }

    }

LOCAL_C void TestDeleteGroupL(CTestResources& aRes, TContactItemId aGroupId)

    {

    aRes.Db().DeleteContactL(aGroupId);

    TContactDbObserverEvent dbEvent;

    test(aRes.DbEvents().ListenForEvent(KEventWaitTime,dbEvent));

    test(dbEvent.iType==EContactDbObserverEventGroupDeleted && dbEvent.iContactId==aGroupId);

    TContactViewEvent event;

    test(!aRes.TestViewEvents(CTestResources::ETestViewContactsOnly).ListenForEvent(KEventWaitTime,event));