// Copyright (c) 2000-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 <e32test.h>
#include <msvapi.h>
#include <msvids.h>
#include "msvtestutils.h"
#include "msvtestconfig.h"
#include "msgservertestutils.h"
#include <miutset.h>

_LIT(KTestName,"Message Server Smoke test");
RTest tests(KTestName);
CMsgServerTestUtils* theUtils = NULL;




class TTestSessionObserver: public MMsvSessionObserver
	{
public:
	TTestSessionObserver() : iNumberOfEvents(0) {};
	virtual void HandleSessionEventL(TMsvSessionEvent aEvent, TAny*, TAny*, TAny*)
		{
		iLastEvent=aEvent;
		iNumberOfEvents++;
		};

		TInt CheckEvents(TInt aNumber)
		{
		_LIT(KNote3,"Checking session observer got the correct number of events\n");
		theUtils->Printf(KNote3);
		TInt err=KErrNone;
		if(iNumberOfEvents!=aNumber)
			{
			_LIT(KErrMsg,"Wrong Number of Events, Wanted %d Got %d, last event %d\n");
			theUtils->Printf(KErrMsg,aNumber,iNumberOfEvents,iLastEvent);
			err=KErrUnknown;
			}
		iNumberOfEvents=0;
		return err;
		};

	TInt CheckEvents(TInt aNumber, TMsvSessionEvent aLastEvent)
		{
		_LIT(KNote3,"Checking session observer got the correct event\n");
		theUtils->Printf(KNote3);

		TInt err=KErrNone;
		if(aNumber !=0 && iLastEvent!=aLastEvent)
			{
			_LIT(KErrMsg,"Wrong Event Wanted %d Got %d\n");		
			theUtils->Printf(KErrMsg,aLastEvent,iLastEvent);
			err=KErrUnknown;
			}
		if(iNumberOfEvents!=aNumber)
			{
			_LIT(KErrMsg,"Wrong Number of Events Wanted %d Got %d\n");		
			theUtils->Printf(KErrMsg,aNumber,iNumberOfEvents);
			err=KErrUnknown;
			}
		iNumberOfEvents=0;
		return err;
		};
	
private:

	TMsvSessionEvent iLastEvent;
	TInt iNumberOfEvents;
	};	


class TTestEntryObserver: public MMsvEntryObserver
	{
public:
	TTestEntryObserver() : iNumberOfEvents(0) {};
	virtual void HandleEntryEventL(TMsvEntryEvent aEvent, TAny*, TAny*, TAny*)
		{
		iLastEvent=aEvent;
		iNumberOfEvents++;
		}


	TInt CheckEvents(TInt aNumber)
		{
		_LIT(KNote3,"Checking entry observer got the correct number of events\n");
		theUtils->Printf(KNote3);
		TInt err=KErrNone;
		if(iNumberOfEvents!=aNumber)
			{
			_LIT(KErrMsg,"Wrong Number of Events, Wanted %d Got %d, last event %d\n");
			theUtils->Printf(KErrMsg,aNumber,iNumberOfEvents,iLastEvent);
			err=KErrUnknown;
			}
		iNumberOfEvents=0;
		return err;
		};

	TInt CheckEvents(TInt aNumber, TMsvEntryEvent aLastEvent)
		{
		_LIT(KNote3,"Checking entry observer got the correct event\n");
		theUtils->Printf(KNote3);

		TInt err=KErrNone;
		if(iNumberOfEvents!=aNumber)
			{
			_LIT(KErrMsg,"Wrong Number of Events, Wanted %d Got %d\n");
			theUtils->Printf(KErrMsg,aNumber,iNumberOfEvents);
			err=KErrUnknown;
			}
		if(iLastEvent!=aLastEvent)
			{
			_LIT(KErrMsg,"Wrong Entry Event, Wanted %d Got %d\n");		
			theUtils->Printf(KErrMsg,aLastEvent,iLastEvent);
			err=KErrUnknown;
			}
		iNumberOfEvents=0;
		return err;
		};


private:
	TMsvEntryEvent iLastEvent;
	TInt iNumberOfEvents;
	};



class TEntryObserverCleanup
	{
	public:
		TEntryObserverCleanup(CMsvEntry &aEntry,TTestEntryObserver &aObserver)
			: iEntry(aEntry), iObserver(aObserver) {};
	static void CleanupEntryObserver(TAny* aPtr)
		{
		TEntryObserverCleanup* me = STATIC_CAST(TEntryObserverCleanup*, aPtr);
		me->Cleanup();
		};
	private:
		void Cleanup()
		{
		iEntry.RemoveObserver(iObserver);
		};

	private:
		CMsvEntry &iEntry;
		TTestEntryObserver &iObserver;
	};


TInt RunWhilePending(const TRequestStatus &aStatus)
	{
	_LIT(KNote2,"Running scheduler till we complete\n");
	theUtils->Printf(KNote2);

	TInt err=KErrNone;
	while(aStatus==KRequestPending)
		{
		CActiveScheduler::Current()->RunIfReady(err,0);
		CActiveScheduler::Current()->WaitForAnyRequest();
		}

	_LIT(KNote3,"Completed\n");
	theUtils->Printf(KNote3);
	return err;
	}


// create a service
TInt CreateServiceTest(TTestSessionObserver &aObserver, CMsvEntry &aEntry, TMsvId &aServiceId)
	{

	TMsvEntry tEntry;

	tEntry.iMtm = KUidMsgTypePOP3;
	tEntry.iType = KUidMsvServiceEntry;
	tEntry.SetReadOnly(EFalse);
	tEntry.SetVisible(ETrue);
	_LIT(KADescription,"A Fake Service");
	tEntry.iDescription.Set(KADescription);

	_LIT(KNote0,"Setting entry to root\n");
	theUtils->Printf(KNote0);
	aEntry.SetEntryL(KMsvRootIndexEntryIdValue);

	_LIT(KNote1,"Starting async create service\n");
	theUtils->Printf(KNote1);
	TRequestStatus status;
	CMsvOperation *anop=aEntry.CreateL(tEntry,status);
	CleanupStack::PushL(anop);

	TInt err=RunWhilePending(status);
	if(err==KErrNone)
		{
		err=aObserver.CheckEvents(1,MMsvSessionObserver::EMsvEntriesCreated);
		aServiceId = McliUtils::GetLocalProgressL(*anop).iId;
		}

	CleanupStack::PopAndDestroy(anop);
	return err ;
	}


// create a service
TInt CreateMessageTest(TTestSessionObserver &aObserver, CMsvEntry &aEntry, TMsvId aServiceId, TMsvId& aMessageId)
	{
	_LIT(KNote0,"Setting entry to drafts entry\n");
	theUtils->Printf(KNote0);
	aEntry.SetEntryL(KMsvDraftEntryIdValue);
	_LIT(KNote1,"Observing draft entry\n");
	theUtils->Printf(KNote1);
	TTestEntryObserver eObs;
	aEntry.AddObserverL(eObs);
	TEntryObserverCleanup clean(aEntry,eObs);
	CleanupStack::PushL(TCleanupItem(TEntryObserverCleanup::CleanupEntryObserver, &clean));


	_LIT(KAnAddress,"Test@psion7.demon.co.uk");
	_LIT(KADescription,"A Message");

	TMsvEntry message;
	message.iDetails.Set(KAnAddress);
	message.iDescription.Set(KADescription);
	message.iMtm=KUidMsgTypePOP3;
	
	message.iServiceId=aServiceId;
	message.iType=KUidMsvMessageEntry;

	_LIT(KNote2,"Starting async create message\n");
	theUtils->Printf(KNote2);

	TRequestStatus status;
	CMsvOperation *anop=aEntry.CreateL(message,status);
	CleanupStack::PushL(anop);

	TInt err=RunWhilePending(status);

	if(err==KErrNone)
		{
		aMessageId = McliUtils::GetLocalProgressL(*anop).iId;
		err=aObserver.CheckEvents(1,MMsvSessionObserver::EMsvEntriesCreated);
		}
	if(err==KErrNone)
		err=eObs.CheckEvents(1,MMsvEntryObserver::EMsvNewChildren);

	CleanupStack::PopAndDestroy(anop);
	CleanupStack::PopAndDestroy(&clean);
	return(err);
	}


TInt CopyMessageTest(TTestSessionObserver &aObserver, CMsvEntry &aEntry, TMsvId aMessageId)
	{
	_LIT(KNote0,"Setting entry to drafts\n");
	theUtils->Printf(KNote0);
	aEntry.SetEntryL(KMsvDraftEntryId);
	_LIT(KNote1,"Observing drafts entry\n");
	theUtils->Printf(KNote1);
	TTestEntryObserver eObs;
	aEntry.AddObserverL(eObs);
	TEntryObserverCleanup clean(aEntry,eObs);
	CleanupStack::PushL(TCleanupItem(TEntryObserverCleanup::CleanupEntryObserver, &clean));


	_LIT(KNote3,"Starting async copy message on draft entry/aMessageId to Outbox\n");
	theUtils->Printf(KNote3);

	TRequestStatus status;
	CMsvOperation *anop=aEntry.CopyL(aMessageId,KMsvGlobalOutBoxIndexEntryId,status);
	CleanupStack::PushL(anop);

	TInt err=RunWhilePending(status);

	if(err==KErrNone)
		err=aObserver.CheckEvents(1,MMsvSessionObserver::EMsvEntriesCreated);
	if(err==KErrNone)
		err=eObs.CheckEvents(0);

	CleanupStack::PopAndDestroy(anop);
	CleanupStack::PopAndDestroy(&clean);
	return err ;
	}

TInt MoveMessageTest(TTestSessionObserver &aObserver, CMsvEntry &aEntry, TMsvId aMessageId)
	{
	_LIT(KNote0,"Setting entry to drafts\n");
	theUtils->Printf(KNote0);
	aEntry.SetEntryL(KMsvDraftEntryId);
	_LIT(KNote1,"Observing drafts entry\n");
	theUtils->Printf(KNote1);
	TTestEntryObserver eObs;
	aEntry.AddObserverL(eObs);
	TEntryObserverCleanup clean(aEntry,eObs);
	CleanupStack::PushL(TCleanupItem(TEntryObserverCleanup::CleanupEntryObserver, &clean));


	_LIT(KNote2,"Getting outbox entry\n");
	theUtils->Printf(KNote2);
	CMsvEntry* outboxEntry=aEntry.Session().GetEntryL(KMsvGlobalOutBoxIndexEntryId);
	CleanupStack::PushL(outboxEntry);
	_LIT(KNote3,"Observing outbox entry\n");
	theUtils->Printf(KNote3);
	TTestEntryObserver outboxObs;
	outboxEntry->AddObserverL(outboxObs);
	TEntryObserverCleanup clean2(*outboxEntry,outboxObs);
	CleanupStack::PushL(TCleanupItem(TEntryObserverCleanup::CleanupEntryObserver, &clean2));

	_LIT(KNote5,"Starting async move message on draft entry/aMessageId to Outbox\n");
	theUtils->Printf(KNote5);

	TRequestStatus status;
	CMsvOperation *anOp=aEntry.MoveL(aMessageId,KMsvGlobalOutBoxIndexEntryId,status);
	CleanupStack::PushL(anOp);

	TInt err=RunWhilePending(status);

	if(err==KErrNone)
		err=aObserver.CheckEvents(1,MMsvSessionObserver::EMsvEntriesMoved);

	_LIT(KNote6,"Checking drafts entry events\n");
	theUtils->Printf(KNote6);
	if(err==KErrNone)
		err=eObs.CheckEvents(1,MMsvEntryObserver::EMsvDeletedChildren);

	_LIT(KNote7,"Checking outbox entry events\n");
	theUtils->Printf(KNote7);
	if(err==KErrNone)
		err=outboxObs.CheckEvents(1,MMsvEntryObserver::EMsvNewChildren);

	CleanupStack::PopAndDestroy(anOp);
	CleanupStack::PopAndDestroy(&clean2);
	CleanupStack::PopAndDestroy(outboxEntry);
	CleanupStack::PopAndDestroy(&clean);
	return err ;
	}



TInt DoTestsL(TTestSessionObserver &aSessionObs, CMsvEntry &aEntry)
	{
	TInt testno=1;
	TInt err=KErrNone;

	TMsvId serviceId; 

	theUtils->TestStart(testno,_L("Creating a Service"));
	err=CreateServiceTest(aSessionObs,aEntry,serviceId);
	theUtils->TestFinish(testno++,err);
	if(err!=KErrNone) return(err);

	TMsvId messageId;
	theUtils->TestStart(testno,_L("Creating a Message"));
	err=CreateMessageTest(aSessionObs,aEntry,serviceId,messageId);
	theUtils->TestFinish(testno++,err);
	if(err!=KErrNone) return(err);

	theUtils->TestStart(testno,_L("Copying message to Outbox"));
	err=CopyMessageTest(aSessionObs,aEntry,messageId);
	theUtils->TestFinish(testno++,err);
	if(err!=KErrNone) return(err);

	theUtils->TestStart(testno,_L("Creating another Message"));
	err=CreateMessageTest(aSessionObs,aEntry,serviceId,messageId);
	theUtils->TestFinish(testno++,err);
	if(err!=KErrNone) return(err);

	theUtils->TestStart(testno,_L("Moving message to Outbox"));
	err=MoveMessageTest(aSessionObs,aEntry,messageId);
	theUtils->TestFinish(testno++,err);
	if(err!=KErrNone) return(err);


	return KErrNone;
	}




void DoMainL()
	{
	theUtils=CMsgServerTestUtils::NewL(tests);
	theUtils->SetupL();
	TTestSessionObserver sObs;
	CMsvSession *session=CMsvSession::OpenSyncL(sObs);
	CleanupStack::PushL(session);
	CMsvEntry *cEntry=session->GetEntryL(KMsvRootIndexEntryId);
	CleanupStack::PushL(cEntry);

	TInt err=DoTestsL(sObs,*cEntry);
	CleanupStack::PopAndDestroy(cEntry);
	CleanupStack::PopAndDestroy(session);
	theUtils->Close(err);
	delete theUtils;
	}

GLDEF_C TInt E32Main()
	{       
	__UHEAP_MARK;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	TRAPD(ret, DoMainL());
	tests(ret==KErrNone);
    tests.Getch();
	tests.Close();
	delete cleanup;      
	__UHEAP_MARKEND;
	return(KErrNone);
	}

EXPORT_C TInt WinsMain()
	{
#if defined(__WINS__)
	E32Main();
#endif
	return KErrNone;
	}