/*

* Copyright (c) 2002-2007 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:  Declares CUPPrintFactory class

*

*/

#include <f32file.h>

#include "cupprintfactory.h"

#include "upconsts.h"

#include "cuplogger.h"

_LIT( KHtmFileName, "UPnPPrint_%d.xhtml" );

_LIT(KUPnPSettingsFile, "settings.txt");

// (TInt64 == 21 chars)*2 + , + \n --> must fit in 50

const TInt KSettingsLength = 50;

// -----------------------------------------------------------------------------

// CUPPrintFactory::NewL

// -----------------------------------------------------------------------------

//

CUPPrintFactory* CUPPrintFactory::NewL( )

{

	CUPPrintFactory* self = new (ELeave) CUPPrintFactory();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();	// self

	return self;

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::~CUPPrintFactory

// Destructor

// -----------------------------------------------------------------------------

//

CUPPrintFactory::~CUPPrintFactory( )

{

	// No can do if deleting fails -> ignore leave

    TRAP_IGNORE( DeleteXhtmlFilesL() );

    iFileSession.Close();

    iCapabilities.Close();

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::CreateXhtmlFileL

// -----------------------------------------------------------------------------

//

void CUPPrintFactory::CreateXhtmlFileL(const RArray<CImageInfo>& aJobURIs, const TInt aLayout, 

								  const TInt aPaperSize, const TInt aQuality,

								  TDes& aXhtmlPrintFile, TInt& aPageCount)

{

	if ( aJobURIs.Count() < 1 )

	{

		User::Leave( KErrArgument );

	}

    iFileCount++;

    //Create XHTML-print file

	aXhtmlPrintFile.Format(KHtmFileName(), iFileCount);

	// parse XHTML-file

	CXhtmlFileComposer *fileParser = CXhtmlFileComposer::NewLC(KUPnPXhtmlPath());

	fileParser->CreateXhtmlFileL(aJobURIs, aLayout, aPaperSize, aQuality, aXhtmlPrintFile, aPageCount);

	CleanupStack::PopAndDestroy(fileParser);

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::DeleteXhtmlFilesL

// -----------------------------------------------------------------------------

//

void CUPPrintFactory::DeleteXhtmlFilesL( )

{

    CFileMan* fileMan = CFileMan::NewL( iFileSession );

    CleanupStack::PushL( fileMan ); 

    fileMan->RmDir( KUPnPXhtmlPath() );

    CleanupStack::PopAndDestroy(fileMan);

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::FileCount

// -----------------------------------------------------------------------------

//

TInt CUPPrintFactory::FileCount()

{

	return iFileCount;

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::GetCapabilityIDs

// -----------------------------------------------------------------------------

//

void CUPPrintFactory::GetCapabilityIDs(RArray<TInt>& aCapabilityIDs )

{

	for (TInt i=0; i < iCapabilities.Count(); i++)

	{

		aCapabilityIDs.Append(iCapabilities[i].iCapabilityID);

	}

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::GetCapability

// -----------------------------------------------------------------------------

//

TInt CUPPrintFactory::GetCapability(const TInt aCapabilityID, TPrintCapability& aCapability)

{

	for (TInt i=0; i < iCapabilities.Count(); i++)

	{

		if (aCapabilityID == iCapabilities[i].iCapabilityID)

		{

			// copy capability to ouput param

			aCapability.iCapabilityID 	= aCapabilityID;

			aCapability.iDefaultValue 	= iCapabilities[i].iDefaultValue;

			aCapability.iType 			= iCapabilities[i].iType;

			aCapability.iEnumCount 		= 0;

			for (TInt j=0; j < iCapabilities[i].iEnumCount; j++)

			{

				aCapability.iEnumCodes[j] = iCapabilities[i].iEnumCodes[j];

				aCapability.iEnumCount++;

			}

			return KErrNone;

		}

	}

	return KErrNotSupported;

}

//--------------------------------------------------------------------------------------------

// CUPPrintFactory::GetPrintSetting

//--------------------------------------------------------------------------------------------

TInt CUPPrintFactory::GetPrintSetting(TInt aCapabilityID, TInt& aValue)

{

	for (TInt i=0; i<iCapabilities.Count(); i++)

	{

		if (iCapabilities[i].iCapabilityID == aCapabilityID)

		{

			aValue = iCapabilities[i].iDefaultValue;

			return KErrNone;

		}

	}

	return KErrNotSupported;

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::SetPrintSetting

// -----------------------------------------------------------------------------

//

TInt CUPPrintFactory::SetPrintSetting(TInt aCapabilityID, TInt aValue)

{

	for (TInt i=0; i<iCapabilities.Count(); i++)

	{

		if (iCapabilities[i].iCapabilityID == aCapabilityID)

		{

			// validate value

			for (TInt j=0; j<iCapabilities[i].iEnumCount; j++)

			{

				if ( aValue == iCapabilities[i].iEnumCodes[j] )

				{

					iCapabilities[i].iDefaultValue = aValue;

					TRAPD(err, SetDefaultSettingsL());

					if(KErrNone != err)

						LOG1("[CUPPrintFactory::SetPrintSetting]\t Writing default values failed. Error: %d", err);

					return KErrNone;

				}

			}

			return KErrArgument;

		}

	}

	return KErrNotSupported;

}

// PRIVATE

// -----------------------------------------------------------------------------

// CUPPrintFactory::CUPPrintFactory

// CPP constructor

// -----------------------------------------------------------------------------

//

CUPPrintFactory::CUPPrintFactory()

{

    iFileCount = 0;

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::ConstructL

// Two-phased constructor

// -----------------------------------------------------------------------------

//

void CUPPrintFactory::ConstructL( )

{

	User::LeaveIfError( iFileSession.Connect() );

	iFileSession.SetSessionPath( KUPnPDataPath() );	

	// Create data and XHTML-file folder

	TInt err = iFileSession.MkDirAll( KUPnPDataPath() );

	if (err == KErrNone || err == KErrAlreadyExists)

	{

		err = iFileSession.MkDirAll( KUPnPXhtmlPath() );

	}

	if (err != KErrNone && err != KErrAlreadyExists)

	{

		User::Leave(err);

	}

	// Init capabilities

	InitCapabilities();

}

// -----------------------------------------------------------------------------

// CUPPrintFactory::InitCapabilities

// -----------------------------------------------------------------------------

//

void CUPPrintFactory::InitCapabilities()

{

	// Layout

	TPrintCapability layout;

	layout.iCapabilityID = EPrintCapabLayout;

	layout.iType = TPrintCapability::Int;

	layout.iDefaultValue = EPrintCapabLayout1UpBorderless;

	// Supported layouts

	layout.iEnumCodes[0] = EPrintCapabLayout1UpBorderless;

	layout.iEnumCodes[1] = EPrintCapabLayout1UpBorder;

	layout.iEnumCodes[2] = EPrintCapabLayout2Up;

	layout.iEnumCodes[3] = EPrintCapabLayout4Up;

	layout.iEnumCodes[4] = EPrintCapabLayout6Up;

	layout.iEnumCodes[5] = EPrintCapabLayout9Up;

	layout.iEnumCodes[6] = EPrintCapabLayout12Up;

	layout.iEnumCodes[7] = EPrintCapabLayout16Up;

	layout.iEnumCount = 8;

	// Quality

	TPrintCapability quality;

	quality.iCapabilityID = EPrintCapabQuality;

	quality.iType = TPrintCapability::Int;

	quality.iDefaultValue = EPrintCapabQualityNormal;

	// Supported quality

	quality.iEnumCodes[0] = EPrintCapabQualityNormal;

	quality.iEnumCount = 1;

	// Paper size

	TPrintCapability paper;

	paper.iCapabilityID = EPrintCapabPaperSize;

	paper.iType = TPrintCapability::Int;

	paper.iDefaultValue = EPrintCapabPaperSize4x6;

	// Supported paper sizes

	paper.iEnumCodes[0] = EPrintCapabPaperSize4x6;

	paper.iEnumCodes[1] = EPrintCapabPaperSize5x7;

	paper.iEnumCodes[2] = EPrintCapabPaperSizeA6;

	paper.iEnumCodes[3] = EPrintCapabPaperSizeA4;

	paper.iEnumCodes[4] = EPrintCapabPaperSizeLetter;

	paper.iEnumCount = 5;

	// Add to settings array

	TRAPD(err, GetDefaultSettingsL(layout.iDefaultValue, paper.iDefaultValue, quality.iDefaultValue))

	if(KErrNone != err)

		LOG1("[CUPPrintFactory::InitCapabilities]\t Reading default values failed. Error: %d", err);

	iCapabilities.Append(layout);

	iCapabilities.Append(quality);

	iCapabilities.Append(paper);

}

//--------------------------------------------------------------------------------------------

// CUPPrintFactory::GetDefaultSettingsL

//--------------------------------------------------------------------------------------------

void CUPPrintFactory::GetDefaultSettingsL(TInt& aLayout, TInt& aSize, TInt& aQuality)

{

	LOG("[CUAPrintingJobContainer::GetDefaultSettingsL]\t");

	RFile file;

	RFs fs;

	User::LeaveIfError(file.Open(iFileSession, KUPnPSettingsFile, EFileRead));

	CleanupClosePushL(file);

	TInt fileSize = 250;

	file.Size(fileSize);

	if(0 >= fileSize)

		fileSize = 250;

	// Create buffer

	HBufC8* fileBuffer = HBufC8::NewL(fileSize);

	CleanupStack::PushL(fileBuffer);

	TPtr8 bufferPtr( fileBuffer->Des() );

	bufferPtr.Zero();

	User::LeaveIfError(file.Read(bufferPtr));

	LOG81("bufferPtr: %S", &bufferPtr);

	TInt stopper = 0;

	TInt pos = bufferPtr.Find(KUPnPLineFeed8());

	while (pos > 0 && stopper < 20)

	{

		++stopper;

		LOG("----------------");

		TLex8 lex(bufferPtr.Left(pos));

		LOG81("bufferPtr.Left(pos): %S", &(bufferPtr.Left(pos)));

		// get id

		if ((lex.Peek()).IsDigit()) 

		{

			TInt id;

			TInt err =  lex.Val(id);

			LOG1("id: %d", id);

			bufferPtr = bufferPtr.Right(bufferPtr.Length() - lex.Offset()-1);

			lex.Assign(bufferPtr);

			//get value

			if ((lex.Peek()).IsDigit()) 

			{

				switch( id ) 

				{

					case EPrintCapabLayout:

						User::LeaveIfError(lex.Val(aLayout));

						LOG1("aLayout: %d", aLayout);

						break;

					case EPrintCapabPaperSize:

						User::LeaveIfError(lex.Val(aSize));

						LOG1("aSize: %d", aLayout);

						break;

					case EPrintCapabQuality:

						User::LeaveIfError(lex.Val(aQuality));

						LOG1("aQuality: %d", aQuality);

						break;

					default:

						break;

				}

				bufferPtr = bufferPtr.Right(bufferPtr.Length() - lex.Offset()-1);

				lex.Assign(bufferPtr);

			}

		}

		// find next

		pos = bufferPtr.Find(KUPnPLineFeed8());

	}

	CleanupStack::PopAndDestroy(2); //fileBuffer, file

}

//--------------------------------------------------------------------------------------------

// CUPPrintFactory::SetDefaultSettingsL

//--------------------------------------------------------------------------------------------

void CUPPrintFactory::SetDefaultSettingsL()

{

	LOG("[CUAPrintingJobContainer::SetDefaultSettingsL]\t");

	// Create buffer

	HBufC8* settingsBuf = HBufC8::NewL(KSettingsLength * iCapabilities.Count());

	CleanupStack::PushL(settingsBuf);

	for (TInt i=0; i<iCapabilities.Count(); i++)

	{

		TBuf8<50> settingsStr;

		settingsStr.AppendNum(iCapabilities[i].iCapabilityID);

		settingsStr.Append(KUPnPComma());

		settingsStr.AppendNum(iCapabilities[i].iDefaultValue);

		settingsStr.Append(KUPnPLineFeed8());

		settingsBuf->Des().Append(settingsStr);

	}

	RFile file;

	User::LeaveIfError(file.Replace(iFileSession, KUPnPSettingsFile, EFileWrite));

	CleanupClosePushL(file);

	file.Write(settingsBuf->Des());

	CleanupStack::PopAndDestroy(2); //file, settingsBuf

}

// End of file