// 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:
// Telephony Fax Test base test code.
// 
//

/**
 @file
 @internalComponent
*/

#include "faxdefn.h"
#include "fax_reversebytes.h"
#include "FAXSET.H"
#include "CFAX32.H"

#include "TE_FaxBase.h"

 #include <commsdattypesv1_1.h>

 using namespace CommsDat;


//
// Constants...
//
const TInt KFaxTestLogPeriod = 5*1000000;
_LIT(KTEFaxINIFileName, "Z:\\TestData\\Configs\\TE_Fax.INI");
_LIT8(KTEFaxINIDestNumber, "DestPhoneNumber");


/**
 *  Default constructor.
 */	
CFaxTestStep::CFaxTestStep()
	{
	// NOP
	} // CFaxTestStep::CFaxTestStep


/**
 *  Default destructor.
 */	
CFaxTestStep::~CFaxTestStep()
	{
	// NOP
	} // CFaxTestStep::~CFaxTestStep


/**
 *  Pre-amble function called before all tests.
 *
 *  @return Test verdict for this test.
 */	
TVerdict CFaxTestStep::doTestStepPreambleL()
	{
	//
	// Mark for memory leaks!!!
	//
	__UHEAP_MARK;

	//
	// Create an Active Scheduler...
	//
	iScheduler = new(ELeave) CActiveScheduler();
	CActiveScheduler::Install(iScheduler);

	return TestStepResult();
	} // CFaxTestStep::doTestStepPreambleL


/**
 *  Post-amble function called before all tests.
 *
 *  @return Test verdict for this test.
 */	
TVerdict CFaxTestStep::doTestStepPostambleL()
	{
	delete iScheduler;
	iScheduler = NULL;
	
	//
	// Check the heap for memory leaks...
	//
	__UHEAP_MARKEND;

	return TestStepResult();
	} // CFaxTestStep::doTestStepPostambleL


/**
 *  Initialise the Fax settings based on default values and CommDB settings.
 *
 *  @param aFaxSettings  Fax Settings stucture to initialise.
 */	
void CFaxTestStep::ReadDestPhoneNumberFromIniFileL(TDes8& aPhoneNumber)
	{
	//
	// Open the INI file...
	//
	RFs  fs;
	RFile  file;
	TInt  result;

	result = fs.Connect();
	TESTCHECKL(result, KErrNone);
	CleanupClosePushL(fs);

	result = file.Open(fs, KTEFaxINIFileName, EFileShareAny | EFileRead);
	if (result != KErrNone)
		{
		INFO_PRINTF2(_L("Cannot load TE_Fax.ini file! (Error %d)"), result);
		TESTCHECKL(result, KErrNone);
		}
	CleanupClosePushL(file);

	//
	// Get the file size and and then load the file into memory...
	//
	TInt  fileSize;

	result = file.Size(fileSize);
	TESTCHECKL(result, KErrNone);
	TESTL(fileSize > 0);

	HBufC8*  fileContents = HBufC8::NewLC(fileSize);
	TPtr8  fileContentsPtr(fileContents->Des());

	result = file.Read(0, fileContentsPtr);
	TESTCHECKL(result, KErrNone);

	//
	// Parse the contents of the file...
	//
	TLex8  lexInput(fileContentsPtr);

	while (!lexInput.Eos())
		{
		TPtrC8  token(lexInput.NextToken());
		lexInput.SkipSpace();

		if (token.Find(KTEFaxINIDestNumber) == KErrNone) 
			{
			lexInput.SkipSpaceAndMark();

			TPtrC8  phoneNumberPtr(lexInput.NextToken());
			TBuf<32>  phoneNumber;

			phoneNumber.Copy(phoneNumberPtr);
			INFO_PRINTF2(_L("Phone number read from INI file as \"%S\"."), &phoneNumber);

			aPhoneNumber.Copy(phoneNumber);
			}
		}

	//
	// Done, clean up...
	//
	CleanupStack::PopAndDestroy(fileContents);
	CleanupStack::PopAndDestroy(&file);
	CleanupStack::PopAndDestroy(&fs);
	} // CFaxTestStep::ReadDestPhoneNumberFromIniFileL


/**
 *  Initialise the Fax settings based on default values and CommDB settings.
 *
 *  @param aFaxSettings  Fax Settings stucture to initialise.
 */	
void CFaxTestStep::ReadFaxCommDBSettingsL(TFaxSettings& aFaxSettings)
	{
	INFO_PRINTF1(_L("Reading Fax settings from the CommDB."));

	//
	// Initialise the default values...
	//
	aFaxSettings.iFaxId.Zero();
	aFaxSettings.iMaxSpeed             = 14400;
	aFaxSettings.iMinSpeed             = 2400;
	aFaxSettings.iPreferredResolution  = EFaxFine;
	aFaxSettings.iPreferredCompression = EModifiedHuffman;
	aFaxSettings.iPreferredECM         = EFalse;
	aFaxSettings.iFaxOnDemandDelay     = 20;
	aFaxSettings.iVerbose              = 1;

	//
	// Now we now read the Comm DB modem settings - we must have
	// these to run...
	//
#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
#else
	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
#endif
	CleanupStack::PushL(db);

	//
	// Read the currently selected connection preference and find preferred IAP...
	//
	TInt prefRank = 1;
	
	CCDConnectionPrefsRecord *connectionPrefs =
		static_cast<CCDConnectionPrefsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord));
	CleanupStack::PushL(connectionPrefs);
	connectionPrefs->iRanking = prefRank;
	connectionPrefs->iDirection = ECommDbConnectionDirectionOutgoing;
	connectionPrefs->FindL(*db);
	
	// The following code is a temporary solution until an issue has been resolved in CommsDat
	// start
	CCDIAPRecord* tempPIapRecord =
		static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));
	tempPIapRecord->SetRecordId(connectionPrefs->iDefaultIAP);
	connectionPrefs->iDefaultIAP.iLinkedRecord = tempPIapRecord;
	
	CCDIAPRecord* pIapRecord = (CCDIAPRecord*)connectionPrefs->iDefaultIAP.iLinkedRecord;
	pIapRecord->SetRecordId(connectionPrefs->iDefaultIAP);
	pIapRecord->LoadL(*db);
	
	CCDBearerRecordBase* tempBearerRecord =
		static_cast<CCDBearerRecordBase*>(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));
	tempBearerRecord->SetRecordId(pIapRecord->iBearer);
	pIapRecord->iBearer.iLinkedRecord = tempBearerRecord;

	CCDBearerRecordBase* pBearerRecord = (CCDBearerRecordBase*) pIapRecord->iBearer.iLinkedRecord;
	pBearerRecord->SetRecordId(pIapRecord->iBearer);
	pBearerRecord->LoadL(*db);
	// end
	
	TUint32 iapId = pBearerRecord->iRecordTag;

	//
	// Get bearer number from IAP table, it is assumed bearer type will be a modem...
	//
	CMDBField<TUint32>* bearerField = new(ELeave) CMDBField<TUint32>(KCDTIdIAPBearer);
	CleanupStack::PushL(bearerField);
	bearerField->SetRecordId(iapId);
	bearerField->LoadL(*db);
	TUint32 modemId = *bearerField;
	CleanupStack::PopAndDestroy(bearerField);
	
	//
	// Get modem parameters...
	//
	CCDModemBearerRecord *modemRecord =
		static_cast<CCDModemBearerRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord));
	CleanupStack::PushL(modemRecord);
	modemRecord->SetRecordId(modemId);
	modemRecord->LoadL(*db);
	iPortDriverName = modemRecord->iCsyName;
	iCommPortName = modemRecord->iPortName;
	iFaxInitString = modemRecord->iFaxInitString;
	iModemInitString = modemRecord->iModemInitString;
	
	TUint32 faxClass;
	faxClass = modemRecord->iFaxClassPref;
	aFaxSettings.iFaxClass = (TFaxClass) faxClass;

	CleanupStack::PopAndDestroy(3); // db, connectionPrefs, modemId
	
	} // CFaxTestStep::ReadFaxCommDBSettingsL


/**
 *  Begin Fax Transfer.  We only launch it once the elements of
 *  session->iFaxSessionParameters are all set up.  We call it with a
 *  TRequestStatus and while waiting for the fax to end, we also display
 *  the status of the fax every second.
 *
 *  @param aFaxSession   Fax Session already in use.
 */	
TInt CFaxTestStep::BeginFaxTransfer(CFaxTransfer* aFaxSession)
	{
	TRequestStatus  threadStatus;
	TRequestStatus  timerStatus;
	RTimer  timer;
	TFaxPhase  lastPhase = ENotYetStarted;
	TInt  result;

	result = aFaxSession->Start(threadStatus);
	if (result == KErrNone)
		{
		timer.CreateLocal ();
		timer.After(timerStatus, KFaxTestLogPeriod);

		for (;;)
			{
			User::WaitForRequest(timerStatus, threadStatus);
			if (timerStatus != KRequestPending)
				{
				if (aFaxSession->Progress())
					{
					INFO_PRINTF1(_L("Cancelling - no progress!"));
					aFaxSession->Cancel();
					}
				else
					{
					lastPhase = aFaxSession->iProgress.iPhase;
					if (lastPhase != ENotYetStarted)
						{
						INFO_PRINTF6(_L("Phase %c Speed %d Resolution %d Compression %dD ECM %d"),
									 aFaxSession->iProgress.iPhase,
									 aFaxSession->iProgress.iSpeed,
									 aFaxSession->iProgress.iResolution,
									 aFaxSession->iProgress.iCompression+1,
									 aFaxSession->iProgress.iECM);
						INFO_PRINTF4(_L("Line %d Page %d Connected to \"%S\""),
									 aFaxSession->iProgress.iLines,
									 aFaxSession->iProgress.iPage,
									 &aFaxSession->iProgress.iAnswerback);
						}
					timer.After(timerStatus, KFaxTestLogPeriod);
					}
				}
			else if (threadStatus != KRequestPending)
				{
				aFaxSession->Stop();

				timer.Cancel();
				User::WaitForRequest(timerStatus);
				timer.Close ();

				result = threadStatus.Int();
				break;
				}
			}
		}

	if (result == KFaxErrNoHangup)
		{
		//
		// KFaxErrNoHangup is a phase E error and can be safely ignored.
		//
		result = KErrNone;
		}

	return (result);
	} // CFaxTestStep::BeginFaxTransfer()


void CFaxTestStep::GenerateHeaderFileL(TFaxSettings& aFaxSettings, const TUint8* aFont,
									   TInt aWidth, TInt aHeight)
{
	TFaxHeaderInfo  faxHeader;

	//
	// Declare the font size...
	//
	faxHeader.iHeaderFontWidthInBytes  = aWidth;
	faxHeader.iHeaderFontHeightInLines = aHeight;

	//
	// Work out the number of characters we can get in the scan line, so that we can
	// create a modifiable buffer to hold the header line and fill it with spaces
	//
	TInt  charactersPerLine = KFaxBytesPerScanLine / faxHeader.iHeaderFontWidthInBytes;
	HBufC8*  textBuff = HBufC8::New(charactersPerLine);
	CleanupStack::PushL(textBuff);

	if (!textBuff)
		{
		User::Leave (KErrNoMemory);
		}

	TPtr8  textLine = textBuff->Des();
	textLine.Fill(' ', charactersPerLine);

	//
	// Work out the margin we leave on each side of the page in characters
	// this is specified as 74 pixels in T.4.
	//
	TInt  margin = (74 / (8 * faxHeader.iHeaderFontWidthInBytes));

	//
	// THE FOLLOWING LAYOUT IS PURELY FOR TEST PURPOSES AND SHOULDN'T
	// BE TAKEN TO BE A DEFINITIVE HEADER LAYOUT
	//
	//
	// assume we have the date and time on the lefthand side as dd/mm/yyyy hh:mm
	// 0000000001111111
	// 1234567890123456
	// fill in the separators
	//
	textLine.Replace(margin + 3, 1, _L8 ("/"));
	textLine.Replace(margin + 6, 1, _L8 ("/"));
	textLine.Replace(margin + 14, 1, _L8 (":"));

	//
	// Set up the offsets to the data...
	//
	faxHeader.iOffsetToDay    = margin + 1;
	faxHeader.iOffsetToMonth  = margin + 4;
	faxHeader.iOffsetToYear   = margin + 7;
	faxHeader.iOffsetToHour   = margin + 12;
	faxHeader.iOffsetToMinute = margin + 15;

	//
	// Assume we have the page info on the righthand side as pp/tt
	// 54321
	// fill in the separator
	//
	textLine.Replace(charactersPerLine - margin - 3, 1, _L8 ("/"));

	//
	// Set up the offsets to the data
	//
	faxHeader.iOffsetToTotalPages  = charactersPerLine - margin - 2;
	faxHeader.iOffsetToCurrentPage = charactersPerLine - margin - 5;

	//
	// Fill the header line with appropriate information
	//
	textLine.Replace(faxHeader.iOffsetToMinute + 4, aFaxSettings.iFaxId.Length (),
					 aFaxSettings.iFaxId);

	//
	// HEADER LAYOUT NOW FINISHED
	//
	// Now we can write the fax header info to the header info file
	//
	CFaxHeaderLines*  testheader = CFaxHeaderLines::NewL();
	CleanupStack::PushL(testheader);

	testheader->WriteFaxHeaderInfoL(faxHeader);

	//
	// Now we generate the scan line and write the header line bitmap
	// via a loop for each rowInFont in the font.
	//
	TInt rowInFont;

	for (rowInFont = 0;  rowInFont < faxHeader.iHeaderFontHeightInLines;  rowInFont++)
		{
		TRawScanLine  image;

		image.SetMax ();
		image.FillZ ();
		
		TInt offsetInImage = 0;

		for (TInt characterPosition = 0;  characterPosition < charactersPerLine;  characterPosition++)
			{
			for (TInt fontByte = 0;  fontByte < faxHeader.iHeaderFontWidthInBytes;  fontByte++)
				{
				image[offsetInImage++] = (TUint8) ~ KReverseByte[*(aFont + ((textLine[characterPosition] - 32) * faxHeader.iHeaderFontHeightInLines * faxHeader.iHeaderFontWidthInBytes) + (rowInFont * faxHeader.iHeaderFontWidthInBytes) + fontByte)];
				}
			}
		testheader->WriteRawHeaderLineL(rowInFont, image);
		}

	//
	// Now we replace the first ten characters in the header text line with digits
	// and write out the font line...
	//
	textLine.Replace(0, 10, _L8 ("0123456789"));	

	for (rowInFont = 0;  rowInFont < faxHeader.iHeaderFontHeightInLines;  rowInFont++)
		{
		TRawScanLine image;

		image.SetMax ();
		image.FillZ ();

		TInt offsetInImage = 0;

		for (TInt characterPosition = 0;  characterPosition < charactersPerLine;  characterPosition++)
			{
			for (TInt fontByte = 0;  fontByte < faxHeader.iHeaderFontWidthInBytes;  fontByte++)
				{
				image[offsetInImage++] = (TUint8) ~ KReverseByte[*(aFont + ((textLine[characterPosition] - 32) * faxHeader.iHeaderFontHeightInLines * faxHeader.iHeaderFontWidthInBytes) + (rowInFont * faxHeader.iHeaderFontWidthInBytes) + fontByte)];
				}
			}
		testheader->WriteRawFontLineL(rowInFont, image);
		}

	CleanupStack::PopAndDestroy(testheader);
	CleanupStack::PopAndDestroy(textBuff);
	} // CFaxTestStep::GenerateHeaderFileL