// 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:
//

/**
 @file
*/

#include "CAgentSMBase.h"
#include "dialogprocessor.h"
#include "AgentPanic.h"
#include "Ni_Log.h"


NONSHARABLE_CLASS(CDialogDestroyPCTNotification) : public CActive
/**
Declaration of this private class - forward reference in dialogprocessor.h
*/
	{
public:
	CDialogDestroyPCTNotification(RGenConAgentDialogServer* aDialogSvr,
                                  CDialogProcessor* aDlgPrc,
                                  TInt aPriority = CActive::EPriorityStandard);
	virtual ~CDialogDestroyPCTNotification();
	void RequestNotification();
private:

	/** From CActive */
	virtual void DoCancel();
	virtual void RunL();
private:
	RGenConAgentDialogServer* iDialogSvr;
	CDialogProcessor* iDlgPrc;
	};

//
// MDialogProcessorObserver
//

EXPORT_C void MDialogProcessorObserver::MDPOSelectComplete(TInt /*aError*/, const TConnectionSettings& /*aSettings*/)
	{ AgentPanic(Agent::EDialogProcessorSelectObserverNotImplemented); }

EXPORT_C void MDialogProcessorObserver::MDPOSelectModemAndLocationComplete(TInt /*aError*/, const TConnectionSettings& /*aSettings*/)
	{ AgentPanic(Agent::EDialogProcessorSelectModemAndLocationObserverNotImplemented); }

EXPORT_C void MDialogProcessorObserver::MDPOWarnComplete(TInt /*aError*/, TBool /*aResponse*/)
	{ AgentPanic(Agent::EDialogProcessorWarnObserverNotImplemented); }

EXPORT_C void MDialogProcessorObserver::MDPOLoginComplete(TInt /*aError*/)
	{ AgentPanic(Agent::EDialogProcessorLoginObserverNotImplemented); }

EXPORT_C void MDialogProcessorObserver::MDPOAuthenticateComplete(TInt /*aError*/)
	{ AgentPanic(Agent::EDialogProcessorAuthObserverNotImplemented); }

EXPORT_C void MDialogProcessorObserver::MDPOReconnectComplete(TInt /*aError*/)
	{ AgentPanic(Agent::EDialogProcessorReconnectObserverNotImplemented); }

EXPORT_C void MDialogProcessorObserver::MDPOReadPctComplete(TInt /*aError*/)
	{ AgentPanic(Agent::EDialogProcessorReadPctObserverNotImplemented); }

EXPORT_C void MDialogProcessorObserver::MDPODestroyPctComplete(TInt /*aError*/)
	{ AgentPanic(Agent::EDialogProcessorDestroyPctObserverNotImplemented); }

EXPORT_C void MDialogProcessorObserver::MDPOQoSWarningComplete(TInt /*aError*/, TBool /*aResponse*/)
	{ AgentPanic(Agent::EDialogProcessorWarnQoSObserverNotImplemented); }

//
// CDialogProcessor definitions
//

EXPORT_C CDialogProcessor* CDialogProcessor::NewL(TInt aPriority)
	{
	CDialogProcessor* self = new(ELeave) CDialogProcessor(aPriority);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(); // self
	return self;
	}

CDialogProcessor::CDialogProcessor(TInt aPriority) 
	: CActive(aPriority)
	{}

void CDialogProcessor::ConstructL()
	{
	CActiveScheduler::Add(this);
	TInt ret = iDlgServ.Connect();
	LOG(NifmanLog::Printf(_L("CDialogProcessor::ConstructL - Connect returned %d"),ret); )
	User::LeaveIfError(ret);
	iDestroyPctNotification = new(ELeave) CDialogDestroyPCTNotification(&iDlgServ,this);
	iState = ENoState;
	}

EXPORT_C CDialogProcessor::~CDialogProcessor()
	{
	CancelEverything();
	delete iDestroyPctNotification;
	iDlgServ.Close();
	}

EXPORT_C void CDialogProcessor::SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs)
/**
Request connection dialog
*/
	{
	iDlgServ.IapConnection(iSettings.iIAPId, aPrefs, iStatus);

	SetActive(aObserver,ESelectConnection);
	}

EXPORT_C void CDialogProcessor::SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, TInt aLastError)

/**
Request connection dialog
*/
	{
	iDlgServ.IapConnection(iSettings.iIAPId, aPrefs, aLastError, iStatus);

	SetActive(aObserver,ESelectConnection);
	}

EXPORT_C void CDialogProcessor::SelectModemAndLocation(MDialogProcessorObserver& aObserver)
/**
Request Modem Dialog
*/
	{
	iDlgServ.ModemAndLocationSelection(iSettings.iBearerId,iSettings.iLocationId,iStatus);
	SetActive(aObserver,ESelectModemAndLocation);
	}

EXPORT_C void CDialogProcessor::Authenticate(MDialogProcessorObserver& aObserver, TDes& aUsername,TDes& aPassword,TBool aIsReconnect)
/**
Request authentication dialog
*/
	{
	iDlgServ.Authenticate(aUsername,aPassword,aIsReconnect,iStatus);
	SetActive(aObserver,EAuthentication);
	}

EXPORT_C void CDialogProcessor::Reconnect(MDialogProcessorObserver& aObserver)
/**
Request reconnect dialog
*/
	{
	iDlgServ.Reconnect(iReconResponse,iStatus);
	SetActive(aObserver,EReconnect);
	}

EXPORT_C void CDialogProcessor::WarnNewConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, const TDesC* aNewIapName, const TIspConnectionNames*, TInt aLastError)
/**
Warn of new connection dialog
*/
	{
	__ASSERT_DEBUG(aNewIapName, AgentPanic(Agent::ENullWarnParameter));
	iDlgServ.WarnNewIapConnection(aPrefs, aLastError, *aNewIapName, iWarnNewConnectResponse, iStatus);

	SetActive(aObserver,EWarnNewConnection);
	}

EXPORT_C void CDialogProcessor::Login(MDialogProcessorObserver& aObserver, TDes& aUsername, TDes& aPassword,TBool aIsReconnect)
/**
Request login dialog
*/
	{
	iDlgServ.Login(aUsername,aPassword,aIsReconnect,iStatus);
	SetActive(aObserver,ELogin);
	}

EXPORT_C void CDialogProcessor::DestroyPctNotification(MDialogProcessorObserver& aObserver)
/**
Request notification on destruction of PCT. 
*/
	{
	iDestroyPctNotification->RequestNotification();
	iPctDestructionObserver = &aObserver;
	}

EXPORT_C void CDialogProcessor::ReadPct(MDialogProcessorObserver& aObserver, TDes& aData)
/**
Request read from PCT and return read string in aData
*/
	{
	iDlgServ.ReadPct(aData,iStatus);
	SetActive(aObserver,EReadPct);
	}

EXPORT_C void CDialogProcessor::QoSWarning(MDialogProcessorObserver& aObserver)
/**
Warn QoS has fallen below minimum values
*/
	{
	iDlgServ.QoSWarning(iQoSWarningResponse, iStatus);
	SetActive(aObserver,EQoSWarning);
	}

EXPORT_C TInt CDialogProcessor::OpenPct()
/**
Request open of PCT
*/
	{
	return iDlgServ.OpenPct();
	}

EXPORT_C TInt CDialogProcessor::WritePct(const TDesC& aData)
/**
Request write aData to PCT
*/
	{
	return iDlgServ.WritePct(aData);
	}

EXPORT_C void CDialogProcessor::ClosePct()
/**
Request close of PCT
*/
	{
	iDlgServ.ClosePct();
	}	

EXPORT_C void CDialogProcessor::CancelEverything()
/**
Cancel the active object waiting on the destroy pct notification 
and then everything else outstanding
*/
	{
	if (iDestroyPctNotification)
		{
		iDestroyPctNotification->Cancel();
		// Null the observer pointer, the observer is owned by other objects!
		iPctDestructionObserver = NULL;
		}

	Cancel();
	}	

void CDialogProcessor::CompleteDestroyPctNotification(TInt aStatus)
/**
Complete notification on destruction of PCT
*/
	{
	if (iPctDestructionObserver)
		{
		iPctDestructionObserver->MDPODestroyPctComplete(aStatus);
		// Null the observer pointer, the observer is owned by other objects!
		iPctDestructionObserver = NULL;
		}
	}

void CDialogProcessor::SetActive(MDialogProcessorObserver& aObserver, TDPState aState)
	{
	__ASSERT_DEBUG(!iCurrentObserver, AgentPanic(Agent::EObserverNotNull));

	iCurrentObserver = &aObserver;
	iState = aState;
	CActive::SetActive();
	}

void CDialogProcessor::RunL()
	{
	__ASSERT_DEBUG(iCurrentObserver, AgentPanic(Agent::EObserverNull));

	const TDPState state = iState;
	iState = ENoState;
	MDialogProcessorObserver* currentObserver = iCurrentObserver;
	iCurrentObserver = NULL;

	switch (state)
		{
	case ESelectConnection:
		currentObserver->MDPOSelectComplete(iStatus.Int(),iSettings);
		break;
	case EWarnNewConnection:
		currentObserver->MDPOWarnComplete(iStatus.Int(),iWarnNewConnectResponse);
		break;
	case ESelectModemAndLocation:
		currentObserver->MDPOSelectModemAndLocationComplete(iStatus.Int(),iSettings);
		break;
	case ELogin:
		currentObserver->MDPOLoginComplete(iStatus.Int());
		break;
	case EAuthentication:
		currentObserver->MDPOAuthenticateComplete(iStatus.Int());
		break;
	case EReconnect:
		if(iReconResponse)
			currentObserver->MDPOReconnectComplete(KErrNone);
		else
			currentObserver->MDPOReconnectComplete(KErrCancel);
		break;
	case EReadPct:
		currentObserver->MDPOReadPctComplete(iStatus.Int());
		break;
	case EQoSWarning:
		currentObserver->MDPOQoSWarningComplete(iStatus.Int(),iQoSWarningResponse);
		break;
	default:
		User::Leave(KErrGeneral);
		break;
		}
	}

void CDialogProcessor::DoCancel()
/**
Only called if CDialogProcessor is active (Could be inactive while iDestroyPctNotification
is still active so should call CancelEverything() instead if pct around)
*/
	{ 
	__ASSERT_DEBUG(!iPctDestructionObserver, AgentPanic(Agent::EDestroyNotificationNotCancelled));

	switch (iState)
		{
	case ESelectConnection:
		iDlgServ.CancelIapConnection();
		break;
	case ESelectModemAndLocation:
		iDlgServ.CancelModemAndLocationSelection();
		break;
	case EWarnNewConnection:
		iDlgServ.CancelWarnNewIapConnection();
		break;
	case ELogin:
		iDlgServ.CancelLogin();
		break;
	case EAuthentication:
		iDlgServ.CancelAuthenticate();
		break;
	case EReconnect:
		iDlgServ.CancelReconnect();
		break;
	case EReadPct:
		iDlgServ.CancelReadPct();
		break;
	case EQoSWarning:
		iDlgServ.CancelQoSWarning();
		break;
	default:
		AgentPanic(Agent::EIllegalActionType);
		break;
		}

	iState = ENoState;
	iCurrentObserver = NULL;
	}

//
// CDialogDestroyPCTNotification
//

CDialogDestroyPCTNotification::CDialogDestroyPCTNotification(RGenConAgentDialogServer* aDialogSvr,
															 CDialogProcessor* aDlgPrc,
															 TInt aPriority)
	: CActive(aPriority), iDialogSvr(aDialogSvr), iDlgPrc(aDlgPrc)
	{
	CActiveScheduler::Add(this);
	}

CDialogDestroyPCTNotification::~CDialogDestroyPCTNotification()
	{
	Cancel();
	}

void CDialogDestroyPCTNotification::RequestNotification()
/**
Request notification when the PCT is destroyed
*/
	{
	iDialogSvr->DestroyPctNotification(iStatus);
	SetActive();
	}

void CDialogDestroyPCTNotification::DoCancel()
/**
This will cancel any oustanding requests and cause the destroy notification to complete - which will
get caught by the CActive::Cancel()
*/
	{
	iDialogSvr->CancelDestroyPctNotification();
	}

void CDialogDestroyPCTNotification::RunL()
/**
Received notification
*/
	{
	iDlgPrc->CompleteDestroyPctNotification(iStatus.Int());
	}