// Copyright (c) 2001-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:
// Implements the functionality required to provide clients with
// CallWaiting status and registration information.
// 
//

/**
 @file
*/

#include <testconfigfileparser.h>
#include "CSimCallWaiting.h"
#include "CSimPhone.h"
#include "Simlog.h"

const TInt KMobServiceIndxStart = 1;
const TInt KMobServiceIndxEnd   = 5;


CSimCallWaiting* CSimCallWaiting::NewL(CSimPhone* aPhone)
/**
 * Standard two-phase constructor.
 * @param aPhone				The parent phone object.
 * @return CSimCallWaiting		The new call waiting class.
 */
	{
	CSimCallWaiting* self=new(ELeave) CSimCallWaiting(aPhone);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

CSimCallWaiting::CSimCallWaiting(CSimPhone* aPhone)
		: iPhone(aPhone)
/**
 * Trivial first phase construction.
 * @param aPhone				The parent phone object.
 */
	{
	}

void CSimCallWaiting::ConstructL()
/**
	Second phase of 2-Phase Constructor
  	Retrieves all the Call waiting related tags from the config file
*/
	{
	LOGCALL1("Starting to parse Call waiting config parameters...");

	iGetCWStatus = new(ELeave) CArrayPtrFlat<CListReadAllAttempt>(1);
	FindAndCreateCWListL();
	LOGCALL1("...Finished parsing Call waiting config parameters...");
	}
	
void CSimCallWaiting::FindAndCreateCWListL()
{
/**
  	Retrieves all the Call waiting tags that define the 
  	original status of Call waiting from the config file
*/
	LOGCALL1("CSimPhone::FindAndCreateCWListL");
	RMobilePhone::TMobilePhoneCWInfoEntryV1 entry;

	iCWList = CMobilePhoneCWList::NewL();
	TInt count=CfgFile()->ItemCount(KCWList);
	const CTestConfigItem* item=NULL;
	TInt ret=KErrNone;

	LOGCALL1("Starting to Load and Parse CWList Config parameters");
	TInt i;
	for(i=0;i<count;i++)
		{
		item=CfgFile()->Item(KCWList,i);
		if(!item)
			break;
		
		TInt serviceGroup, status;
		
		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,serviceGroup);
		if(ret!=KErrNone)
			{
			LOGPARSERR("serviceGroup",ret,0,&KCWList);
			continue;
			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,status);
		if(ret!=KErrNone)
			{
			LOGPARSERR("status",ret,1,&KCWList);
			continue;
			}
		
		entry.iServiceGroup=(RMobilePhone::TMobileService)serviceGroup;
		entry.iStatus=(RMobilePhone::TMobilePhoneCWStatus)status;

		iCWList->AddEntryL(entry);
		}
	}

CSimCallWaiting::~CSimCallWaiting()
	{
	delete iCWList;
	if (iGetCWStatus)
		iGetCWStatus->ResetAndDestroy();
	delete iGetCWStatus;
	}

TInt CSimCallWaiting::ExtFuncL(const TTsyReqHandle aReqHandle,const TInt aIpc, const TDataPackage& aPckg)
	{
	/**
  	Handles the phone based requests that apply to call waiting
  	@param aReqHandle Handle to the request
  	@param aIpc request identifier
  	@param aPckg contains additional information for the requests
	*/

	TAny* dataPtr = aPckg.Ptr1();
	TAny* dataPtr2 = aPckg.Ptr2();
	// The following requests can be completed even if the completion of another request is pending.
	switch(aIpc)
		{
	case EMobilePhoneSetCallWaitingStatus:
		return SetCallWaitingStatusL(aReqHandle,
			REINTERPRET_CAST(RMobilePhone::TMobileService*, dataPtr),
			REINTERPRET_CAST(RMobilePhone::TMobilePhoneServiceAction*,dataPtr2));
	case EMobilePhoneNotifyCallWaitingStatusChange:
		return NotifyCallWaitingStatusChange(aReqHandle, REINTERPRET_CAST(RMobilePhone::TMobilePhoneCWInfoEntryV1*, dataPtr));
	case EMobilePhoneGetWaitingStatusPhase1:
		return GetCallWaitingStatusPhase1(aReqHandle, 
			REINTERPRET_CAST(CRetrieveMobilePhoneCWList::TGetCallWaitingRequest*, dataPtr), 
			REINTERPRET_CAST(TInt*, dataPtr2));
	case EMobilePhoneGetWaitingStatusPhase2:
		return GetCallWaitingStatusPhase2(aReqHandle, 
			REINTERPRET_CAST(RMobilePhone::TClientId*, dataPtr), aPckg.Des2n());		
	default:
		break;
		}
	return KErrNotSupported;
	}
	
TInt CSimCallWaiting::CancelService(const TInt aIpc, const TTsyReqHandle aReqHandle)
	{
	/**
  	Cancels any phone based request regarding call waiting
  	@param aIpc the IPC to cancel
  	@param aReqHandle handle to the request
	*/
	switch(aIpc)
		{
	case EMobilePhoneSetCallWaitingStatus:
		return SetCallWaitingStatusCancel(aReqHandle);
	case EMobilePhoneNotifyCallWaitingStatusChange:
		return NotifyCallWaitingStatusChangeCancel(aReqHandle);
	default:
		break;
		}
	return KErrNone;
	}

TInt CSimCallWaiting::NotifyCallWaitingStatusChange(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneCWInfoEntryV1* aCW)
	{	
	/**
	Requests to be notified of change in the Call Waiting status
	@param aReqHandle Handle to the request
	@param aCW contains the service group and new status that has changed
  	*/
	__ASSERT_ALWAYS(!iCWNotification.iCWChangeInfoNotificationPending,SimPanic(ENotificationReqAlreadyOutstanding));
	iCWNotification.iCWChangeInfoNotificationPending=ETrue;
	iCWNotification.iCWChangeInfoReqHandle=aReqHandle;
	iCWNotification.iCWInfo=aCW;
	LOGCALL1("Finished CSimCallWaiting::NotifyCallWaitingStatusChange");
	return KErrNone;
	}

TInt CSimCallWaiting::NotifyCallWaitingStatusChangeCancel(const TTsyReqHandle aReqHandle)
	{
	/**
	Cancels request to be notified of call Waiting status change
	@param aReqHandle Handle to the request
	*/
	if(iCWNotification.iCWChangeInfoNotificationPending)
		{
		iCWNotification.iCWChangeInfoNotificationPending=EFalse;
		iPhone->ReqCompleted(aReqHandle,KErrCancel);
		}
	return KErrNone;
	}
	
TInt CSimCallWaiting::SetCallWaitingStatusL(const TTsyReqHandle aReqHandle, RMobilePhone::TMobileService* aService,  RMobilePhone::TMobilePhoneServiceAction* aAction)
	{
	/**
	Sets the status for call Waiting
	@param aReqHandle Handle to the request
	@param aCB condition for which the client whishes to set the call Waiting status
	@param aInfo additional parameters to set the call Waiting status
  	*/
	
	// make sure we know that the operation concluded sucessfully
	TRAPD(ret,UpdateCWListL(aService,aAction)); 	
	if ( ret != KErrNone )
		{ 
		iPhone->ReqCompleted(aReqHandle,ret);
		}
		
	// otherwise proceed and notify all went well
	// Notify change
	if (iCWNotification.iCWChangeInfoNotificationPending)
		{
		
		(iCWNotification.iCWInfo->iServiceGroup)=*aService;
				
		switch (*aAction)
			{
			case RMobilePhone::EServiceActionRegister:
			case RMobilePhone::EServiceActionActivate:
				iCWNotification.iCWInfo->iStatus= RMobilePhone::ECallWaitingStatusActive;
				break;
			case RMobilePhone::EServiceActionDeactivate:
			case RMobilePhone::EServiceActionErase:
				iCWNotification.iCWInfo->iStatus= RMobilePhone::ECallWaitingStatusNotActive;
				break;
			case RMobilePhone::EServiceActionUnspecified:
			default:
				iCWNotification.iCWInfo->iStatus= RMobilePhone::ECallWaitingStatusUnknown;
				// no sense doing any further operation - leave
				User::Leave( KErrArgument );
				break;
			}
		
		iCWNotification.iCWChangeInfoNotificationPending=EFalse;
		iPhone->ReqCompleted(iCWNotification.iCWChangeInfoReqHandle,KErrNone);
		}
		
	iPhone->ReqCompleted(aReqHandle,KErrNone);
		
	return KErrNone;
	}

TInt CSimCallWaiting::SetCallWaitingStatusCancel(const TTsyReqHandle aReqHandle)
	{
	/**
	Cancels the request to sets the status for call waiting
	@param aReqHandle Handle to the request
  	*/
	 
	iPhone->ReqCompleted(aReqHandle,KErrCancel);
	return KErrNone;
	}
	
	
	
const CTestConfigSection* CSimCallWaiting::CfgFile()
/**
 * Returns a pointer to the current configuration file section.
 *
 * @return CTestConfigSection	A pointer to the current configuration file data section.
 */
	{
	return iPhone->CfgFile();
	}

TInt CSimCallWaiting::GetCallWaitingStatusPhase1(const TTsyReqHandle aTsyReqHandle, 
												 CRetrieveMobilePhoneCWList::TGetCallWaitingRequest* aReqData, 
												 TInt* aBufSize)
	{
	/**
	1st phase retrieval of the the call waiting status list
	@param aReqHandle Handle to the request
	@param aReqData information about the request
	@param aBufSize Size of the buffer the client has to allocate for the 2nd pahase
  	*/
	LOGCALL1("CSimCallWaiting::GetCalWaitingStatusPhase1");
	
	TInt ret=KErrNone;
	TInt leaveCode=KErrNone;
	TRAP(leaveCode, ret=ProcessGetCallWaitingStatusPhase1L(aTsyReqHandle, aReqData, aBufSize););
	if (leaveCode != KErrNone)
			iPhone->ReqCompleted(aTsyReqHandle,leaveCode);

	LOGCALL1("CSimCallWaiting::GetCalWaitingStatusPhase1");
	return ret;
	}
	
TInt CSimCallWaiting::ProcessGetCallWaitingStatusPhase1L(const TTsyReqHandle aTsyReqHandle, 
														 CRetrieveMobilePhoneCWList::TGetCallWaitingRequest* aReqData, 
														 TInt* aBufSize)
	{
	/** Retrieve call waiting status of each line from phone, 
	store each CB status response as a list entry,
	stream the list and then return size of this buffer to client
	@param aReqHandle Handle to the request
	@param aReqData information about the request
	@param aBufSize Size of the buffer the client has to allocate for the 2nd pahase
	*/
	LOGCALL1("CSimCallWaiting::ProcessGetCallWaitingStatusPhase1L");

	CMobilePhoneCWList* list=CMobilePhoneCWList::NewL();
	CleanupStack::PushL(list);
		
	TInt maxNum=iCWList->Enumerate();
	//if testing all CB are non-active
	// then we have to return a single entry EAllServices
	if ( maxNum )
		{
		for(TInt i=0;i<maxNum;i++)
			{
			list->AddEntryL(iCWList->GetEntryL(i));
			}
		}
	else
		{
		// if the list is empty and the querry general then we have to return general info
		RMobilePhone::TMobilePhoneCWInfoEntryV1 entry;
		
		// Check that the data structure is supported by the simulated TSY version
		TInt err = iPhone->CheckSimTsyVersion(entry);
		if(err != KErrNone)
			{
			iPhone->ReqCompleted(aTsyReqHandle, err);
			return KErrNone;
			}

		entry.iServiceGroup	= RMobilePhone::EAllServices;
		entry.iStatus		= RMobilePhone::ECallWaitingStatusNotActive;
		list->AddEntryL( entry );
		}

	// Store the streamed list and the client ID
	CListReadAllAttempt* read=CListReadAllAttempt::NewL(aReqData->iClient,aTsyReqHandle);
	CleanupStack::PushL(read);
	
	read->iListBuf = list->StoreLC();
	CleanupStack::Pop(); // pop the CBufBase allocated by StoreLC
	
	iGetCWStatus->AppendL(read);
	CleanupStack::Pop(read); // pop the CListReadAllAttempt
	
	// return the CBufBase’s size to client
	*aBufSize=(read->iListBuf)->Size();
	
	CleanupStack::PopAndDestroy(list); // pop&destroy list
	
	// Complete first phase of list retrieval
	iPhone->ReqCompleted(aTsyReqHandle,KErrNone);
	
	LOGCALL1("CSimCallWaiting::ProcessGetCallWaitingStatusPhase1L");
	return KErrNone;
	}

TInt CSimCallWaiting::GetCallWaitingStatusPhase2(const TTsyReqHandle aTsyReqHandle, 
												 RMobilePhone::TClientId* aClient, TDes8* aBuf)
	{
	/**
	2nd phase retrieval of the the call waiting status list
	@param aReqHandle Handle to the request
	@param aClient Ponter to the client
	@param aBuf Buffer containiong the call waiting status list
	*/
	LOGCALL1("CSimCallWaiting::GetCallWaitingStatusPhase2");
	CListReadAllAttempt* read=NULL;
	// Find the get detected network attempt from this client
	for (TInt i=0; i<iGetCWStatus->Count(); ++i)
		{
		read = iGetCWStatus->At(i);
		if ((read->iClient.iSessionHandle==aClient->iSessionHandle) &&
		    (read->iClient.iSubSessionHandle==aClient->iSubSessionHandle))
			{
			TPtr8 bufPtr((read->iListBuf)->Ptr(0));
			// Copy the streamed list to the client
			aBuf->Copy(bufPtr);
			delete read;
			iGetCWStatus->Delete(i);
			iPhone->ReqCompleted(aTsyReqHandle,KErrNone);
			return KErrNone;
			}
		}
	// Should handle error case of not finding the matching client from read all phase 1
	LOGCALL1("CSimCallWaiting::GetCallWaitingStatusPhase2");
	return KErrNotFound;
	}

TInt CSimCallWaiting::GetCallWaitingStatusCancel(const TTsyReqHandle aTsyReqHandle)
	{
	/*
	Cancels a Request to retrieve the call waiting status list
	@param aReqHandle Handle to the request
	*/
	LOGCALL1("CSimCallWaiting::GetCallWaitingStatusCancel");
	iPhone->ReqCompleted(aTsyReqHandle,KErrNone);
	// Remove the read all attempt from iGetCBStatus
	CListReadAllAttempt* read=NULL;
	for (TInt i=0; i<iGetCWStatus->Count(); ++i)
		{
		read = iGetCWStatus->At(i);
		if (read->iReqHandle == aTsyReqHandle)
			{
			delete read;
			iGetCWStatus->Delete(i);
			break;
			}
		}
	iPhone->ReqCompleted(aTsyReqHandle,KErrCancel);
	LOGCALL1("CSimCallWaiting::GetCallWaitingStatusCancel");
	return KErrNone;
	}
	
inline void SplitOneEntryIntoSeparateGroupsL( 
								CMobilePhoneCWList* aCWList,
								RMobilePhone::TMobilePhoneCWInfoEntryV1 aOrigEntry,
								RMobilePhone::TMobileService aExceptServiceGroup
									)
	{
	/*
	Splits one entry valid for all basic service groups into individual entries 
	and places them into a CMobilePhoneCBList. This excludes one service group.	 
	@param aCBList The list to which to store the entries
	@param aOrigEntry The original entry; details of which should be passed to individual group entries
	@param aExceptServiceGroup The group which has to be avoided
	*/
	// we have to split the entry into entries 
	// per group with the same condition; excluding the specified service group 
	RMobilePhone::TMobilePhoneCWInfoEntryV1 anotherEntry = aOrigEntry;

	//anotherEntry.iCondition = aOrigEntry.iCondition;
	//anotherEntry.iStatus = RMobilePhone::ECallBarringStatusActive;
	RMobilePhone::TMobileService service;
	
	for (TInt i=KMobServiceIndxStart; i<=KMobServiceIndxEnd;i++)
		{
		service=static_cast<RMobilePhone::TMobileService>(i);
		if( service != aExceptServiceGroup )
			{
			anotherEntry.iServiceGroup=service;
			aCWList->AddEntryL(anotherEntry);
			}
		}//end for (another)
	}
	
void CSimCallWaiting::UpdateCWListL(RMobilePhone::TMobileService* aServiceGroup, RMobilePhone::TMobilePhoneServiceAction* aAction )
	{
	/*
	Updates the status of call waiting.
	@param aServiceGroup service group to set
	@param aAction ation to be performed 
	*/
	
	// no sense processing if either condition or change info are NULLS 
	User::LeaveIfNull(aServiceGroup);
	User::LeaveIfNull(aAction);
    
	
	//Lets do some work then
	RMobilePhone::TMobilePhoneCWInfoEntryV1 theNewEntry;

	theNewEntry.iServiceGroup = *aServiceGroup;
	
	switch (*aAction)
		{
		case RMobilePhone::EServiceActionRegister:
		case RMobilePhone::EServiceActionActivate:
			theNewEntry.iStatus= RMobilePhone::ECallWaitingStatusActive;
			break;
		case RMobilePhone::EServiceActionDeactivate:
		case RMobilePhone::EServiceActionErase:
			theNewEntry.iStatus= RMobilePhone::ECallWaitingStatusNotActive;
			break;
		case RMobilePhone::EServiceActionUnspecified:
		default:
			theNewEntry.iStatus= RMobilePhone::ECallWaitingStatusUnknown;
			// no sense doing any further operation - leave
			User::Leave( KErrArgument );
			break;
		}
		
	// retain prev version of the list in local variable and in Cleanup stack
	CMobilePhoneCWList* thePrevCWList = CMobilePhoneCWList::NewL();
	CleanupStack::PushL(thePrevCWList);
	// copy existing data into the temp storage
	for (TInt indx=0; indx<iCWList->Enumerate(); indx++)
		{ 
		thePrevCWList->AddEntryL(iCWList->GetEntryL(indx));
		}
	delete iCWList;
	iCWList = NULL;
	
	// create a new version and hold it in the class member
	iCWList = CMobilePhoneCWList::NewL();
	// get a hold of it in a local variable       
	CMobilePhoneCWList* theNewCWList = iCWList;
	RMobilePhone::TMobilePhoneCWInfoEntryV1 entry;

	TInt count = thePrevCWList->Enumerate();
	
	if (theNewEntry.iStatus == RMobilePhone::ECallWaitingStatusActive)
		{
		if (theNewEntry.iServiceGroup==RMobilePhone::EAllServices)
			{
			theNewCWList->AddEntryL(theNewEntry);
			}
		else
			{
			for (TInt i = 0; i<count; i++)
				{
				entry = thePrevCWList->GetEntryL(i);
				if(entry.iServiceGroup!=theNewEntry.iServiceGroup
					&& entry.iServiceGroup!=RMobilePhone::EAllServices)
					theNewCWList->AddEntryL(entry);
				}
			theNewCWList->AddEntryL(theNewEntry);
			}
		}
	else //deactivate
		{
		if (theNewEntry.iServiceGroup==RMobilePhone::EAllServices)
			{
			theNewCWList->AddEntryL(theNewEntry);
			}
		else
			{
			for (TInt i = 0; i<count; i++)
				{
				entry = thePrevCWList->GetEntryL(i);
				if(entry.iServiceGroup==RMobilePhone::EAllServices)
					{
					//add to the list active entries for all servive groups but the one to be deactivated
					SplitOneEntryIntoSeparateGroupsL(theNewCWList,entry, theNewEntry.iServiceGroup);
					continue;
					}
				if(entry.iServiceGroup!=theNewEntry.iServiceGroup)
					{
					theNewCWList->AddEntryL(entry);
					}
				}				
			}
			
		}
	// now delete the old memory	
	CleanupStack::PopAndDestroy(thePrevCWList);	
	}