// Copyright (c) 1998-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 <logcli.h>

#include <logview.h>

#include "EmailTestUtils.h"

#include <commdb.h>

#include <bacline.h>

#include <cemailaccounts.h>

#include "t_log.h"

// For loading the serial comms device drivers 

#if defined (__WINS__)

	#define PDD_NAME		_L("ECDRV")

	#define LDD_NAME		_L("ECOMM")

#else

	#define PDD_NAME		_L("EUART1")

	#define LDD_NAME		_L("ECOMM")

#endif

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

//#define _DEBUG_MTMCOMMAND_

// Static variables

LOCAL_D RTest test(_L("IMPS.dll Testrig"));

LOCAL_D RFs theFs;

// LOCAL_C CMsvServer* theServer;

_LIT(KFolderNameToEncode, "αινσϊ");

_LIT(KMessageNameTest, "Test: 12");

_LIT(KMessageNameAttachment, "Test: 9");

_LIT(KMessageNamePriority,"Test: 23");

_LIT(KMessageNameXPriority,"Test: 15");

_LIT(KMessageNamePrecedence,"Test: 24");

_LIT(KMessageNameImportance,"Test: 14");

_LIT(KMessageNameMimeHTML, "Test: 2");

LOCAL_D const TUid KUidImQueuedOperationList = {0x10001794};	// 2648441492 dec.

_LIT(KTestParams,"-testparams");

enum TCmdLineArgs

	{

	EArgProgramName,

	EArgTestParams,

	EArgRemoveMsgStore,

	EArgMainMenu

	};

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

class TestScheduler : public CActiveScheduler

	{

public:

	void Error (TInt aError) const;

	};

void TestScheduler::Error(TInt anError) const

	{

	test.Printf(_L("Scheduler Error %d"), anError );

	CActiveScheduler::Stop();

	}

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

class TestUiTimer : public CTimer

	{

public:

	static TestUiTimer* NewL( CConsoleBase*, CBaseServerMtm* &aImppServerMtm );

	~TestUiTimer();

	void RunL();

	void DoCancel();

	void ConstructL();

	void IssueRequest();

	void Dump();

	TPtrC StateName(TImap4GenericProgress::TImap4GenericProgressState aState);

	TPtrC OpName(TImap4GenericProgress::TImap4GenericProgressOp aOp);

	TPtrC SyncStateName(TImap4SyncProgress::TImap4SyncProgressState aState);

	CConsoleBase*				iConsole;

	CBaseServerMtm*				&iImppServerMtm;

	TTimeIntervalMicroSeconds32 period;

protected:

	TestUiTimer( CConsoleBase* , CBaseServerMtm* &aImppServerMtm );

	TInt iCount;

	TBool iClosing;

	TBool iDoneConnecting;

	};

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

enum TImap4OpType

	{

	EImap4OpCopyToLocal,

	EImap4OpMoveToLocal,

	EImap4OpCopyFromLocal,

	EImap4OpMoveFromLocal,

	EImap4OpCopyWithinService,

	EImap4OpMoveWithinService,

	EImap4OpMoveWithinServiceToInbox,

	EImap4OpPopulate,

	EImap4OpDelete,

	EImap4OpUndelete,

	EImap4OpCopyWithinFolder,

	EImap4OpCopyToLocalAndDelete,

	EImap4OpMoveToLocalAndDelete,

	EImap4OpCopyFromLocalAndDelete,

	EImap4OpMoveFromLocalAndDelete,

	EImap4OpCopyWithinServiceAndDelete,

	EImap4OpMoveWithinServiceAndDelete

	};

enum TDebugLevel

	{

	EDebugLevel0=0,

	EDebugLevel1,

	EDebugLevel2,

	EDebugLevel3,

	EDebugLevel4,

	EDebugLevel5,

	EDebugLevel6,

	EDebugLevel7,

	EDebugLevel8,

	EDebugLevel9

	};

class CActiveConsole;

class CTestRefreshMBox : public CActive

	{

public:

	static CTestRefreshMBox* NewLC(CCommandLineArguments* aCmdLineArgs);

	static CTestRefreshMBox* NewL(CCommandLineArguments* aCmdLineArgs);

	// Destruction

	~CTestRefreshMBox();

	// Issue request

	void StartL();

	void EnterStateL(TInt aState);

	// Cancel request.

	// Defined as pure virtual by CActive;

	// implementation provided by this class.

	void DoCancel();

	// Service  request.

	// Defined as pure virtual by CActive;

	// implementation provided by this class,

	void RunL();

	TInt NumBadMessages();

	void ModifyImap4SynchronisationLimitsL(TInt aInboxSyncLimit,TInt aMailboxSyncLimit);

	void FindImap4SettingsL();

	void CreateDefaultServiceL(CImImap4Settings* aSettings);

	void CreateServiceL( const CImImap4Settings* aSettings,

						 const TDesC& aDetails, const TDesC& aDescription,

						 const TBool aLocalOnly =EFalse);

	void QueueOpL(TImap4OpType aOp);

	void UnQueueOpL(TImap4OpType aOp);

	void QueueLocalToLocalOpL(TImap4OpType aOp);

 	CMsvServerEntry* ServerEntry();

	void SelectServiceIdL();

	TMsvId iServiceId;

	void DoCancelOffLineOpsL();

	void SetConsole(CActiveConsole* aConsole) {iConsole=aConsole;} 

	CEmailTestUtils*		iTestUtils;

	TInt iDebugLevel;

private:

    void EndOfTest();  

	void SetSubscriptionsL( TFolderSyncType aSync, TFolderSubscribeType aSubscribe );

	void FindAttachmentL();

	void FindMessagesInSelectionL();

	void DoConnectL();

	void DoConnectAndSyncL();

	void DoFullSyncL();

	void DoInboxNewSyncL();

	void DoSyncTreeL();

	void DoFetchInboxL();

	void DoDisconnectL();

	void DoWaitForBackgroundL();

	void DoFetchAttachmentL();

    void DoFetchAttachedMessageL();

	void DoRenameFolderL();

	void DoAutomatedOffLineOpsL();

	void DoAutomatedSyncOpsL();

	void DoFetchTestL();

	void DoFolderRemoveL();

	void DoFolderRemoveL(TMsvId aParent, const TDesC& aName);

	void DoFolderCreateL();

	void DoFolderCreateL(TMsvId aParent, const TDesC& aName);

	void DoAutomatedSecondaryConnectOpsL();

	void DoCopyMessagesL();

	TBool StateMachineCheckServerContentsL();

	void DoCheckServerContentsL();

	TBool StateMachineNSynchronisationL();

	void DoNSynchronisationRegressionL();

	void DoNSynchronisationTestsL();

	void DoNSynchronisationSpecialTestsL();

	void DoNSynchronisationPerformanceTestsL();

	void DoNSynchronisationOneOffTestsL();

	void StartTimerL();

	void ClearTimer();

	void ConstructL();

	TPtrC TestMsgName(TImap4OpType aOpType, TImap4GetMailOptions aOptions);

	void TestFolders(TImap4OpType aOpType,

					 TMsvId& srcFolder, TMsvId& destination);

	TMsvId FindMessageByNameL(TMsvId aSrcFolder, const TDesC& aName);

	TMsvId FindMessageByOpL(TMsvId aSrcFolder, TImap4OpType aOp);

	TMsvId FindMessageByOpL(TMsvId aSrcFolder, TImap4OpType aOp, TImap4GetMailOptions aOptions);

	TMsvId FindFolderByNameL(TMsvId aSrcFolder, const TDesC& aName);

	TMsvId FindByNameL(TMsvId aSrcFolder, const TDesC& aName, TBool aSearchOnDetails);

	TMsvId CountMessagesByNameL(TMsvId aSrcFolder, const TDesC& aName);

	TInt CountMessagesByOpL(TMsvId aSrcFolder, TImap4OpType aOp);

protected:

	// Data members defined by this class

	CBaseServerMtm*			iImppServerMtm;

	CMsvServerEntry*		iEntry;

	CMsvEntrySelection*		iSelection;

	TInt					iState;

private:

	CMsvServerEntry* SetEntryL(TMsvId aFolder, const TDesC& aName);

	CImHeader* GetHeaderLC();

	CImImap4Settings* GetImap4SettingsLC();

	TBool HandleSyncStateL();

	TBool HandleOffLineStateL();

	TBool TestSecondaryConnectStateMachineL();

	void NextState(TInt aInc);

	void NextState();

	void PerformOpL( TImap4OpType aOpType, const TDesC8& aParams);

	void PerformSpecialOpL(TMsvId aId, TImap4Cmds aCommand);

	void DoOpByIdL( TImap4OpType aOpType, TMsvId aId );

	void DoOpByIdL( TImap4OpType aOpType, TMsvId aId, const TDesC8& aParams );

	void DoOpL( TImap4OpType aOpType, const TDesC& aName, TMsvId aSourceFolder, TMsvId aDestFolder, const TDesC8& aParams);

	void DoOpL( TImap4OpType aOpType, TMsvId aSourceFolder, TMsvId aDestFolder, const TDesC8& aParams);

	void DoOpL( TImap4OpType aOpType, TMsvId aSourceFolder, TMsvId aDestFolder);

	void DoOpL( TImap4OpType aOpType, TMsvId aSourceFolder, TMsvId aDestFolder, TImap4GetMailOptions aOptions);

	void DoOpNamedL( TImap4OpType aOpType, TMsvId aSrcFolder, TMsvId aDestFolder, const TDesC8& params);

	void DoOpNamedL( TImap4OpType aOpType, TMsvId aSrcFolder, TMsvId aDestFolder);

	void DoOpNamedL( TImap4OpType aOpType, TMsvId aSrcFolder, TMsvId aDestFolder, TImap4GetMailOptions aOptions);

	TBool TestQueueL( TMsvId aFolder, CImOffLineOperation::TOffLineOpType aOpType, TMsvId aMessage, TMsvId aTarget, TInt aFnId,	const TDesC8& aParams );

	TBool TestQueueL( TMsvId aFolder, CImOffLineOperation::TOffLineOpType aOpType, TMsvId aMessage, TMsvId aTarget, TImap4GetMailOptions aOptions );

	TBool TestQueueL( TMsvId aFolder, CImOffLineOperation::TOffLineOpType aOpType, TMsvId aMessage, TMsvId aTarget );

	TBool TestQueueEmptyL( TMsvId aFolder );

	TMsvId FindShadowL( TMsvId aFolder, TMsvId aSourceId );

	TBool TestShadowL( TMsvId aFolder, TMsvId aSourceId );

	TBool TestVisible( TMsvId aSourceId );

	TBool TestInvisible( TMsvId aSourceId );

	TBool TestComplete( TMsvId aSourceId );

	TBool TestExists( TMsvId aSourceId );

	TImDisconnectedOperationType TestDisconnectedFlags( TMsvId aSourceId );

	TBool TestSubscribed( TMsvId aSourceId );

	TBool TestNotSubscribed( TMsvId aSourceId );

	TBool TestLocalSubscription( TMsvId aSourceId );

	TBool TestNotLocalSubscription( TMsvId aSourceId );

	void TestPriorityAndReceiptAddressL();

	void DebugFormatL(TInt aDebugLevel,TRefByValue<const TDesC> aFmt,...);

	void DebugUidListL(TInt aDebugLevel);

	TMsvId iRemoteInbox;

	TMsvId iRemoteFolder1;

	TMsvId iRemoteFolder2;

	TMsvId iLocalFolder1;

	TMsvId iLocalFolder2;

	TInt iOpState;

	TInt iTestNum;

	TMsvId iSourceId;

	TMsvId iSourceFolder;

	TMsvId iDestFolder;

	TMsvId iOrigSourceId;

	CLogClient *iLogClient;

	CLogViewEvent *iLogView;

	CLogFilter *iLogFilter;

	TUint32 iMessageUid;

	TInt iSyncLimit;

	TTime iTimeStamp;

private:

	CTestRefreshMBox();

	TestUiTimer*			iTimer;

	TBool					iRenamedFolder;

	CActiveConsole*			iConsole;

	CCommandLineArguments*	iCmdLineArgs;	

public:

	enum

		{

		EImapTestConnect,

		EImapTestConnectAndSync,

		EImapTestFullSync,

		EImapTestInboxNewSync,

		EImapTestSyncTree,

		EImapTestDisconnect,

		EImapTestFetchInbox,

		EImapTestOffLineOp,

		EImapTestWaitForBackground,

		EImapTestFetchAttachment,

		EImapTestCancelOffLineOps,

		EImapTestRenameFolder,

		EImapTestAutoOffLineOp,

		EImapTestAutoSyncOp,

		EImapTestFetchTest,

		EImapTestFolderDelete,

		EImapTestFolderCreate,

		EImapTestCheckServerContents,

		EImapTestAutoSecondaryConnect,

		EImapTestLocalSubscribe,

		EImapTestLocalUnsubscribe,

        EImapTestFetchAttachedMessage,

        EImapTestCopyMessages,

		EImapTestNSynchronisation,	 

		EImapTestNSynchronisationTests,			 

		EImapTestNSynchronisationSpecialTests,

		EImapTestNSynchronisationPerformanceTests,

		EImapTestNSynchronisationOneOffTests

		};

	};

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

// My derived Console, as per the example code and the stuff in T_POPC 

class CActiveConsole : public CActive

	{

public:

	// Construction

	static CActiveConsole* NewLC( CTestRefreshMBox *aRefresher,CCommandLineArguments* aCmdLineArgs );

	// Destruction

	~CActiveConsole();

	// Issue request

	void RequestCharacter();

	// Cancel request.

	// Defined as pure virtual by CActive;

	void DoCancel();

	// Service completed request.

	// Defined as pure virtual by CActive;

	void RunL();

	// Called from RunL() to handle the completed request

	void ProcessKeyPressL(TChar aChar); 

	void DumpMessageStructureL( TMsvId aId,

							   TInt aSummary,

							   TInt aParts,

							   TBool aRecurse,

							   TBool aShowIds,

							   MsgMatchFn aMatch =0);

private:

	void ConstructL();

	CActiveConsole();

	void DisplayMainMenu();

	void DisplayImap4ServerMenu();

	void DisplayImap4SettingsMenu();

	void DisplayImap4DumpMenu();

	void DisplayHousekeepingMenu();

	void DisplayOffLineOpMenu();

	void DisplayOffLineOpQueueMenu();

	void DisplayOffLineOpUnQueueMenu();

	void DisplayOffLineOpQueueLocalToLocalMenu();

	void DisplayConnectMenu();

	void DisplayConnect2Menu();

	void DisplayAutomationMenu();

	void DisplaySynchroniseMenu();

	void DisplayDebugMenu();

	void SelectImap4ServerEntryL(TChar aChar);

	void SelectImap4SettingsEntryL(TChar aChar);

public:

	TBool	iIssueCancel;

private:	

	TUint iMenuState;

	TUint iPrevState;

	CTestRefreshMBox *iRefresher;

	CCommandLineArguments*	iCmdLineArgs;

	TInt					iLevel;

	enum

		{

		EExit = 0,

		EMainMenu,

		EImap4ServerMenu,

		EImap4SettingsMenu,

		EImap4DumpMenu,

		EHousekeepingMenu,

		EOffLineOpMenu,

		EOffLineOpQueueMenu,

		EOffLineOpUnQueueMenu,

		EOffLineOpQueueLocalToLocalMenu,

		EConnectMenu,

		EConnect2Menu,

		EAutomationMenu,

		ESynchroniseMenu,

		EDebugMenu

		};

	};

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

// Constants

_LIT(KFilePathMailTest, "c:\\mailtest\\");

#define KPeriod 10000	// period of timer

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

TestUiTimer* TestUiTimer::NewL( CConsoleBase* aConsole, CBaseServerMtm* &aImppServerMtm)

	{

	TestUiTimer* self = new(ELeave) TestUiTimer( aConsole , aImppServerMtm);

	CleanupStack::PushL(self);

	self->iImppServerMtm = aImppServerMtm;

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

TestUiTimer::TestUiTimer( CConsoleBase* aConsole , CBaseServerMtm* &aImppServerMtm)

	: CTimer(10 /*KMsgPop3RefreshMailboxPriority+1*/) , iImppServerMtm(aImppServerMtm)

	{

	iConsole = aConsole;

	period = 	KPeriod;

	iClosing = EFalse;

	iCount = 0;

	iDoneConnecting = EFalse;

	}

TestUiTimer::~TestUiTimer()

	{

	}

void TestUiTimer::ConstructL()

	{

	CTimer::ConstructL();

	CActiveScheduler::Add( this );

	}

void TestUiTimer::IssueRequest()

	{

	After( period );

	}

void TestUiTimer::DoCancel()

	{

	CTimer::DoCancel();

	}

TPtrC TestUiTimer::OpName(TImap4GenericProgress::TImap4GenericProgressOp aOp)

	{

	switch (aOp)

		{

	case TImap4GenericProgress::EConnect:

		return _L("EConnect");

	case TImap4GenericProgress::EDisconnect:

		return _L("EDisconnect");

	case TImap4GenericProgress::ESync:

		return _L("ESync");

	case TImap4GenericProgress::ESelect:

		return _L("ESelect");

	case TImap4GenericProgress::ECopyToLocal:

		return _L("ECopyToLocal");

	case TImap4GenericProgress::ECopyWithinService:

		return _L("ECopyWithinService");

	case TImap4GenericProgress::ECopyFromLocal:

		return _L("ECopyFromLocal");

	case TImap4GenericProgress::EMoveToLocal:

		return _L("EMoveToLocal");

	case TImap4GenericProgress::EMoveWithinService: