/*

* 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:  Defines the CXhtmlFileComposer class.

*

*/

#include <imageconversion.h>

#ifdef _DEBUG

#include <driveinfo.h>

#include <pathinfo.h>

#endif

#include "cxhtmlfilecomposer.h"

#include "printcapabilitycodes.h"

#include "cxfclogger.h"

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

//

// CXhtmlFileComposer::NewL

//

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

EXPORT_C CXhtmlFileComposer* CXhtmlFileComposer::NewL(const TDesC& aPath)

	{

		CXhtmlFileComposer *self = NewLC(aPath);

		CleanupStack::Pop();	// self

		return self;

	}

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

//

// CXhtmlFileComposer::NewLC

//

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

EXPORT_C CXhtmlFileComposer* CXhtmlFileComposer::NewLC(const TDesC& aPath)

	{

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

		CleanupStack::PushL(self);

		if(0 >= aPath.Length())

		{

			self->ConstructL(KXFCDefaultResultPath());

		}

		else

		{

			self->ConstructL(aPath);

		}

		return self;

	}

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

//

// CXhtmlFileComposer::CreateXhtmlFileL

//

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

EXPORT_C void CXhtmlFileComposer::CreateXhtmlFileL(const RArray<CImageInfo>& aImages, const TInt aLayout,

								  const TInt aPaperSize, const TInt /*aQuality*/,

								  const TDesC& aXhtmlPrintFile,TInt& aPageCount, TBool aDataFile)

{

	LOG("[CXhtmlFileComposer]\t WriteJobControlFileL");

	// Get page and layout related data

	PageData(aPaperSize);

	RArray<TSizeReal> positions;

	CleanupClosePushL(positions);

	LayoutData(aLayout, positions);

	ReadTemplateFileL();

	// init counter variables

	aPageCount = 0;

	TInt posIx = 0;

	TInt copies = 0;

	TInt currentImgNum = 0;

	TInt imageCount = aImages.Count();

	// loop for images

	for(TInt imgIx = 0; imgIx < aImages.Count(); imgIx++)

	{

		/**** Handle copies ****/

		copies = aImages[imgIx].Copies();

		imageCount += copies - 1; // decrease current image from copies

		// Create template blocks for each copy

		while(1 <= copies && imageCount > currentImgNum)

		{

			AddPageL(currentImgNum, posIx, aPageCount);

			AddTemplateStringL(iFrameTemplate, KFrame());

			// add frame position template once per position for all pages

			if(1 == aPageCount)

			{

				AddTemplateStringL(iPositionTemplate, KFramePosition());

				ComposePositionL(posIx, positions);

			}

			ComposeTemplateL(posIx+1, KPosId());

			--copies;

			++currentImgNum;

		}

		// add image details

		AddTemplateStringL(iImageTemplate, KImgDetails());

		ComposeTemplateL(1+imgIx, KDetId());

		// Get correct name for the image

		TFileName8 imageName;

		GetImageNameL(aImages[imgIx], imageName, aDataFile);

		/**** Image size and orientation ****/

		TSizeReal imageSize(0,0);

		TBool framePortrait = EFalse;

		SizeAndOrientationL(aImages[imgIx], imageSize, framePortrait);

		/**** Image scaling & cropping ****/

		TSizeReal scaledSize;

		GetRatioL(scaledSize, imageSize);

		// Turn frame and scaled size in correct orientation again

		if(framePortrait != iImagePortrait)

		{

			scaledSize.Reverse();

			iImageFrame.Reverse();

		}

		ComposeFileL(imageName, scaledSize, aDataFile);

	}// End of loop for images

	CleanupStack::PopAndDestroy( &positions );

	// Compose the correct unit in file

	ComposeUnitL();

	/**** Create result file ****/

	RFile newFile;

	CleanupClosePushL( newFile );

	User::LeaveIfError( newFile.Replace( iFsSession, aXhtmlPrintFile, EFileWrite) );

	newFile.Write( FinalizeBufferL() );

	CleanupStack::PopAndDestroy( &newFile );

}

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

//

// CXhtmlFileComposer::~CXhtmlFileComposer

//

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

EXPORT_C CXhtmlFileComposer::~CXhtmlFileComposer()

{

	iFsSession.Close();

	if(iFileBuf)

		delete iFileBuf;

}

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

//

// CXhtmlFileComposer::UnitToPixel

//

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

EXPORT_C TReal CXhtmlFileComposer::UnitToPixel(TReal aValue)

{

	TReal tmp = aValue;

	if(EUAMillis == iPaperType)

		tmp = aValue/(TReal)KInchDivider;

	tmp = tmp*(TReal)KDpiDivider;

	return tmp;

}

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

//

// CXhtmlFileComposer::UnitToPixel

//

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

EXPORT_C TSizeReal CXhtmlFileComposer::UnitToPixel(TSizeReal aValue)

{

	TSizeReal tmp = aValue;

	if(EUAMillis == iPaperType)

		tmp = aValue/(TReal)KInchDivider;

	tmp = tmp*(TReal)KDpiDivider;

	return tmp;

}

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

//

// CXhtmlFileComposer::PixelToUnit

//

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

EXPORT_C TReal CXhtmlFileComposer::PixelToUnit(TReal aValue)

{

	TReal tmp = aValue/(TReal)KDpiDivider;

	if(EUAMillis == iPaperType)

		tmp = tmp*(TReal)KInchDivider;

	return tmp;

}

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

//

// CXhtmlFileComposer::PixelToUnit

//

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

EXPORT_C TSizeReal CXhtmlFileComposer::PixelToUnit(TSizeReal aValue)

{

	TSizeReal tmp = aValue/(TReal)KDpiDivider;

	if(EUAMillis == iPaperType)

		tmp = tmp*(TReal)KInchDivider;

	return tmp;

}

// PROTECTED

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

//

// CXhtmlFileComposer::ConstructL

//

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

void CXhtmlFileComposer::ConstructL(const TDesC& aPath)

{

	LOG("[CXhtmlFileComposer::ConstructL]\t");

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

	iFsSession.SetSessionPath( aPath );

	iFsSession.MkDirAll( aPath );

	iPaperSize.SetSize(0,0);

	iPaperType = 0;

	iPageMargin = 0;

	iImageFrame.SetSize(0,0);

	iFileBuf = NULL;

	iImagesPerPage = 0;

	iImagePortrait=EFalse;

	iPagePortrait = ETrue;

	iPageTemplate.Copy(KNullDesC8());

	iFrameTemplate.Copy(KNullDesC8());

	iPositionTemplate.Copy(KNullDesC8());

	iImageTemplate.Copy(KNullDesC8());

	LOG("[CXhtmlFileComposer::ConstructL]\t Done.");

}

// PRIVATE

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

//

// CXhtmlFileComposer::CXhtmlFileComposer

//

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

CXhtmlFileComposer::CXhtmlFileComposer()

{

}

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

//

// CXhtmlFileComposer::GetRatioL

//

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

void CXhtmlFileComposer::GetRatioL(TSizeReal &aNewSize, TSizeReal aImageSize)

{

	LOG("[CXhtmlFileComposer::GetRatioL]\t ********************************");

	TRealX margin = 0;

	TXhtmlSetting marginStr, tmpStr;

	LOG2("[CXhtmlFileComposer::GetRatioL]\t aImageSize: %fx%f", PixelToUnit(aImageSize.iWidth), PixelToUnit(aImageSize.iHeight));

	LOG2("[CXhtmlFileComposer::GetRatioL]\t iImageFrame: %fx%f", PixelToUnit(iImageFrame.iWidth), PixelToUnit(iImageFrame.iHeight));

	LOG2("[CXhtmlFileComposer::GetRatioL]\t image ratio: %f vs. frame ratio %f", aImageSize.Ratio(), iImageFrame.Ratio());

	TReal relativeRatio = aImageSize.Ratio() / iImageFrame.Ratio();

	LOG2("[CXhtmlFileComposer::GetRatioL]\t relativeRatio: %f, iPageMargin %f", relativeRatio, iPageMargin);

	// crop borderless: if iPageMargin == 0, the margin must be negative

	if((1 < relativeRatio && iPageMargin) || (1 > relativeRatio && !iPageMargin))

	{

		LOG("[CXhtmlFileComposer::GetRatioL]\t *Match width*");

		aNewSize.SetSize(iImageFrame.iWidth, iImageFrame.iWidth/aImageSize.Ratio());

		margin = (iImageFrame.iHeight-aNewSize.iHeight)/2;

	    if((!iPagePortrait && !iPageMargin && iImagePortrait) || iPagePortrait)

	    	marginStr.Copy(KTop());

		else

	    	marginStr.Copy(KLeft());

	}

	else

	{

		LOG("[CXhtmlFileComposer::GetRatioL]\t *Match height*");

		aNewSize.SetSize(iImageFrame.iHeight*aImageSize.Ratio(), iImageFrame.iHeight);

		margin = (iImageFrame.iWidth-aNewSize.iWidth)/2;

	    if((!iPagePortrait && !iPageMargin && iImagePortrait) || iPagePortrait)

	    	marginStr.Copy(KLeft());

		else

	    	marginStr.Copy(KTop());

	}

	FormatReal(PixelToUnit(margin), tmpStr);

	marginStr.Append(tmpStr);

	LOG2("[CXhtmlFileComposer::GetRatioL]\t aNewSize: %fx%f", PixelToUnit(aNewSize.iWidth), PixelToUnit(aNewSize.iHeight));

	LOG81("[CXhtmlFileComposer::GetRatioL]\t \"%S\"", &marginStr);

	// margin not needed anymore: compose margin into file buffer

	ComposeTemplateL(marginStr, KImgMargin());

	LOG("[CXhtmlFileComposer::GetRatioL]\t ********************************");

}

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

//

// CXhtmlFileComposer::ComposeUnitL

//

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

void CXhtmlFileComposer::ComposeUnitL()

{

	LOG("[CXhtmlFileComposer]\t ComposeUnit");

	if(EUAMillis == iPaperType)

	{

		_LIT8(KMm, "mm");

		ComposeTemplateL(KMm(), KUnit());

	}

	else

	{

		_LIT8(KIn, "in");

		ComposeTemplateL(KIn(), KUnit());

	}

}

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

//

// CXhtmlFileComposer::ComposeFile

//

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

void CXhtmlFileComposer::ComposeFileL(const TDes8 &aImageName, TSizeReal aImgSize, TBool aDataFile)

{

	LOG("[CXhtmlFileComposer]\t ComposeFile");

	// Format page settings in file

	TXhtmlSetting pageWidthStr, pageHeightStr, pageMarginStr;

	FormatReal(PixelToUnit(iPaperSize.iWidth), pageWidthStr);

	ComposeTemplateL(pageWidthStr, KPageWidth());

	FormatReal(PixelToUnit(iPaperSize.iHeight), pageHeightStr);

	ComposeTemplateL(pageHeightStr, KPageHeight());

	FormatReal(iPageMargin, pageMarginStr);

	ComposeTemplateL(pageMarginStr, KPageMargin());

	// Format image frame settings in file

	TXhtmlSetting imgFrameWidthStr, imgFrameHeightStr;

	FormatReal(PixelToUnit(iImageFrame.iWidth), imgFrameWidthStr);

	ComposeTemplateL(imgFrameWidthStr, KImgFrameWidth());

	FormatReal(PixelToUnit(iImageFrame.iHeight), imgFrameHeightStr);

	ComposeTemplateL(imgFrameHeightStr, KImgFrameHeight());

	// Format image settings in file

	TXhtmlSetting imgWidthStr, imgHeightStr;

	FormatReal(PixelToUnit(aImgSize.iWidth), imgWidthStr);

	ComposeTemplateL(imgWidthStr, KImgWidth());

	FormatReal(PixelToUnit(aImgSize.iHeight), imgHeightStr);

	ComposeTemplateL(imgHeightStr, KImgHeight());

///////////

	HBufC8* data = NULL;

	if(aDataFile)

	{

		TFileName imgFile;

		imgFile.Copy(aImageName);

		LOG("[CXhtmlFileComposer]\t ComposeFileL - read image data");

		// Open the template file and read it into buffer

		RFile file;

		CleanupClosePushL(file);

		User::LeaveIfError( file.Open( iFsSession, imgFile, EFileRead | EFileShareReadersOnly ) );

		LOG("[CXhtmlFileComposer]\t ComposeFileL - file opened");

		TInt fileSize = 0;

		User::LeaveIfError( file.Size(fileSize) );

		LOG1("[CXhtmlFileComposer]\t ComposeFileL - file size %d",fileSize);

		_LIT8(KDataUrl, "data:image/jpeg;base64,");

		data = HBufC8::NewLC(fileSize + KDataUrl().Length());

		TPtr8 dataPtr( data->Des() );

		dataPtr.Zero();

		file.Read(dataPtr);

		dataPtr.Insert(0, KDataUrl());

		ComposeTemplateL(dataPtr, KImgName());

		LOG("[CXhtmlFileComposer]\t ComposeFileL - file composed");

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

	}

///////////

	else

	{

		// Format image name in file

		ComposeTemplateL(aImageName, KImgName());

	}

}

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

//

// CXhtmlFileComposer::ComposeTemplateL

//

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

void CXhtmlFileComposer::ComposeTemplateL(const TInt aValue, const TDesC8 &aTemplate)

{

//	LOG("[CXhtmlFileComposer]\t ComposeTemplateL");

	TBuf8<KDefaultRealWidth> valueStr;

	valueStr.Zero();

	valueStr.AppendNum(aValue);

	ComposeTemplateL(valueStr, aTemplate);

}

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

//

// CXhtmlFileComposer::ComposeTemplateL

//

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

void CXhtmlFileComposer::ComposeTemplateL(const TDesC8 &aStr, const TDesC8 &aTemplate)

{

//	LOG("[CXhtmlFileComposer]\t ComposeTemplateL");

	User::LeaveIfNull(iFileBuf);

	TInt pos = iFileBuf->Find(aTemplate);

	while(KErrNotFound != pos)

	{

		TInt requiredSize = iFileBuf->Des().Length() + aStr.Length();

		if(iFileBuf->Des().MaxLength() < requiredSize)

		{

			iFileBuf = iFileBuf->ReAllocL(requiredSize);

		}

		iFileBuf->Des().Replace(pos, aTemplate.Length(), aStr);

		pos = iFileBuf->Find(aTemplate);

	}

}

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

//

// CXhtmlFileComposer::SetPageTypeL

//

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

void CXhtmlFileComposer::SetPageTypeL()

{

	LOG("[CXhtmlFileComposer]\t SetPageTypeL");

	User::LeaveIfNull(iFileBuf);

	TXhtmlSetting pageType(KPageFirsts());

	TInt pos = iFileBuf->Find(KPageType());

	if(KErrNotFound >= pos)

		User::Leave(KErrCorrupt);

	while(KErrNotFound != pos)

	{

		// check if next exists to assign correct page type in template

		TPtrC8 tmpBuf;

		tmpBuf.Set(iFileBuf->Mid(pos+KPageType().Length()));

		if(KErrNotFound == tmpBuf.Find(KPageType()))

			pageType.Copy(KPageLast());

		// replace correct page type in first found position

		TInt requiredSize = iFileBuf->Des().Length() + pageType.Length();

		if(iFileBuf->Des().MaxLength() < requiredSize)

		{

			iFileBuf = iFileBuf->ReAllocL(requiredSize);

		}

		iFileBuf->Des().Replace(pos, KPageType().Length(), pageType);

		pos = iFileBuf->Find(KPageType());

	}

}

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

//

// CXhtmlFileComposer::FinalizeBufferL

//

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

TPtrC8 CXhtmlFileComposer::FinalizeBufferL()

{

	LOG("[CXhtmlFileComposer]\t FinalizeBufferL");

	User::LeaveIfNull(iFileBuf);

	SetPageTypeL();

	// Remove markers from the buffer

	TInt pos = iFileBuf->Find(KPage());

	if(KErrNotFound != pos)

		iFileBuf->Des().Delete(pos, KPage().Length());

	pos = iFileBuf->Find(KFrame());

	if(KErrNotFound != pos)

		iFileBuf->Des().Delete(pos, KFrame().Length());

	pos = iFileBuf->Find(KImgDetails());

	if(KErrNotFound != pos)