/*
* Copyright (c) 2004-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:  Contains the CPrintJob class definition and the PJS enum.
*
*/


#include <e32std.h>
#include <pathinfo.h>
#include <driveinfo.h>

#include "cprintjob.h"
#include "printcapabilitycodes.h"
#include "imageprint.h"
#include "clog.h"
#include "tbtmapper.h"
#include "btprotocolconsts.h"




// Public functions
//--------------------------------------------------------------------------------------------
//
// CPrintJob::NewL
//
//--------------------------------------------------------------------------------------------
CPrintJob* CPrintJob::NewL(CRsBtDevice* aDevice, RArray<TFileName>& aImages,
							const TDesC8& aUserName)
{
	CPrintJob* self = new (ELeave) CPrintJob(aDevice);
	CleanupStack::PushL(self);
	self->ConstructL(aImages, aUserName);
	CleanupStack::Pop();	// self
	return self;
}


//--------------------------------------------------------------------------------------------
//
// CPrintJob::~CPrintJob
//
//--------------------------------------------------------------------------------------------
CPrintJob::~CPrintJob()
{
	iImages.Reset();
	iImages.Close();
	iDevice = NULL;
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::SetJobId
//
//--------------------------------------------------------------------------------------------
void CPrintJob::SetJobId(const TInt aId)
{
	iJobId = aId;
}


//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetJobId
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::JobId()
{
	return iJobId;
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetJobName
//
//--------------------------------------------------------------------------------------------
void CPrintJob::GetJobName(TDes8& aJobName)
{
	// Return the name of first image
	if (iImages.Count() > 0)
	{
		iImages[0].GetFilePath(aJobName);
	}
	else
	{
		aJobName.Append(KNullDesC8());
	}
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::ImageCount
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::ImageCount()
{
	return iImages.Count();
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::Images
//
//--------------------------------------------------------------------------------------------
void CPrintJob::Images(RArray<CImageInfo>& aImages)
{
	for (TInt i=0; i < iImages.Count(); i++)
	{
		aImages.Append(iImages[i]);
	}
}


//--------------------------------------------------------------------------------------------
//
// CPrintJob::PrinterId
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::PrinterId()
{
	if(Device())
		return Device()->DeviceId();
	
	return KErrNotFound;
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetUserName
//
//--------------------------------------------------------------------------------------------
void CPrintJob::GetUserName(TPtrC8& aUserName)
{
	aUserName.Set(iUserName);
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetUserName
//
//--------------------------------------------------------------------------------------------
CRsBtDevice* CPrintJob::Device()
{
	if(iDevice)
		return iDevice;
	else
		return NULL;
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::SetNumsOfCopies
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::SetNumsOfCopies( const RArray<TInt>& aNumsOfCopies)
{
	TInt err = KErrNone;

	for(TInt arrayIx = 0, imgIx = 0; arrayIx < aNumsOfCopies.Count(); ++arrayIx)
	{
		if(iImages[imgIx].Index() < aNumsOfCopies.Count())
		{
			TInt copies = aNumsOfCopies[iImages[imgIx].Index()];
			if(0 < copies)
				iImages[imgIx].SetCopies(copies);
			++imgIx;
		}
		else
			err = KErrCorrupt;
	}
	return err;
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::GetPrintFileL
//
//--------------------------------------------------------------------------------------------
void CPrintJob::GetPrintFileL(TDes8& aPrintFile)
{
	LOG("[CPrintJob::GetPrintFileL]\t begin");
	
	TInt layout;
	TInt paper;
	TInt quality;

	GetPrintSetting(EPrintCapabLayout, layout);
	GetPrintSetting(EPrintCapabPaperSize, paper);
	GetPrintSetting(EPrintCapabQuality, quality);

	TFileName tmpFile;
	tmpFile.Copy(aPrintFile);

	CXhtmlFileComposer* fileComposer = CXhtmlFileComposer::NewLC(KNullDesC());

	LOG("[CPrintJob::GetPrintFileL]\t create file");
	fileComposer->CreateXhtmlFileL( iImages, layout, paper, quality, tmpFile, iSheets );
	
	CleanupStack::PopAndDestroy(fileComposer);
	aPrintFile.Copy(tmpFile);

	LOG("[CPrintJob::GetPrintFileL]\t file created");
}


//--------------------------------------------------------------------------------------------
//
// CPrintJob::Sheets
//
//--------------------------------------------------------------------------------------------
TInt CPrintJob::Sheets()
{
	if(0 == iSheets)
	{
		TInt layout;
		TInt layoutNbr = 1;
		TInt imageNbr = 0;

		// We don't care about return value here: if GetPrintSetting
		// fails, we can anyway tell there will be at least an image/page
		GetPrintSetting(EPrintCapabLayout, layout);

		switch( layout )
		{
			case EPrintCapabLayout1Up:
			case EPrintCapabLayout1UpBorderless:
			case EPrintCapabLayout1UpBorder:
				layoutNbr = 1;
				break;
			case EPrintCapabLayout2Up:
				layoutNbr = 2;
				break;
			case EPrintCapabLayout4Up:
				layoutNbr = 4;
				break;
			case EPrintCapabLayout6Up:
				layoutNbr = 6;
				break;
			case EPrintCapabLayout9Up:
				layoutNbr = 9;
				break;
			case EPrintCapabLayout12Up:
				layoutNbr = 12;
				break;
			case EPrintCapabLayout16Up:
				layoutNbr = 16;
				break;
			default:
				break;
		}

		for (TInt i = 0; i<iImages.Count(); ++i)
		{
			imageNbr += iImages[i].Copies();
		}

		iSheets = imageNbr / layoutNbr;
		if(0 < imageNbr % layoutNbr)
		{
			++iSheets;
		}
	}
	LOG1("[CPrintJob::Sheets]\t iSheets = %d", iSheets);
	return iSheets;
}

// Protected functions
//--------------------------------------------------------------------------------------------
//
// CPrintJob::ConstructL
//
//--------------------------------------------------------------------------------------------
void CPrintJob::ConstructL(RArray<TFileName>& aImages, const TDesC8& aUserName)
{
	if (aImages.Count() < 1)
	{
		User::Leave(KErrArgument);
	}

	_LIT(KObex, "obex:");
	_LIT(KMmc, "\\mmc");
	_LIT(KLocal, "\\media");
	_LIT(KSlash, "/");
	_LIT(KBackSlash, "\\");
	
	// Initialize iImages array
	for (TInt i=0 ; i<aImages.Count(); i++)
	{
		// Skip empty strings
		if (aImages[i].Length() < 1)
		{
			continue;
		}

		aImages[i].LowerCase();
		
		CImageInfo imageInfo;
		imageInfo.SetId(KErrNotFound);
		imageInfo.SetIndex(i);
		imageInfo.SetCopies(1);	
		
		// Image file path
		imageInfo.SetFilePathL(aImages[i]);

		// Parse obex "uri"
		TFileName tmpUri;
		
		TParse parse;
		parse.Set(aImages[i], NULL, NULL);

		// Get drive id and root path when multiple drive is enabled.
		TInt driveId;
		TFileName localRoot;
		User::LeaveIfError(DriveInfo::GetDefaultDrive(DriveInfo::EDefaultPhoneMemory, driveId));
		User::LeaveIfError(PathInfo::GetRootPath(localRoot, driveId));

		localRoot.LowerCase();
		
		tmpUri.Copy(KObex());
		// Note here: the correct format would be uuid.LongForm(), 
		// but in currently supported services it is not required.
		tmpUri.AppendNum(KBTSDPDPROService, EHex);

		TFileName drive = parse.Drive();
		
		TInt pos = localRoot.Find(drive);
		if(KErrNotFound < pos)
		{
			tmpUri.Append(KLocal()); 
		}
		else
		{
			tmpUri.Append(KMmc());
		}
		tmpUri.Append(parse.Path());
		tmpUri.Append(parse.NameAndExt());

		pos = tmpUri.Find(KBackSlash());
		while(KErrNotFound != pos)
		{
			tmpUri.Replace(pos, KBackSlash().Length(), KSlash());
			pos = tmpUri.Find(KBackSlash());
		}

		LOG1("[CPrintJob::ConstructL]\t tmpUri: \"%S\"", &tmpUri);
		imageInfo.SetUriL(tmpUri);
//		LOG82("[CPrintJob::ConstructL]\t iFilePath: \"%S\", iUri: \"%S\"", &imageInfo.iFilePath, &imageInfo.iUri);

		iImages.Append(imageInfo);
	}

	iUserName.Copy(aUserName);
	iSheets = 0;
}


// Private functions
//--------------------------------------------------------------------------------------------
//
// CPrintJob::CPrintJob
//
//--------------------------------------------------------------------------------------------
CPrintJob::CPrintJob(CRsBtDevice* aDevice) :
	iJobId(KErrNotFound),
	iDeviceId(KErrNotFound),
	iDevice(aDevice),
	iUserName(KNullDesC8()),
	iSheets(0),
	iJobState(CPrintJob::EStateNone)
{
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::UpdateJobState
//
//--------------------------------------------------------------------------------------------
void CPrintJob::UpdateJobState(const TJobState aState)
{
	iJobState = aState;
}

//--------------------------------------------------------------------------------------------
//
// CPrintJob::JobState
//
//--------------------------------------------------------------------------------------------
CPrintJob::TJobState CPrintJob::JobState()
{
	return iJobState;
}

//--------------------------------------------------------------------------------------------
// CPrintJob::GetPrintSetting
//--------------------------------------------------------------------------------------------
TInt CPrintJob::GetPrintSetting(TInt aCapabilityID, TInt& aValue)
{
	if(Device())
	{
		for(TInt i = 0; i < Device()->CapabilityCount(); ++i)
		{
			TPrintCapability c;
			if(KErrNone == Device()->GetCapability(aCapabilityID, c) )
			{
				aValue = c.iDefaultValue;
				LOG2("[CPrintJob::GetPrintSetting]\t %d = %d", aCapabilityID, aValue);
				return KErrNone;
			}
		}
	}

	aValue = KErrNotFound;
	
	LOG("[CPrintJob::GetPrintSetting]\t out: KErrInvalidData");
	return KErrInvalidData;
}

//--------------------------------------------------------------------------------------------
// CPrintJob::SetPrintSetting
//--------------------------------------------------------------------------------------------
TInt CPrintJob::SetPrintSetting(TInt aCapabilityID, TInt aValue)
{
	LOG2("[CPrintJob::SetPrintSetting]\t %d = %d", aCapabilityID, aValue);

	if(Device())
		return Device()->SetDefaultCapability(aCapabilityID, aValue);
	
	LOG("[CPrintJob::GetPrintSetting]\t out: KErrInvalidData");
	return KErrInvalidSequence;
}

//  End of File