// fcalendar.cpp

// 

// Copyright (c) 2009 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include "caliterator.h"

#include <calsession.h>

#include <calentryview.h>

#include <calentry.h>

#include <calalarm.h>

#include <calrrule.h>

#include <caluser.h>

#include <calprogresscallback.h>

#include <fshell/ioutils.h>

using namespace IoUtils;

// Destroy the RPointerArray

void DestroyCalEntryRPointerArray(TAny* aPtr)

    {

    RPointerArray<CCalEntry>* self = static_cast<RPointerArray<CCalEntry>*> (aPtr);

    self->ResetAndDestroy();

    }

enum TCurrentOperation

	{

	ECONewEntryView,

	ECONone	

	};

class CCmdCalendar : public CCommandBase, public MCalProgressCallBack

	{

public:

	static CCommandBase* NewLC();

	~CCmdCalendar();

private:

	CCmdCalendar();

	void DoListEntryL();

	void DoDeleteEntryL();

	void DoAddEntryL();

	void DoChangeEntryL();

	void ReadCmdLineAmendEntryContentL(CCalEntry& aEntry);	

	void ListGSDetailL(const TDesC8& aGlobalId, TInt aVerboseLevel);	

	void PrintEntryDetailL(CCalEntry* aEntry, TInt aVerboseLevel);	

	void PrintAcceptedOptions();

	TInt CheckAlarmAlertServer();

	static const TDesC* UidName(TUid aUid);

	static const TDesC* EntryMethodToString(CCalEntry::TMethod aEntryMethod);

	static const TDesC* EntryStatusToString(CCalEntry::TStatus aEntryStatus);	

	static const TDesC* EntryTypeToString(CCalEntry::TType aEntryType);	

	static const TDesC* RepeatTypeToString(TCalRRule::TType aType);

	void PrintTime(const TTime& aTime, TBool aNewline);	

private: // From CCommandBase.

	virtual const TDesC& Name() const;

	virtual void DoRunL();

	virtual void ArgumentsL(RCommandArgumentList& aArguments);

	virtual void OptionsL(RCommandOptionList& aOptions);

private:	//MCalProgressCallBack

	virtual void Progress(TInt aPercentageCompleted);

	virtual void Completed(TInt aError);

	virtual TBool NotifyProgress();

private:

	CActiveSchedulerWait* iActiveWait;

	TCurrentOperation iCurOpr;

	CCalSession* iCalSes;

	CCalEntryView* iEntryView;

	RArray<TBool> iVerbose;

	HBufC* iOptFileName;	//calendar database file full path

	TInt iOptLocalId;		//local ID

	HBufC* iOptGlobalID;

	CCalEntry::TType iOptType;

	HBufC* iOptSummary;

	HBufC* iOptStartTime;

	HBufC* iOptEndTime;

	enum 

		{

		EListEntry,

		EDeleteEntry,

		EAddEntry,

		EChangeEntry,		

		} iCommand;

	};

CCommandBase* CCmdCalendar::NewLC()

	{

	CCmdCalendar* self = new(ELeave) CCmdCalendar();

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdCalendar::CCmdCalendar()

	{

	iCurOpr = ECONone;

	iActiveWait = new (ELeave) CActiveSchedulerWait;

	}

CCmdCalendar::~CCmdCalendar()

	{

	delete iOptFileName;

	delete iOptGlobalID;

	delete iOptSummary;	

	delete iOptStartTime;

	delete iOptEndTime;

	delete iEntryView;

	delete iCalSes;

	delete iActiveWait;

	iVerbose.Close();

	}

//////////////////////////////////////////////////////

//virtual 

void CCmdCalendar::Progress(TInt /*aPercentageCompleted*/)

	{

	;

	}

//virtual 

void CCmdCalendar::Completed(TInt /*aError*/)

	{

	TBool bWaitStarted = iActiveWait->IsStarted();

	ASSERT(bWaitStarted);

	(void)bWaitStarted;

	if (iCurOpr == ECONewEntryView)

		{

		iActiveWait->AsyncStop();

		}

	iCurOpr = ECONone;

	}

TBool CCmdCalendar::NotifyProgress()

	{

	return ETrue;

	}

const TDesC& CCmdCalendar::Name() const

	{

	_LIT(KName, "fcalendar");

	return KName;

	}

void CCmdCalendar::ArgumentsL(RCommandArgumentList& aArguments)

	{

	_LIT(KArgCommand, "command");

	aArguments.AppendEnumL((TInt&)iCommand, KArgCommand);

	}

void CCmdCalendar::OptionsL(RCommandOptionList& aOptions)

	{

	_LIT(KOptVerbose, "verbose");

	aOptions.AppendBoolL(iVerbose, KOptVerbose);

	_LIT(KOptFile, "file");

	aOptions.AppendStringL(iOptFileName, KOptFile);

	_LIT(KOptLocalId, "local_id");

	aOptions.AppendUintL((TUint&)iOptLocalId, KOptLocalId);

	_LIT(KOptGlobalId, "global_id");

	aOptions.AppendStringL(iOptGlobalID, KOptGlobalId);

	_LIT(KOptType, "type");

	aOptions.AppendEnumL((TInt&)iOptType, KOptType);

	_LIT(KOptSummary, "summary");

	aOptions.AppendStringL(iOptSummary, KOptSummary);

	_LIT(KOptStartTime, "start_time");

	aOptions.AppendStringL(iOptStartTime, KOptStartTime);

	_LIT(KOptEndTime, "end_time");

	aOptions.AppendStringL(iOptEndTime, KOptEndTime);

	}

//calendar have dependency on !AlamAlertServer,

//this server is usually part of eikon and not likely to be started separately

//we need to check if this server is up and running,

//if not, no point to contiune

//

//return:

//-1 (KErrNotFound): this server is not running

//0 (KErrNone): OK

TInt CCmdCalendar::CheckAlarmAlertServer()

	{

	TInt Ret;

	TInt Res;

	TFindServer findASServer(_L("!AlarmAlertServer"));

	TFullName name;

	Res = findASServer.Next(name);

	if (Res==KErrNotFound )

		Ret = KErrNotFound;

	else

		Ret = KErrNone;

	return Ret;

	}

void CCmdCalendar::DoRunL()

	{

	TInt res;

	res = CheckAlarmAlertServer();

	LeaveIfErr(res, _L("!AlarmAlertServer not running"));

	TRAPD(err, iCalSes = CCalSession::NewL() );

	LeaveIfErr(err, _L("Could not connect to Calendar server"));

	//open the calendar database file

	if (iOptFileName && iOptFileName->Length()>0 ) 

		{

		Printf(_L("Calendar Database file: %S \r\n"), iOptFileName);

		}

	else

		{

		Printf(_L("Calendar Database file unspecified, by default S60 database file is c:Calendar\r\n"));

		delete iOptFileName; iOptFileName = NULL;

		iOptFileName = HBufC::NewL(128);

		*iOptFileName = _L("c:Calendar");

		}

	//open database file

	TRAP(err, iCalSes->OpenL(*iOptFileName) );

	LeaveIfErr(err, _L("Could not open database file"));

	//Create an entry view 

	iCurOpr = ECONewEntryView;

	TRAP(err, iEntryView = CCalEntryView::NewL(*iCalSes, *this));

	LeaveIfErr(err, _L("Could not create entry view"));

	//entry view takes a long time to build index, and we must not do anything 

	//until we received callback, therefore, must wait here.

	iActiveWait->Start();

	///////////////////////////////////////////////////////////////////////////

	switch (iCommand)

		{

	case EListEntry:

		DoListEntryL();

		break;

	case EDeleteEntry:

		DoDeleteEntryL();	

		break;

	case EAddEntry:

		DoAddEntryL();

		break;

	case EChangeEntry:

		DoChangeEntryL();

		break;

		};

	}

void CCmdCalendar::DoChangeEntryL()

	{

	//compulsory: globalid, these can not be changed later

	if (!iOptGlobalID || iOptGlobalID->Length()== 0)

		LeaveIfErr(KErrArgument, _L("No global id specified. Use -g to specify one"));

	//type cannot be changed by calendar API, warning user of this fact

	if (iOptions.IsPresent(&iOptType))

		{

		Printf(_L("Type is not allowed to change, this option (-t) will be ignored.\r\n"));

		}

	RPointerArray<CCalEntry> CalEntryArray;

	CleanupStack::PushL(TCleanupItem(DestroyCalEntryRPointerArray, &CalEntryArray));

	TBuf8<128> TmpGlobalId;

	TmpGlobalId.Copy(*iOptGlobalID);

	HBufC8* pGlobalId = HBufC8::New(128);

	CleanupStack::PushL(pGlobalId);

	*pGlobalId = TmpGlobalId;

	//do an extra check if the same global ID is already used.

	iEntryView->FetchL(*pGlobalId, CalEntryArray);

	CleanupStack::PopAndDestroy(pGlobalId);

	pGlobalId = NULL;	//this HBufC is owned by CalEntry

	TInt Cnt = CalEntryArray.Count();

	if (Cnt == 0)

		LeaveIfErr(KErrNotFound, _L("No such Global ID."));					

	Printf(_L("%d entries found\r\n"), Cnt);

	CCalEntry* pEntry = CalEntryArray[0];

	//amend necessary calendar entry properties

	ReadCmdLineAmendEntryContentL(*pEntry);

	TInt SucessfulEntryCnt = 0;

	iEntryView->UpdateL(CalEntryArray, SucessfulEntryCnt);

	Printf(_L("%d entries changed\r\n"), SucessfulEntryCnt);

	CleanupStack::PopAndDestroy();	

	}

void CCmdCalendar::DoAddEntryL()

	{

	//compulsory: globalid, type, these can not be changed later

	if (!iOptGlobalID || iOptGlobalID->Length()== 0)

		LeaveIfErr(KErrArgument, _L("No global id specified. Use -g to specify one"));							

	if (!iOptions.IsPresent(&iOptType))

		LeaveIfErr(KErrArgument, _L("No type specified. Use -t to specify one"));

	RPointerArray<CCalEntry> CalEntryArray;

	CleanupStack::PushL(TCleanupItem(DestroyCalEntryRPointerArray, &CalEntryArray));

	TBuf8<128> TmpGlobalId;

	TmpGlobalId.Copy(*iOptGlobalID);

	HBufC8* pGlobalId = HBufC8::New(128);

	CleanupStack::PushL(pGlobalId);

	*pGlobalId = TmpGlobalId;

	//do an extra check if the same global ID is already used.

	//if yes, then adding with such global id is not allowed

		{

		iEntryView->FetchL(*pGlobalId, CalEntryArray);

		TInt Cnt = CalEntryArray.Count();

		if (Cnt > 0)

			LeaveIfErr(KErrAlreadyExists, _L("The same Global ID is already used."));					

		}

	CCalEntry* pEntry = CCalEntry::NewL(iOptType, pGlobalId, 

			CCalEntry::EMethodNone, 0);

	CleanupStack::Pop(pGlobalId);

	pGlobalId = NULL;	//this HBufC is owned by CalEntry

	CalEntryArray.Append(pEntry);

	//amend necessary calendar entry properties

	ReadCmdLineAmendEntryContentL(*pEntry);

	TInt SucessfulEntryCnt = 0;

	iEntryView->StoreL(CalEntryArray, SucessfulEntryCnt);

	Printf(_L("%d entries added\r\n"), SucessfulEntryCnt);

	CleanupStack::PopAndDestroy();	

	}

void CCmdCalendar::DoDeleteEntryL()

	{

	//TInt VerboseLevel = iVerbose.Count();

	if (iOptGlobalID && iOptGlobalID->Length())

		{

		RPointerArray<CCalEntry> CalEntryArray;

		CleanupStack::PushL(TCleanupItem(DestroyCalEntryRPointerArray, &CalEntryArray));

		//FetchL is not Async

		//and there will be new CCalEntry objects generared 

		//and pointer stored in CalEntryArray

		TBuf8<256> GlobalID;

		GlobalID.Copy(*iOptGlobalID);

		iEntryView->FetchL(GlobalID, CalEntryArray);

		TInt EntryCount = CalEntryArray.Count();

		Printf(_L("%d Entries found\r\n"), EntryCount);

		for (TInt i=0; i<EntryCount; i++)

			{

			CCalEntry* pEntry = CalEntryArray[0];

			CalEntryArray.Remove(0);				

			CleanupStack::PushL(pEntry);

			iEntryView->DeleteL(*pEntry);

			CleanupStack::PopAndDestroy(pEntry);

			}		

		Printf(_L("%d Entries deleted\r\n"), EntryCount);

		CleanupStack::PopAndDestroy();

		}

	else

		{

		LeaveIfErr(KErrArgument, _L("No global id specified. Use -g to specify one"));							

		}	

	}

//list all agenda entry in the agenda server

void CCmdCalendar::DoListEntryL()

	{

	TInt VerboseLevel = iVerbose.Count();

	CCalIter* pIter = CCalIter::NewL(*iCalSes);

	CleanupStack::PushL(pIter);

	const TDesC8* pGlb = &(pIter->FirstL());

	TBuf<128> GlbId;

	while(*pGlb != KNullDesC8)

		{	

		GlbId.Copy(*pGlb);

		Printf(_L("================================\r\n"));

		Printf(_L("Group Scheduling Entry, Global ID: %S\r\n"), &GlbId);

		ListGSDetailL(*pGlb, VerboseLevel);

		pGlb = &(pIter->NextL());

		}		

	CleanupStack::PopAndDestroy(pIter);

	}

//this function read user command line options,

//and amend the corresponding Entry properties

//

void CCmdCalendar::ReadCmdLineAmendEntryContentL(CCalEntry& aEntry)

	{

	TInt res;

	//summary is optional

	if (iOptSummary && iOptSummary->Length() > 0)

		aEntry.SetSummaryL(*iOptSummary);	

	TCalTime StartTime = aEntry.StartTimeL();

	TCalTime EndTime = aEntry.EndTimeL();

	if (iOptStartTime && iOptStartTime->Length() > 0)

		{

		TTime Tmp(Time::NullTTime());

		res = Tmp.Parse(*iOptStartTime);

		if (res >= 0)

			{

			Printf(_L("StartTime recognised as ") );

			PrintTime(Tmp, ETrue);

			StartTime.SetTimeUtcL(Tmp);					

			}

		else

			{

			Printf(_L("Start Date/Time format not recogised.\r\n") );			

			}		

		}

	if (iOptEndTime && iOptEndTime->Length() > 0)

		{

		TTime Tmp(Time::NullTTime());

		res = Tmp.Parse(*iOptEndTime);		

		if (res >= 0)

			{

			Printf(_L("EndTime recognised as ") );

			PrintTime(Tmp, ETrue);

			EndTime.SetTimeUtcL(Tmp);		

			}

		else

			{

			Printf(_L("End Date/Time format not recogised.\r\n") );			

			}		

		}

	aEntry.SetStartAndEndTimeL(StartTime, EndTime);

	if (iOptLocalId)

		{

		TCalLocalUid LocalId = (TCalLocalUid) iOptLocalId;

		aEntry.SetLocalUidL(LocalId);		

		}	

	}

//verbose level

//-v = 1, -vv = 2

//

void CCmdCalendar::ListGSDetailL(const TDesC8& aGlobalId, TInt aVerboseLevel)

	{

	RPointerArray<CCalEntry> CalEntryArray;

	CleanupStack::PushL(TCleanupItem(DestroyCalEntryRPointerArray, &CalEntryArray));

	//FetchL is not Async

	//and there will be new CCalEntry objects generared 

	//and pointer stored in CalEntryArray  

	iEntryView->FetchL(aGlobalId, CalEntryArray);

	TInt Count = CalEntryArray.Count();

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

		{

		CCalEntry* pCalEntry= CalEntryArray[0];

		CalEntryArray.Remove(0);		

		CleanupStack::PushL(pCalEntry);

		//make sure leave does not occur inside this scope, 

		//or contents in CalEntryArray may not be cleaned

		TRAP_IGNORE(PrintEntryDetailL(pCalEntry, aVerboseLevel));

		CleanupStack::PopAndDestroy(pCalEntry);

		}

	CleanupStack::PopAndDestroy();

	}

void CCmdCalendar::PrintEntryDetailL(CCalEntry* aEntry, TInt aVerboseLevel)

	{

	//this matches the Group Scheduling global ID, no need to print it out

	//const TDesC8& EntryID = aEntry->UidL();	

	//for verbose level 0

	//entry type, summery, start time, end time, priority

	CCalEntry::TType EntryType = aEntry->EntryTypeL();

	const TDesC& EntrySummary = aEntry->SummaryL();

	TCalTime EntryStartTime = aEntry->StartTimeL();

	TCalTime EntryEndTime = aEntry->EndTimeL();