// Copyright (c) 1997-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:
//

#include "FAXSERV.H"
#include "fax_reversebytes.h"
#include "FAXMDRV.H"
#include "FAXMODEM.H"
#include <et_phone.h>

#include "FAXLOG.H"


/*********************************************************************/

CFaxSession *CFaxSession::NewLC ()
	{
	CFaxSession *self = new (ELeave) CFaxSession;
	CleanupStack::PushL (self);
	return self;
	}

CFaxSession *CFaxSession::NewL ()
	{
	CFaxSession *self = NewLC ();
	CleanupStack::Pop ();
	return self;
	}
/********************************************************************/
CFaxSession::CFaxSession(void)
            :CBase()
{
}

CFaxSession::~CFaxSession ()
	{
	FxClose ();
	delete iSharedFileHandles;
	}

void CFaxSession::SetCallBack(MFaxCompletionBase* aCompletionBase)
	{
	iCompletionBase = aCompletionBase;
	}

/********************************************************************/

// this kicks off the send or receive session by launching a separate high
 // priority faxthread.  A FxOpen must be paired with a call to FxClose
 // as this is an EPOC32 requirement
 //
 // we are part of c32 here, so we cannot set a thread priority
 //
 // the heap and stack sizes set here (4K each) are pure guesswork
 // we need a handle to this parent thread so that our child thread
 // is able to signal back to us via a TRequestStatus

TInt CFaxSession::FxOpen (TFaxServerSessionSettings & aSettings,RFax::TProgress* aProgress)
{
	
    __FLOG_FAXSRV( _L8("CFaxSession::FxOpen entering"));

	ASSERT (iFaxRequest == NULL);
	iFaxServerSessionSettings = aSettings;

// Initialise the Progress Settings
	iProgress = aProgress;
	iProgress->iLastUpdateTime=0;
	iProgress->iAnswerback.Zero();
	iProgress->iPhase = ENotYetStarted;
	iProgress->iSpeed = 9600;
	iProgress->iResolution = EFaxNormal;
	iProgress->iCompression = EModifiedHuffman;
	iProgress->iECM = 0;
 	iProgress->iPage = 0;
	iProgress->iLines = 0;

	TRAPD (state, iFaxRequest = CFaxRequest::NewL (this));
	if (state == KErrNone)
		{
		iFaxRequest->iChildThread.Logon (iChildDeath);
		iFaxRequest->iChildThread.Resume ();
		User::WaitForRequest (iFaxRequest->iThreadStat);
		CActiveScheduler::Add (iFaxRequest);
		}
	return (state);
}
/********************************************************************/

TInt CFaxSession::FxClose ()
{
    __FLOG_FAXSRV( _L8("CFaxSession::FxClose entering"));

	if (iFaxRequest)
		{
		if (iFaxRequest->IsActive ())
			{
			Cancel ();
			}
		iFaxRequest->FaxRequest (EFxClose);
		User::WaitForRequest (iChildDeath);
		delete iFaxRequest;
		iFaxRequest = NULL;
		}
	if (!iAmDestructing)
		{
		iAmDestructing = ETrue;
		delete this;
		}
	return (KErrNone);
}
/********************************************************************/

MFaxCompletionBase* CFaxSession::ReturnCompletionBase ()
{
	return (iCompletionBase);
}

/*******************************************************************/

void CFaxSession::RxConnect ()
{
	iFaxRequest->FaxRequest (ERxConnect);
}
/********************************************************************/

void CFaxSession::RxFaxData (TDes8 & aData)
{
	iRxData = &aData;
	iFaxRequest->FaxRequest (ERxFaxData);
}
/********************************************************************/

void CFaxSession::RxPostPage ()
{
	iFaxRequest->FaxRequest (ERxPostPage);
}
/********************************************************************/

void CFaxSession::TxConnect ()
{
	iFaxRequest->FaxRequest (ETxConnect);
}
/********************************************************************/

void CFaxSession::TxFaxData (const TDesC8 & aData)
{
	iTxData = &aData;
	iFaxRequest->FaxRequest (ETxFaxData);
}
/********************************************************************/

void CFaxSession::TxPostPage ()
{
	iFaxRequest->FaxRequest (ETxPostPage);
}

void CFaxSession::Cancel ()
{
	iFaxRequest->Cancel ();
}

void CFaxSession::StartModemL ()
{
    __FLOG_FAXSRV( _L8("CFaxSession::StartModemL entering"));

	if (iModemDriver != NULL)
		return;

	if (iFaxServerSessionSettings.iFaxClass == EClass1)
		iModemDriver = CFaxClass1::NewL (&iFaxServerSessionSettings,*iProgress);
	else if (iFaxServerSessionSettings.iFaxClass == EClass2)
		iModemDriver = CFaxClass2::NewL (&iFaxServerSessionSettings,*iProgress);
	else if (iFaxServerSessionSettings.iFaxClass == EClass2point0)
		iModemDriver = CFaxClass20::NewL (&iFaxServerSessionSettings,*iProgress);
	else
		User::Leave (KFaxCannotAutodetect);

	iModemDriver->iFaxServerSessionSettings = &iFaxServerSessionSettings;
   iCompletionBase->GetCadenceAndTimeOfLastRing(iModemDriver->iCadence, iModemDriver->iTimeOfLastRing);
}

void CFaxSession::SetFaxHeaderFile(CFaxSharedFileHandles* aSharedFileHandles)
	{
	//if we already have an object then delete it and use this one instead
	if(iSharedFileHandles)
	{
		delete iSharedFileHandles;
		iSharedFileHandles=NULL;
	}
	//we are now owners of this object and are responsible for its deletion.
	iSharedFileHandles = aSharedFileHandles;
	}

/********************************************************************/

// the CFaxRequest class is our Fax Server Active Object

/*********************************************************************/

CFaxSession::CFaxRequest::CFaxRequest ()
:CActive (1)
{
}
/********************************************************************/

CFaxSession::CFaxRequest *CFaxSession::CFaxRequest::NewLC (CFaxSession * aFaxSession)
{
	CFaxSession::CFaxRequest *self = new (ELeave) CFaxSession::CFaxRequest ();
	CleanupStack::PushL (self);
	self->ConstructL (aFaxSession);
	return self;
}
/********************************************************************/

CFaxSession::CFaxRequest *CFaxSession::CFaxRequest::NewL (CFaxSession * aFaxSession)
{
	CFaxSession::CFaxRequest *self = NewLC (aFaxSession);
	CleanupStack::Pop ();
	return self;
}
/********************************************************************/

void CFaxSession::CFaxRequest::ConstructL (CFaxSession * aFaxSession)
{
	TInt stackSize = 0x1400;
	_LIT(KFaxThread,"FaxServerThread");

	iFaxSession = aFaxSession;
	TInt res = iFaxSession->iParentThread.Duplicate (RThread ());
	if (res == KErrNone)
		res = iChildThread.Create (KFaxThread,
			FaxServerThread,
			stackSize,
			NULL,
			iFaxSession,
			EOwnerProcess);
	if (res)
		User::Leave (KFaxThreadError);
}
/********************************************************************/

CFaxSession::CFaxRequest::~CFaxRequest ()
{
	iFaxSession->iParentThread.Close ();
	iChildThread.Close ();
}
/********************************************************************/

// once we have our active object, we simply call its FaxRequest
 // it re-activates the faxserver thread to process the request
 // and sets the FaxRequest object active before returning

void CFaxSession::CFaxRequest::FaxRequest (CFaxSession::TFaxThreadRequest aFaxThreadRequest)
{
	TRequestStatus *threadStatus = &iThreadStat;
	iFaxThreadRequest = aFaxThreadRequest;
	if (iFaxThreadRequest != EFxClose)
		{
		iStatus = KRequestPending;
		SetActive ();
		}
	iChildThread.RequestComplete (threadStatus, aFaxThreadRequest);
}
/********************************************************************/

// here we request a cancel of a fax call

void CFaxSession::CFaxRequest::DoCancel ()
{
	iCancel = 1;
	if (iFaxSession->iModemDriver)
		{
		if (iFaxSession->iModemDriver->iModem->iCancel == 0)
			iFaxSession->iModemDriver->iModem->iCancel++;
		}
}
/********************************************************************/

void CFaxSession::CFaxRequest::RunL ()
{
	switch (iFaxThreadRequest)
		{
		case ERxConnect:
				{
			iFaxSession->ReturnCompletionBase()->RxConnectComplete (iStatus.Int ());
			break;
				}

		case ERxFaxData:
				{
				iFaxSession->ReturnCompletionBase()->RxFaxDataComplete (iStatus.Int ());
			break;
				}

		case ERxPostPage:
				{
				iFaxSession->ReturnCompletionBase()->RxPostPageComplete (iStatus.Int ());
				break;
				}

		case ETxConnect:
				{
				iFaxSession->ReturnCompletionBase()->TxConnectComplete (iStatus.Int ());
				break;
				}

		case ETxFaxData:
				{
				iFaxSession->ReturnCompletionBase()->TxFaxDataComplete (iStatus.Int ());
				break;
				}

		case ETxPostPage:
				{
				iFaxSession->ReturnCompletionBase()->TxPostPageComplete (iStatus.Int ());
				break;
				}
		default:;
		}
}
/********************************************************************/
// this is a utility function which is the entry to our thread
 // it isn't part of any class, but we pass the address
 // of our CFaxModemDriver in so that we can check the
 // session parameter and get back to the required function
 //
 // it also has the thread service request dispatcher

TInt FaxServerThread (TAny * session)
	{
	TInt state=0;
	TInt ret;
	TBool terminateThread=EFalse;
	CTrapCleanup *cleanup = CTrapCleanup::New ();
	CFaxSession *faxsession = (CFaxSession *) session;
	TRequestStatus *openStatus = &faxsession->iFaxRequest->iThreadStat;
	faxsession->iParentThread.RequestComplete (openStatus, state);

	FOREVER
		{
		User::WaitForRequest (faxsession->iFaxRequest->iThreadStat);
		state = ret = KErrNone;
		
        __FLOG_FAXSRV1( _L8("FaxServerThread: iThreadStat=%d"), faxsession->iFaxRequest->iThreadStat.Int ());
		
		switch (faxsession->iFaxRequest->iThreadStat.Int ())
			{
			case CFaxSession::ERxConnect:
				TRAP (state, faxsession->StartModemL ());
							
				if (state == KErrNone)
					{
					faxsession->iModemDriver->iModem->iCancel = faxsession->iFaxRequest->iCancel;
					TRAP (state, ret = faxsession->iModemDriver->RxConnectL ());
                    __FLOG_FAXSRV2(_L8("FaxServerThread state: ERxConnect returned ret=%d, state=%d"), ret, state);
					}
				break;
			
			case CFaxSession::ERxFaxData:
				if(faxsession->iModemDriver)
					{
					TRAP (state, faxsession->iModemDriver->GetFaxDataL (faxsession->iRxData));
					__FLOG_FAXSRV2( _L8("FaxServerThread state: ERxFaxData returned ret=%d, state=%d"), ret, state);
					}
				else
					__FLOG_FAXSRV( _L8("FaxServerThread state: ERxFaxData - faxsession->iModemDriver=NULL"));
				break;
			
			case CFaxSession::ERxPostPage:
				if(faxsession->iModemDriver)
					{			
					TRAP (state, ret = faxsession->iModemDriver->RxPostPageL ());
					__FLOG_FAXSRV2( _L8("FaxServerThread: iModemDriver->RxPostPageL returned ret=%d, state=%d"), ret, state);
					}
				else
					__FLOG_FAXSRV( _L8("FaxServerThread: iModemDriver->RxPostPageL - faxsession->iModemDriver = NULL"));
				break;
			
			case CFaxSession::ETxConnect:
				__FLOG_FAXSRV(_L8("FaxServerThread state: ETxConnect"));
				TRAP (state, faxsession->StartModemL ());		//creates an instance of the appropriate 
																//modem driver (CFax1, CFax2, CFax2.0)
				if (state == KErrNone)
					{
					faxsession->iModemDriver->iModem->iCancel = faxsession->iFaxRequest->iCancel; // added now
					faxsession->iModemDriver->SetSharedFileHandles(faxsession->iSharedFileHandles);
					TRAP (state, ret = faxsession->iModemDriver->TxConnectL ());
					}
				break;
			
			case CFaxSession::ETxFaxData:
				if(faxsession->iModemDriver)
					{			
					TRAP (state, ret = faxsession->iModemDriver->SendFaxDataL (faxsession->iTxData));
					__FLOG_FAXSRV2(_L8("FaxServerThread state: ETxFaxData, state =%d, ret=%d"),state, ret);
					}
				else
					__FLOG_FAXSRV(_L8("FaxServerThread state: ETxFaxData, faxsession->iModemDriver = NULL"));
				break;
			
			case CFaxSession::ETxPostPage:
                __FLOG_FAXSRV(_L8("FaxServerThread state: ETxPostPage"));
				if(faxsession->iModemDriver)
					{			
					TRAP (state, ret = faxsession->iModemDriver->TxPostPageL ());
					}
				else
					{
					__FLOG_FAXSRV(_L8("FaxServerThread state: ETxPostPage, faxsession->iModemDriver = NULL"));
					}
				break;
			
			case CFaxSession::EFxClose:
                __FLOG_FAXSRV(_L8("FaxServerThread state: EFxClose:"));

				delete faxsession->iModemDriver;
				faxsession->iModemDriver = NULL;
				terminateThread=ETrue;
				state = KErrNone;
				ret   = KErrNone;
				break;
			
			default:
				state = KErrNone;
				ret   = KErrNone;
                break;
			}
		if (state == KErrNone)
			state = ret;
		if (faxsession->iFaxRequest->iCancel)
			{
			
			__FLOG_FAXSRV1(_L8("FaxServerThread: iCancel=%d"), faxsession->iFaxRequest->iCancel);
			
			state = KFaxCancelRequested;
			delete faxsession->iModemDriver;
			faxsession->iModemDriver = NULL;
			}
		if (faxsession->iFaxRequest->IsActive ())
			{
			TRequestStatus *returnStatus = &faxsession->iFaxRequest->iStatus;
			faxsession->iParentThread.RequestComplete (returnStatus, state);
			}
		if(terminateThread)
			break;
//		if (faxsession->iModemDriver == NULL)
//			break;
		}
	delete cleanup;
	return (state);
}
/*********************************************************************/

TFaxServerSessionSettings& TFaxServerSessionSettings::operator=(const TFaxServerSessionSettings& aSettings)
	{
	iPhoneNumber = aSettings.iPhoneNumber;
	iLogging = aSettings.iLogging;
	iFaxInitString = aSettings.iFaxInitString;
	iMode = aSettings.iMode;;
	iFaxClass = aSettings.iFaxClass;
	iPortDriverName = aSettings.iPortDriverName;
	iCommPortName = aSettings.iCommPortName;
	iFaxId = aSettings.iFaxId;
	iMaxSpeed = aSettings.iMaxSpeed;
	iMinSpeed = aSettings.iMinSpeed;
	iPreferredECM = aSettings.iPreferredECM;
	iFaxOnDemandDelay = aSettings.iFaxOnDemandDelay;
	iTxResolution = aSettings.iTxResolution;
	iTxCompression = aSettings.iTxCompression;
	iTxPages = aSettings.iTxPages;
	iRxResolution = aSettings.iRxResolution;
	iRxCompression = aSettings.iRxCompression;
	return(*this);
	}
 
//
// First Ordinal Functions
//
extern "C"
	{
	IMPORT_C CFaxSession* LibEntry(void);	// Force "Proper Name" export
	}

EXPORT_C CFaxSession* LibEntry()
	{
	return CFaxSession::NewL();
	}