// Copyright (c) 2008-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:
//

#include "caltestlib.h"
#include <calentry.h>
#include <calsession.h>
#include <calentryview.h>
#include <e32test.h>
#include <calchangecallback.h>
#include <calfilechangenotification.h>
#include <calrrule.h>
#include <calcalendarinfo.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <tzusernames.h>
#include <tzuserdefineddata.h>
#endif

_LIT(KTestName,"tcal_filechangenotification");
RTest test(KTestName);
_LIT(KTestFileName,"c:tcal_filechangenotification");


class CCalFileChangeNotificationTest : public CBase, MCalChangeCallBack2, MCalFileChangeObserver
    {
public:
    static CCalFileChangeNotificationTest* NewLC();
    ~CCalFileChangeNotificationTest();
    
    // from MCalChangeCallBack2
    void CalendarInfoChangeNotificationL(RPointerArray<CCalFileChangeInfo>& aCalendarInfoChangeEntries);

    // from MCalChangeCallBack2
    void CalChangeNotification(RArray<TCalChangeEntry>& aChangeItems);
    //Test tasks
    void TestFileCreatedL();
    void TestFileDeletedL();
    void TestFileChangeWithCalendarInfoL();
    void TestUpdateCalendarInfoL();
    void TestMixedNotificationL();
 
private: 
    CCalFileChangeNotificationTest();
    void ConstructL();
    
    TCalLocalUid StoreEntryL();
    void RegisterEntryNotificationL();
    TBool CompareFileNotification(RPointerArray<CCalFileChangeInfo>& aCalendarInfoChangeEntries);
    TBool CompareEntryNotification(RArray<TCalChangeEntry>& aChangeItems);
  
private:
    TBool               iNotificationCallBackOccurred;
    TBool               iFileNotificationCallBackOccurred;
    CCalTestLibrary*    iTestLib;
    CCalSession*        iOtherSession;//It does the change such as create file, add calendar info...
    RArray<MCalFileChangeObserver::TChangeType> iExpectedCalendarInfoTypes;
    RArray<TCalChangeEntry> iExpectedEntryChange;
    };

CCalFileChangeNotificationTest::CCalFileChangeNotificationTest()
    :iNotificationCallBackOccurred(EFalse), iFileNotificationCallBackOccurred(EFalse)
    {
    }

void CCalFileChangeNotificationTest::CalendarInfoChangeNotificationL(RPointerArray<CCalFileChangeInfo>& aCalendarInfoChangeEntries)
    {
    test.Printf(_L("MCalFileChangeObserver notification happened\n") );
    iFileNotificationCallBackOccurred = ETrue;
    
    test(CompareFileNotification(aCalendarInfoChangeEntries));
    if(iExpectedCalendarInfoTypes.Count() == 0 && iExpectedEntryChange.Count() == 0)
        {
        CActiveScheduler::Stop();
        }
    }

TBool CCalFileChangeNotificationTest::CompareFileNotification(RPointerArray<CCalFileChangeInfo>& aCalendarInfoChangeEntries)
    {//return ETrue if all elements in aCalendarInfoChangeEntries are found in the iExpectedCalendarInfoTypes otherwise EFalse.
    TBool ret = EFalse;
    const TInt count = aCalendarInfoChangeEntries.Count();
    TInt jj = 0;
    do
        {
        CCalFileChangeInfo* calFileChangeInfo = aCalendarInfoChangeEntries[jj];
        ret = EFalse;
        TInt countExpected = iExpectedCalendarInfoTypes.Count();
        for(TInt ii = countExpected-1; ii >= 0; --ii)
            {
            if(calFileChangeInfo->FileNameL() == KTestFileName() && calFileChangeInfo->ChangeType() == iExpectedCalendarInfoTypes[ii])
                 {
                 iExpectedCalendarInfoTypes.Remove(ii);
                 ret = ETrue;
                 countExpected = iExpectedCalendarInfoTypes.Count();
                 break;
                 }
            }
        
        ++ jj;
        }while (ret && jj < count);
            
    return ret;
    }

TBool CCalFileChangeNotificationTest::CompareEntryNotification(RArray<TCalChangeEntry>& aChangeItems)
    {//return ETrue if all elements in aChangeItems are found in the iExpectedEntryChange otherwise EFalse.
    TBool ret = EFalse;
    const TInt count = aChangeItems.Count();
    TInt jj = 0;
    do
        {
        TCalChangeEntry entryChange = aChangeItems[jj];
        TBool found = EFalse;
         TInt countExpected = iExpectedEntryChange.Count();
        for(TInt ii = countExpected-1; ii >= 0; --ii)
            {
            if(entryChange.iEntryId == iExpectedEntryChange[ii].iEntryId &&
               entryChange.iChangeType == iExpectedEntryChange[ii].iChangeType &&
               entryChange.iEntryType == iExpectedEntryChange[ii].iEntryType)
                 {
                 iExpectedEntryChange.Remove(ii);
                 ret = ETrue;
                 countExpected = iExpectedEntryChange.Count();
                 break;
                 }
            }
        
        ++ jj;
        }while (ret && jj < count);
            
    return ret;
    }

void CCalFileChangeNotificationTest::CalChangeNotification(RArray<TCalChangeEntry>& aChangeItems)
    {
    test.Printf(_L("MCalChangeCallBack2 notification happened\n") );
    iNotificationCallBackOccurred = ETrue;
    test(CompareEntryNotification(aChangeItems));
    if(iExpectedCalendarInfoTypes.Count() == 0 && iExpectedEntryChange.Count() == 0)
        {
        CActiveScheduler::Stop();
        }
    }

CCalFileChangeNotificationTest* CCalFileChangeNotificationTest::NewLC()
    {
    CCalFileChangeNotificationTest* self = new (ELeave) CCalFileChangeNotificationTest();
    CleanupStack::PushL(self);
    self->ConstructL();
    return (self);
    }
    
CCalFileChangeNotificationTest::~CCalFileChangeNotificationTest()
    {
    delete iOtherSession;
    TRAP_IGNORE(iTestLib->DeleteFileL(KTestFileName));
    delete iTestLib;
    iExpectedCalendarInfoTypes.Close();
    iExpectedEntryChange.Close();
    }

void CCalFileChangeNotificationTest::ConstructL()
    {
    iTestLib = CCalTestLibrary::NewL();
    TRAP_IGNORE(iTestLib->DeleteFileL(KTestFileName));
    iOtherSession = CCalSession::NewL();
    }

TCalLocalUid CCalFileChangeNotificationTest::StoreEntryL()
    {
    test.Printf(_L("Add entry\n" ));
    RPointerArray<CCalEntry> entries;
    CleanupResetAndDestroyPushL(entries);
    _LIT8(KUid, "UID_TzDb");
    HBufC8* guid = KUid().AllocLC();
    CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);
    CleanupStack::Pop(guid);
    CleanupStack::PushL(entry);
    entries.AppendL(entry);
    CleanupStack::Pop(entry);
    
    //Set entry start and end time
    TTime startTime (TDateTime(2005, EJanuary, 7, 10, 0, 0, 0)); 
    TCalTime calStartTime;
    calStartTime.SetTimeLocalL(startTime);
    TTime endTime (TDateTime(2005, EJanuary, 7, 11, 0, 0, 0)); 
    TCalTime calEndTime;
    calEndTime.SetTimeLocalL(endTime);
    entry->SetStartAndEndTimeL(calStartTime, calEndTime);
    
    //Set repeating 
    TCalRRule repeat(TCalRRule::EDaily);
    repeat.SetDtStart(calStartTime);
    repeat.SetCount(3);
    entry->SetRRuleL(repeat);

    //Store the Entry
    TInt numStoredEntries;
    iOtherSession->OpenL(KTestFileName());
    CCalEntryView* otherView =CCalEntryView::NewL(*iOtherSession);
    CleanupStack::PushL(otherView);
    otherView->StoreL(entries, numStoredEntries);
    CleanupStack::PopAndDestroy(otherView);
    test (numStoredEntries == entries.Count());
    TCalLocalUid entryId = entries[0]->LocalUidL();

    CleanupStack::PopAndDestroy(&entries);
    return entryId; 
    }

/** Test the file change notification is send and received when the other client has created a file.
*/
void CCalFileChangeNotificationTest::TestFileCreatedL()
    {//maybe combine with delete
    //Register for Calendar entry change notification.
    test.Next(_L("Test notification when file is created"));
    iTestLib->GetSession().StartFileChangeNotificationL(*this);
    iOtherSession->CreateCalFileL(KTestFileName());
    iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarFileCreated);
    
    CActiveScheduler::Start();
    //CActiveScheduler is stopped in Callback
        
    test(iFileNotificationCallBackOccurred);
    test(iExpectedCalendarInfoTypes.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.
 
    iFileNotificationCallBackOccurred = EFalse;
    iTestLib->GetSession().StopFileChangeNotification();
    }

/** Test the file change notifications are send and received when the other client has created a file with a metadata.
*/  
void CCalFileChangeNotificationTest::TestFileChangeWithCalendarInfoL()
    {
    //Register for Calendar entry change notification.
    test.Next(_L("Test notification when file is created"));
    iTestLib->GetSession().StartFileChangeNotificationL(*this);
    CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
    CleanupStack::PushL(calendarInfo);  
    iOtherSession->CreateCalFileL(KTestFileName(), *calendarInfo);
    CleanupStack::PopAndDestroy(calendarInfo);
    iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarFileCreated);
    iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarInfoCreated);
    CActiveScheduler::Start();
    //CActiveScheduler is stopped in Callback       
    test(iFileNotificationCallBackOccurred);
    test(iExpectedCalendarInfoTypes.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.
    iFileNotificationCallBackOccurred = EFalse;
    
    iOtherSession->DeleteCalFileL(KTestFileName());
    iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarFileDeleted);
    iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarInfoDeleted);
    
    CActiveScheduler::Start();
    //CActiveScheduler is stopped in Callback       
    test(iFileNotificationCallBackOccurred);
    iFileNotificationCallBackOccurred = EFalse;
    test(iExpectedCalendarInfoTypes.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.
 
    iTestLib->GetSession().StopFileChangeNotification();
    }

/** Test the file change notifications are send and received when the other client has updated the metadata.
*/
void CCalFileChangeNotificationTest::TestUpdateCalendarInfoL()
    {
    test.Next(_L("Test notification when calendar info is updated"));
    CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
    CleanupStack::PushL(calendarInfo);  
    iOtherSession->CreateCalFileL(KTestFileName(), *calendarInfo);
    CleanupStack::PopAndDestroy(calendarInfo);
    iOtherSession->OpenL(KTestFileName);

    iTestLib->GetSession().StartFileChangeNotificationL(*this);
    
    const TInt numUpdates = 10;
    for(TInt ii= 0; ii < numUpdates; ++ii)
        {
        calendarInfo = CCalCalendarInfo::NewL();
        CleanupStack::PushL(calendarInfo);  
        iOtherSession->SetCalendarInfoL(*calendarInfo);
        CleanupStack::PopAndDestroy(calendarInfo);
        iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarInfoUpdated);
        }
    CActiveScheduler::Start();
    //CActiveScheduler is stopped in Callback       
    test(iFileNotificationCallBackOccurred);
    test(iExpectedCalendarInfoTypes.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.
    iFileNotificationCallBackOccurred = EFalse;

    iTestLib->GetSession().StopFileChangeNotification();
    iOtherSession->DeleteCalFileL(KTestFileName());
    }

/** Test the file change notification is send and received when the other client has deleted a file.
*/
void CCalFileChangeNotificationTest::TestFileDeletedL()
    {
    test.Next(_L("TestFileDeletedL"));

    //Register for Calendar entry change notification.
    test.Next(_L("Test notification when file is deleted"));
    iTestLib->GetSession().StartFileChangeNotificationL(*this);
    iOtherSession->DeleteCalFileL(KTestFileName());
    iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarFileDeleted);
     
    CActiveScheduler::Start();
    //CActiveScheduler is stopped in Callback
         
    test(iFileNotificationCallBackOccurred);
    test(iExpectedCalendarInfoTypes.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.
    iFileNotificationCallBackOccurred = EFalse;
     
    iTestLib->GetSession().StopFileChangeNotification();
    }

void CCalFileChangeNotificationTest::RegisterEntryNotificationL()
    {//requeste for the change notification
    RDebug::Print(_L("Register Notication" ));
    iTestLib->ReplaceFileL(KTestFileName);
    iTestLib->GetSession().OpenL(KTestFileName);

    TCalTime minTime;
    minTime.SetTimeUtcL(TCalTime::MinTime());
    TCalTime maxTime;
    maxTime.SetTimeUtcL(TCalTime::MaxTime());
    CalCommon::TCalTimeRange timeRange(minTime, maxTime);
    CCalChangeNotificationFilter* filter = CCalChangeNotificationFilter::NewL(MCalChangeCallBack2::EChangeEntryAll, ETrue, timeRange);
    iTestLib->GetSession().StartChangeNotification(*this, *filter);
    delete filter;
    }

/** Test the file change notifications and entry change notification are received when the other client change the file and\or calendar entries.
*/
void CCalFileChangeNotificationTest::TestMixedNotificationL()
    {
// (1) Session 1 request both file and entry notification
    //Session 1 Register for Calendar entry change notification.
    test.Next(_L("Test entry and file notification are mixed"));
    //Session 1 Register for Calendar file change notification.
    iTestLib->GetSession().StartFileChangeNotificationL(*this);
    RegisterEntryNotificationL();
   
    //Session 2 set and store the calendar info
    iOtherSession->OpenL(KTestFileName());
    CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
    CleanupStack::PushL(calendarInfo);  
    iOtherSession->SetCalendarInfoL(*calendarInfo);
    CleanupStack::PopAndDestroy(calendarInfo);

    //one file change notification is expected
    iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarInfoCreated);
    //Session 2 also add an entry
    TCalLocalUid entryId = StoreEntryL();//Add an entry by iOtherSession
    TCalChangeEntry change;
    change.iEntryId = entryId;
    change.iChangeType = MCalChangeCallBack2::EChangeAdd;
    change.iEntryType = MCalChangeCallBack2::EChangeEntryEvent;
    //one entry change notification is expected
    iExpectedEntryChange.AppendL(change);

    CActiveScheduler::Start();
    //CActiveScheduler is stopped in Callback       
    test(iFileNotificationCallBackOccurred);
    test(iExpectedCalendarInfoTypes.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.
    test(iNotificationCallBackOccurred);
    test(iExpectedEntryChange.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.

    iFileNotificationCallBackOccurred = EFalse;
    iNotificationCallBackOccurred = EFalse;

// (2) Session 1 stoped file change notification only request for entry notification
    iTestLib->GetSession().StopFileChangeNotification();   
    calendarInfo = CCalCalendarInfo::NewL();
    CleanupStack::PushL(calendarInfo);  
    iOtherSession->SetCalendarInfoL(*calendarInfo);
    CleanupStack::PopAndDestroy(calendarInfo);
    StoreEntryL();
    change.iChangeType = MCalChangeCallBack2::EChangeModify;    
    iExpectedEntryChange.AppendL(change);
    CActiveScheduler::Start();
    test(!iFileNotificationCallBackOccurred);
    test(iNotificationCallBackOccurred);
    test(iExpectedEntryChange.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.
    iNotificationCallBackOccurred = EFalse;
    
// (3) Session 1 start the entry change notification and stoped file change notification
    iTestLib->GetSession().StartFileChangeNotificationL(*this);
    iTestLib->GetSession().StopChangeNotification();
    StoreEntryL();
    calendarInfo = CCalCalendarInfo::NewL();
    CleanupStack::PushL(calendarInfo);  
    iOtherSession->SetCalendarInfoL(*calendarInfo);
    CleanupStack::PopAndDestroy(calendarInfo);
    iExpectedCalendarInfoTypes.AppendL(MCalFileChangeObserver::ECalendarInfoUpdated);
    CActiveScheduler::Start();
    test(iFileNotificationCallBackOccurred);
    test(!iNotificationCallBackOccurred);
    test(iExpectedCalendarInfoTypes.Count() == 0);//In callback function elements in iExpectedCalendarInfoTypes has been remove when it callback item is equel to the expoected.

    iTestLib->GetSession().StopFileChangeNotification(); 
    delete iOtherSession;
    iTestLib->DeleteFileL(KTestFileName());
    iOtherSession = CCalSession::NewL();
    }
  
/**
*/
void DoTestsL()
    {
    test.Title();
    test.Start(_L("@SYMTESTCaseID:PIM-TCAL-TZDBCHANGE-0001 Calendar TZ Rules Data Change Awareness Test Suite"));
    CCalFileChangeNotificationTest* testManager = CCalFileChangeNotificationTest::NewLC();
    
    // Run the test suite
    testManager->TestFileCreatedL();
    testManager->TestFileDeletedL();
    testManager->TestFileChangeWithCalendarInfoL();
    testManager->TestUpdateCalendarInfoL();
    testManager->TestMixedNotificationL();
    
    CleanupStack::PopAndDestroy(testManager);
    test.End();
    }

TInt E32Main()
    {
    __UHEAP_MARK;

    CTrapCleanup* trapCleanup = CTrapCleanup::New();
    if(!trapCleanup)
        {
        return KErrNoMemory;
        }

    CActiveScheduler* scheduler = new CActiveScheduler;
    if(!scheduler)
        {
        return KErrNoMemory;
        }
    CActiveScheduler::Install(scheduler);   
    
    TRAPD(ret, DoTestsL());
    test.Printf(_L("Trapped return value from DoTestsL(): %d\n"), ret);
    test(ret == KErrNone);

    test.Close();   

    delete scheduler;
    delete trapCleanup; 

    __UHEAP_MARKEND;

    return (KErrNone);
    }