/*
* Copyright (c) 2010 Sun Microsystems, Inc. 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 Contributor:
* Maximilian Odendahl
*
* Contributors:
* 
* Description: Caldav server, follows Symbian client/server 
*				architecture
*/

#include <e32svr.h>
#include <e32uid.h>
#include <S32MEM.H> 

#include <xmlengdocument.h>
#include <xmlengtext.h>

#include "caldavserver.h"
#include "caldavenginemgr.h"
#include "caldavserverSession.h"
#include "httpclient.h"

const TUint KServerPolicyRangeCount = 2;

const TInt KServerPolicyRanges[KServerPolicyRangeCount] =
	{
	0, // range is 0 inclusive
			200
	// range is 1-KMaxTInt inclusive
		};

const TUint8 KServerPolicyElementsIndex[KServerPolicyRangeCount] =
	{
	0, // applies to 0th range
			CPolicyServer::ENotSupported
	// applies to 1st range
		};

/**
 * CPolicyServer::TPolicyElement()
 * 
 */
const CPolicyServer::TPolicyElement
		KServerPolicyElements[] =
			{
						{
								_INIT_SECURITY_POLICY_C5(ECapabilityWriteDeviceData,ECapabilityWriteUserData, ECapabilityReadDeviceData,ECapabilityReadUserData,ECapabilityNetworkServices), CPolicyServer::EFailClient
						}
			};

const CPolicyServer::TPolicy KServerPolicy =
	{
	CPolicyServer::EAlwaysPass, // specifies all connect attempts should pass
			KServerPolicyRangeCount,
			KServerPolicyRanges,
			KServerPolicyElementsIndex,
			KServerPolicyElements
	};

/**
 * CCalDavServer::CCalDavServer
 * default constructor
 */
CCalDavServer::CCalDavServer(CActive::TPriority aActiveObjectPriority) :
	CPolicyServer(aActiveObjectPriority, KServerPolicy)
	{
	}

/**
 * CCalDavServer::NewSessionL
 * Creates a new session with the server.
 */
CSession2* CCalDavServer::NewSessionL(const TVersion& aVersion,
		const RMessage2& /*aMessage*/) const
	{
	// Check that the version is OK
	TVersion v(KCalDavServerMajorVersionNumber,
			KCalDavServerMinorVersionNumber, KCalDavServerBuildVersionNumber);
	if (!User::QueryVersionSupported(v, aVersion))
		User::Leave(KErrNotSupported);

	// CAN USE THE aMessage argument to check client's security and identity
	// can make use of this later but for now ignore. AH 4/5/05
	// the connect message is delivered via the RMessage2 object passed. 

	// do something with this later (and move it to the start of the function?)

	// Create the session.
	return new (ELeave) CCalDavServerSession(*const_cast<CCalDavServer*> (this));
	}

/**
* CCalDavServer::PanicServer
 A utility function to panic the server.
 */
void CCalDavServer::PanicServer(TCalDavServPanic aPanic)
	{
	_LIT(KTxtServerPanic,"CalDav server panic");
	User::Panic(KTxtServerPanic, aPanic);
	}

/**
 * CCalDavServer::ThreadFunction
 * The count server thread function that initialises the server.
 */
TInt CCalDavServer::ThreadFunction(TAny* /**aStarted*/)
	{
	CTrapCleanup* cleanupStack = CTrapCleanup::New();
	if (!(cleanupStack))
		{
		PanicServer(ECreateTrapCleanup);
		}
	TRAPD( err, ThreadFunctionL() );
	if (err != KErrNone)
		{
		PanicServer(ESvrCreateServer);
		}

	delete cleanupStack;
	cleanupStack = NULL;

	return KErrNone;

	}

/**
 * CCalDavServer::NewLC
 * first phase construction
 */
CCalDavServer* CCalDavServer::NewLC()
	{
	CCalDavServer* self =
			new (ELeave) CCalDavServer(CActive::EPriorityStandard);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

/**
 * CCalDavServer::ConstructL
 * second phase construction
 */
void CCalDavServer::ConstructL()
	{
	StartL(KCalDavServerName);

	iMgr = CCalDavEngineMgr::NewL();
	}

/**
 * CCalDavServer::ThreadFunctionL
 * start scheduler and construct function
 */
void CCalDavServer::ThreadFunctionL()
	{
	// Construct active scheduler
	CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;
	CleanupStack::PushL(activeScheduler);

	// Install active scheduler
	// We don't need to check whether an active scheduler is already installed
	// as this is a new thread, so there won't be one
	CActiveScheduler::Install(activeScheduler);

	// Construct our server, leave it on clean-up stack
	CCalDavServer::NewLC();

	// Naming the server thread after the server helps to debug panics
	User::LeaveIfError(User::RenameThread(KCalDavServerName));

	RProcess::Rendezvous(KErrNone);

	// Start handling requests
	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2, activeScheduler); //Anonymous CCalDavServer
	}

/**
 * CCalDavServer::~CCalDavServer
 * default destructor
 */
CCalDavServer::~CCalDavServer()
	{
	if (iMgr)
		delete iMgr;
	}

/**
 * CCalDavServer::SyncL
 * 
 */
TInt CCalDavServer::SyncL(const TDesC &aCalendar)
	{
	return iMgr->SyncL(aCalendar);
	}

/**
 * CCalDavServer::SyncAllL
 * 
 */
TInt CCalDavServer::SyncAllL()
	{
	return iMgr->SyncAllL();
	}

/**
 * CCalDavServer::EnableL
 * 
 */
TInt CCalDavServer::EnableL(const TDesC &aCalendar)
	{
	return iMgr->EnableL(aCalendar);
	}

/**
 * CCalDavServer::DisableL
 * 
 */
TInt CCalDavServer::DisableL(const TDesC &aCalendar)
	{
	return iMgr->DisableL(aCalendar);
	}

/**
 * CCalDavServer::UrlL
 * 
 */
TPtrC8 CCalDavServer::UrlL(const TDesC &aCalendar)
	{
	return iMgr->UrlL(aCalendar);
	}

/**
 * CCalDavServer::SetUrlL
 * 
 */
void CCalDavServer::SetUrlL(const TDesC &aCalendar, const TDesC8 &aUrl)
	{
	return iMgr->SetUrlL(aCalendar, aUrl);
	}

/**
 * CCalDavServer::UsernameL
 * 
 */
TPtrC8 CCalDavServer::UsernameL(const TDesC &aCalendar)
	{
	return iMgr->UsernameL(aCalendar);
	}

/**
 * CCalDavServer::SetUsernameL
 * 
 */
void CCalDavServer::SetUsernameL(const TDesC &aCalendar, const TDesC8 &aUsername)
	{
	return iMgr->SetUsernameL(aCalendar, aUsername);
	}

/**
 * CCalDavServer::PasswordL
 * 
 */
TPtrC8 CCalDavServer::PasswordL(const TDesC &aCalendar)
	{
	return iMgr->PasswordL(aCalendar);
	}

/**
 * CCalDavServer::SetPasswordL
 * 
 */
void CCalDavServer::SetPasswordL(const TDesC &aCalendar, const TDesC8 &aPassword)
	{
	return iMgr->SetPasswordL(aCalendar, aPassword);
	}

/**
 * CCalDavServer::SyncIntervalL
 * 
 */
TTimeIntervalMinutes CCalDavServer::SyncIntervalL(const TDesC &aCalendar) const
	{
	return iMgr->SyncIntervalL(aCalendar);
	}

/**
 * CCalDavServer::SetSyncIntervalL
 * 
 */
void CCalDavServer::SetSyncIntervalL(const TDesC &aCalendar,
		TTimeIntervalMinutes aSyncInterval)
	{
	iMgr->SetSyncIntervalL(aCalendar, aSyncInterval);
	}

/**
 * CCalDavServer::EnabledSyncL
 * 
 */
TBool CCalDavServer::EnabledSyncL(const TDesC &aCalendar) const
	{
	return iMgr->EnabledSyncL(aCalendar);
	}

/**
 * CCalDavServer::PastDaysL
 * 
 */
TTimeIntervalDays CCalDavServer::PastDaysL(const TDesC &aCalendar) const
	{
	return iMgr->PastDaysL(aCalendar);
	}

/**
 * CCalDavServer::SetPastDaysL
 * 
 */
void CCalDavServer::SetPastDaysL(const TDesC &aCalendar, TTimeIntervalDays aDays)
	{
	iMgr->SetPastDaysL(aCalendar, aDays);
	}

/**
 * CCalDavServer::ImmediateSyncL
 * 
 */
TBool CCalDavServer::ImmediateSyncL(const TDesC &aCalendar) const
	{
	return iMgr->ImmediateSyncL(aCalendar);
	}

/**
 * CCalDavServer::SetImmediateSyncL
 * 
 */
void CCalDavServer::SetImmediateSyncL(const TDesC &aCalendar,
		TBool aImmediateSyc)
	{
	iMgr->SetImmediateSyncL(aCalendar, aImmediateSyc);
	}

/**
 * CCalDavServer::KeepServerEntryL
 * 
 */
TBool CCalDavServer::KeepServerEntryL(const TDesC &aCalendar) const
	{
	return iMgr->KeepServerEntryL(aCalendar);
	}

/**
 * CCalDavServer::SetKeepServerEntryL
 * 
 */
void CCalDavServer::SetKeepServerEntryL(const TDesC &aCalendar,
		TBool aKeepServerEntry)
	{
	iMgr->SetKeepServerEntryL(aCalendar, aKeepServerEntry);
	}

TInt E32Main()
	{
	return CCalDavServer::ThreadFunction(NULL);
	}