// 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:
// Deal with Network & Operator information
// 
//

#include <et_phone.h>
#include "Mownnum.h"
#include "mSLOGGER.H"
#include "ATIO.H"
#include "Matstd.h"
#include <etelmm.h>
#include <mmlist.h>
#include "et_phone_util.h"

// Get the own numbers from the phone
// NB - not supported by all phones.

_LIT8(KGetOwnNumbersCommand,"AT+CNUM");
_LIT8(KGetOwnNumbersResponse,"+CNUM");

CATOwnNumbers::CATOwnNumbers(CATIO* aIo, CTelObject* aTelObject, CATInit* aInit,CPhoneGlobals* aPhoneGlobals)
	: CATCommands(aIo,aTelObject,aInit,aPhoneGlobals)
	{}

CATOwnNumbers* CATOwnNumbers::NewL(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)
	{
	CATOwnNumbers* self = new(ELeave) CATOwnNumbers(aIo, aTelObject, aInit, aPhoneGlobals);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

CATOwnNumbers::~CATOwnNumbers()
	{
	if (iIo != NULL)
		{
		iIo->RemoveExpectStrings(this);
		}
	delete iOwnNumbers;
	}

void CATOwnNumbers::Start(TTsyReqHandle aTsyReqHandle, TAny* /*aParam*/)
	{
	LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tStarting Get Own Number"));
	iReqHandle = aTsyReqHandle;
	WriteExpectingResults(KGetOwnNumbersCommand, 3);	
	__ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL,Panic(EGeneral));
	iState=EATImsiWaitForWriteComplete;
	}

void CATOwnNumbers::EventSignal(TEventSource aSource)
	{
	if (aSource==ETimeOutCompletion)
		{
		LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tTimeout Error during Get Own Number read"));
		RemoveStdExpectStrings();
		Complete(KErrTimedOut,aSource);
		return;
		}

	switch(iState)
		{
		case EATImsiWaitForWriteComplete:
		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));
			{
			iIo->WriteAndTimerCancel(this);
			StandardWriteCompletionHandler(aSource, 5);
			iState=EATImsiReadComplete;
			}
		break;

		case EATImsiReadComplete:
		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));
			{
			iIo->WriteAndTimerCancel(this);
			TInt ret(ValidateExpectString());
			RemoveStdExpectStrings();
			if (ret==KErrNone)
				TRAP(ret,ParseResponseL());
			Complete(ret,aSource);
			}
			break;
	
		case EATWaitForStopState:
			__ASSERT_ALWAYS(aSource==EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));
			{
			iIo->WriteAndTimerCancel(this);
			Complete(KErrCancel, aSource);
			}
			break;


		default:
			break;
		}//switch
	}//EventSignal

void CATOwnNumbers::Stop(TTsyReqHandle aTsyReqHandle)
	{
	if(iReqHandle == TSY_HANDLE_INIT_VALUE) // default value
		{
		// it seems the Own numbers service has not been started
		// just return
		LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tCancel called, Error - invalid request handle."));
		return;
		}
	
	__ASSERT_ALWAYS(aTsyReqHandle == iReqHandle, Panic(EIllegalTsyReqHandle));
	LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tCancel called."));
	switch(iState)
		{
		case EATNotInProgress:
		case EATImsiWaitForWriteComplete:
			{
			LOGTEXT2(_L8("Current state TSY is cancelling from %d"), iState);
			Complete(KErrCancel, EReadCompletion);
			}
			break;

		default:
			{
			LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tStop, now waiting for expected modem response"));
			AddStdExpectStrings();
			iIo->SetTimeOut(this);
			iState = EATWaitForStopState;
			}
			break;

		}
	}


void CATOwnNumbers::Complete(TInt aError,TEventSource aSource)
	{
	if (aError==KErrNone || aError==KErrNotFound)
		iState = EATCompleted;
	else if (aError==KErrGeneral)
		{	
		iState = EATNotSupported;
		aError = KErrNotSupported;
		}
	else
		iState = EATNotInProgress;
	iIo->WriteAndTimerCancel(this);
	iIo->RemoveExpectStrings(this);
	iOKExpectString = NULL;
	iErrorExpectString = NULL;
	CATCommands::Complete(aError,aSource);
	LOGTEXT2(_L8("GsmTsy:CATOwnNumbers:\tCATOwnNumbers completed with error code : %d"), aError);
	iTelObject->ReqCompleted(iReqHandle, aError);
	if (aSource==EWriteCompletion)
		iIo->Read();
	}

void CATOwnNumbers::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus)
	{
	if (iState!=EATNotInProgress)
		{
		iIo->WriteAndTimerCancel(this);
		iState = EATNotInProgress;
		iTelObject->ReqCompleted(iReqHandle, aStatus);
		}
	}

void CATOwnNumbers::ParseResponseL()
	{
// +CNUM: [text],number,type[,speed,service[,itc]]
// etc.

	
	CMobilePhoneONList* oNList=CMobilePhoneONList::NewL();
	CleanupStack::PushL(oNList);	

//
	ParseBufferLC(EFalse, ':');
//

	TDblQueIter<CATParamListEntry> iter(iRxResults);
	CATParamListEntry* entry=iter++;
	while (entry)
		{
		if (entry->iResultPtr!=KGetOwnNumbersResponse)
			User::Leave(KErrGeneral);
		//
		// provide some default values
		RMobileONStore::TMobileONEntryV1 info;
		info.iMode = RMobilePhone::ENetworkModeGsm; // Hard coded since this tsy just handles GSM.
		
		entry=iter++;
		if (!entry)
			User::Leave(KErrGeneral);
		info.iText.Copy(entry->iResultPtr); 

		entry=iter++;
		if (!entry)
			User::Leave(KErrGeneral);
		info.iNumber.iTelNumber.Copy(entry->iResultPtr);

		entry=iter++;
		info.iNumber.iTypeOfNumber = NumberTypefromGSMToMM(CATParamListEntry::EntryValL(entry)); // How is this to be used

		// now the optional values
		entry=iter++;
		if (entry && entry->iResultPtr!=KGetOwnNumbersResponse)
			{
			//The baerer speed that should have been set here is not supported in the TMobileONEntryV1 class
			entry=iter++;
			TInt service=CATParamListEntry::EntryValL(entry);
			switch (service)
				
				{
			case KServiceVoice:
				info.iService = RMobilePhone::EVoiceService;
				break;
			case KServiceFax:
				info.iService = RMobilePhone::EFaxService;
				break;
			case KAsynchModem:
			case KSynchModem:
			case KPADAccess:
			case KPacketAccess:
				info.iService = RMobilePhone::ECircuitDataService;
				break;

			default:
				info.iService = RMobilePhone::EServiceUnspecified;
				break;
				}
			//
			// further optionality
			entry=iter++;
			if (entry && entry->iResultPtr!=KGetOwnNumbersResponse)
				{
				// Information about the transfer capabilities are not used in 
				// TMobileONEntryV1(the "itc" field is optionaly reurned by AT+CNUM).
				// If it had been available it hade been set here.
				entry=iter++;
				} 
			}
		oNList->AddEntryL(info);
		}
	
	CleanupStack::PopAndDestroy();		// results
	CleanupStack::Pop();				// numbers
	iOwnNumbers = oNList;

	switch (iCommand)
		{
	case EInfo:
		Info();
		break;
	case EEntry:
		(void)User::LeaveIfError(Entry(iResultIndex));
		break;
		}
	}

void CATOwnNumbers::Info() const
/**
 * This method sets the information about the own number store to be passed 
 * back to the client with cached inforamtion.
 */
	{
	RMobilePhoneStore::TMobilePhoneStoreInfoV1& storeInfo = (*iInfoPckg)();

	storeInfo.iType=RMobilePhoneStore::EOwnNumberStore;
	storeInfo.iUsedEntries = iOwnNumbers->Enumerate();
	storeInfo.iTotalEntries = iOwnNumbers->Enumerate();
	storeInfo.iName.Copy(KETelOwnNumberStore);
	storeInfo.iCaps=RMobilePhoneStore::KCapsIndividualEntry | RMobilePhoneStore::KCapsReadAccess;

	if (storeInfo.ExtensionId()==RMobilePhoneStore::KETelMobileONStoreV1)
		{
		RMobileONStore::TMobileONStoreInfoV1Pckg* onPckg 
			= reinterpret_cast<RMobileONStore::TMobileONStoreInfoV1Pckg*>(iInfoPckg);
		RMobileONStore::TMobileONStoreInfoV1& onInfo = (*onPckg)();
		onInfo.iNumberLen=RMobilePhone::KMaxMobileTelNumberSize;
		onInfo.iTextLen=RMobileONStore::KOwnNumberTextSize;
		}
	}

TInt CATOwnNumbers::Entry(TInt aIndex) const
/**
 * This method returnes the own number specified by aIndex.
 * If aIndex should be out of range KErrNotFound is returned.
 */	
	{
	__ASSERT_DEBUG(iOwnNumbers!= NULL, PanicClient(KErrGeneral));

	RMobileONStore::TMobileONEntryV1& oNEntry = (*iEntryPckg)();
	if (TUint(aIndex)>=TUint(iOwnNumbers->Enumerate()))
		{
		// If the index is out of range
		return KErrNotFound;
		}

	// Get the entry specified by the aIndex.
	TRAPD(ret,(oNEntry = iOwnNumbers->GetEntryL(aIndex)));
		
	return ret;
	}


void CATOwnNumbers::GetInfo(TTsyReqHandle aTsyReqHandle, TDes8* aInfo)
/**
 * Execute the command if we have not yet been run
 * Report the own number info if we have already evaluated them
 */
	{
	iInfoPckg=static_cast<RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg*>(aInfo);
	switch (iState)
		{
	case EATCompleted:
		Info();
		iTelObject->ReqCompleted(aTsyReqHandle, KErrNone);
		break;
	case EATNotSupported:
		iTelObject->ReqCompleted(aTsyReqHandle, KErrNotSupported);
		break;
	default:
		iCommand=EInfo;
		ExecuteCommand(aTsyReqHandle,aInfo);
		break;
		}
	}


void CATOwnNumbers::GetEntry(TTsyReqHandle aTsyReqHandle, TDes8* aEntry)
/** 
 * Execute the command if we have not yet been run.
 * @param aTsyReqHandle The request ID
 * @param aEntry This argument is of type TMobileONEntryV1Pckg.
 */
	{
	// Unpack the the TMobileONEntryV1 (aEntry)
	iEntryPckg = static_cast<RMobileONStore::TMobileONEntryV1Pckg*>(aEntry);
	RMobileONStore::TMobileONEntryV1& oNEntry = (*iEntryPckg)();

	// Extract the index of the own number to get.
	// Subtract 1 because SIM slots start at 1 but our list will start at 0
	// Client has asked for SIM slot number
	iResultIndex = oNEntry.iIndex - 1 ;

	switch (iState)
		{
	case EATCompleted:
		{
		TInt r=Entry(iResultIndex);
		if (r!=KErrNone)
			{
			iTelObject->ReqCompleted(aTsyReqHandle, r);
			return;
			}
		iTelObject->ReqCompleted(aTsyReqHandle, KErrNone);
		}
		break;
	case EATNotSupported:
		iTelObject->ReqCompleted(aTsyReqHandle, KErrNotSupported);
		break;
	default:
		iCommand=EEntry;
		ExecuteCommand(aTsyReqHandle, &oNEntry);
		break;
		}
	}//End of GetEntry


RMobilePhone::TMobileTON CATOwnNumbers::NumberTypefromGSMToMM(TUint aTypeOfNumberGSM)
/** Maping from MM Number Type To GSM Number Type
 * 
 * This method maps the GSM way of representing a type of telefon number 
 * to the MM standard.
 * 
 */
	{
	switch (aTypeOfNumberGSM)
		{
	case 129: // Nationality unknown (GSM)		
		return RMobilePhone::EUnknownNumber; //  (MM)
	case 145: // International Number (GSM)	
		return RMobilePhone::EInternationalNumber; //  (MM)
	case 161: // National Number (GSM)
		return RMobilePhone::ENationalNumber; //  (MM)
	default:
        return RMobilePhone::EUnknownNumber; //  (MM)
		}
	}