/*
* Copyright (c) 2010 Kanrikogaku Kenkyusho, Ltd.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
* Kanrikogaku Kenkyusho, Ltd. - Initial contribution
*
* Contributors:
*
* Description:
* {Description of the file}
*
*/

// User includes
#include "clog.h"
#include "DirectPrintApp.pan"
#include "DirectPrintBearerMgr.h"
#include "DirectPrintModel.h"
#include "directprintbearerdata.h"
#include "directprintprinterdata.h"

#include "directprintprintsettings.h"
#include "directprinttintcapability.h"
#include "directprintlistcapability.h"
#include "directprintfloatcapability.h"
#include "directprinttextcapability.h"
#include "directprintsettingsconverter.h"
#include "directprintcapability.h"

const TInt PROTOCOL_ID_BIT_COUNT = 6;

CDirectPrintBearerMgr::CDirectPrintBearerMgr(MDirectPrintBearerMngObserver* aObserver,
											 CDirectPrintModel& aModel)
	: CActive( CActive::EPriorityHigh )
	, iObserver(aObserver)
	, iModel(aModel)
	{
	LOG("CDirectPrintBearerMgr::CDirectPrintBearerMgr()");
	CActiveScheduler::Add(this);
	}

CDirectPrintBearerMgr::~CDirectPrintBearerMgr()
	{
	LOG("CDirectPrintBearerMgr::~CDirectPrintBearerMgr()");
	if (IsActive())
		{
		Cancel();
		}
	iBearer.Close();
	delete iPrintSettings;
	}

CDirectPrintBearerMgr* CDirectPrintBearerMgr::NewL(MDirectPrintBearerMngObserver* aObserver,
										CDirectPrintModel& aModel)
	{
	CDirectPrintBearerMgr* self = CDirectPrintBearerMgr::NewLC(aObserver, aModel);
	CleanupStack::Pop(self);
	return self;
	}

CDirectPrintBearerMgr* CDirectPrintBearerMgr::NewLC(MDirectPrintBearerMngObserver* aObserver,
										CDirectPrintModel& aModel)
	{
	CDirectPrintBearerMgr* self = new(ELeave) CDirectPrintBearerMgr(aObserver, aModel);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

void CDirectPrintBearerMgr::ConstructL()
	{
	LOG("CDirectPrintBearerMgr::ConstructL BEGIN");
	__ASSERT_ALWAYS(iObserver, Panic(EDirectPrintNoObserver));
	iPrintSettings = new ( ELeave ) CDirectPrintPrintSettings;
	iBearer.ConnectL();
	SetBearerStatus(EBearerMngConnected);
	LOG("CDirectPrintBearerMgr::ConstructL END");
	}

void CDirectPrintBearerMgr::CreateJobL()
	{
	LOG("CDirectPrintBearerMgr::CreateJobL BEGIN");
	RPointerArray<TDesC> cmdline;
	CleanupClosePushL(cmdline);

	_LIT(KDPAppName, "DirectPrint");
	cmdline.AppendL(&(KDPAppName()));

	TDirectPrintBearerData bearerData;
	TDirectPrintPrinterData printerData;
	TInt indexBearer = iModel.CurrentBearer();
	TInt indexPrinter = iModel.CurrentPrinter();
	if (indexBearer >= 0 && indexPrinter >= 0)
		{
		iModel.GetBearerDataL(indexBearer, bearerData);
		iModel.GetPrinterDataL(indexPrinter, printerData);
		}
	else
		{
		LOG("CDirectPrintBearerMgr::CreateJobL LEAVE1 KErrNotFound");
		User::Leave(KErrNotFound);
		}

	HBufC* apname = HBufC::NewLC(50);
	TPtr apnamePtr(apname->Des());
	_LIT(KDPApName, "-S%S");
	apnamePtr.AppendFormat(KDPApName(), &(bearerData.iHostName));
	cmdline.AppendL(apname);

	HBufC* printername = HBufC::NewLC(50);
	TPtr printernamePtr(printername->Des());
	_LIT(KDPPrinterName, "-P000000439163");
	printernamePtr.Copy(KDPPrinterName());
	cmdline.AppendL(printername);

	HBufC* filename = HBufC::NewLC(50);
	TPtr filenamePtr(filename->Des());
#ifdef __WINSCW__
		_LIT(KDPFileName, "c:\\fpr.pcl");
#else
//		_LIT(KDPFileName, "e:\\fpr.pcl");
		_LIT(KDPFileName, "c:\\fpr.pcl");
#endif
	filenamePtr.Copy(KDPFileName());
	cmdline.AppendL(filename);

	SetBearerStatus(EBearerMngCreatingJob);

	// bearer ID
	TInt printerID = 128;
	TInt err = iBearer.CreateJob(printerID, iJobGuardData,
						cmdline, iStatus);
	if( !err )
		{
		LOG("Start create JOB");
		SetActive();
		}
	else
		{
		LOG1("CDirectPrintBearerMgr::CreateJobL LEAVE2[%d]", err);
		User::Leave(err);
		}

	CleanupStack::PopAndDestroy(filename);
	CleanupStack::PopAndDestroy(printername);
	CleanupStack::PopAndDestroy(apname);
	CleanupStack::PopAndDestroy(&cmdline);
	LOG("CDirectPrintBearerMgr::CreateJobL END");
	}

void CDirectPrintBearerMgr::RunL()
	{
	LOG1("CDirectPrintBearerMgr::RunL begin with iStatus.Int(): %d", iStatus.Int());
	if( iStatus == KErrNone && iObserver )
		{
		switch( iJobGuardData.iCb )
			{
			case TDirectPrintJobGuardData::EProgressEventCb:
				LOG("CJobGuard::RunL TDirectPrintJobGuardData::EProgressEventCb");
				LOG1("CJobGuard::RunL iJobGuardData.iStatus: %d", iJobGuardData.iStatus);
				LOG1("CJobGuard::RunL iJobGuardData.iPercentCompletion: %d", iJobGuardData.iPercentCompletion);
				LOG1("CJobGuard::RunL iJobGuardData.iJobStateCode: %d", iJobGuardData.iJobStateCode);
				iObserver->PrintJobProgressEvent( iJobGuardData.iStatus, iJobGuardData.iPercentCompletion, iJobGuardData.iJobStateCode );
				break;
			case TDirectPrintJobGuardData::EErrorEventCb:
				LOG("CJobGuard::RunL TDirectPrintJobGuardData::EErrorEventCb");
				LOG1("CJobGuard::RunL iJobGuardData.iError: %d", iJobGuardData.iError);
				LOG1("CJobGuard::RunL iJobGuardData.iErrorStringCode: %d", iJobGuardData.iErrorStringCode);
				iObserver->PrintJobErrorEvent( iJobGuardData.iError, iJobGuardData.iErrorStringCode );
				break;
			case TDirectPrintJobGuardData::EStatusEventCb:
				LOG("CJobGuard::RunL TDirectPrintJobGuardData::EStatusEventCb");
				LOG1("CJobGuard::RunL iJobGuardData.iError: %d", iJobGuardData.iError);
				LOG1("CJobGuard::RunL iJobGuardData.iErrorStringCode: %d", iJobGuardData.iErrorStringCode);
				iObserver->PrintJobErrorEvent( iJobGuardData.iError, iJobGuardData.iErrorStringCode );
				break;
			case TDirectPrintJobGuardData::EImageEventCb:
				LOG("CJobGuard::RunL TDirectPrintJobGuardData::EImageEventCb");
				LOG1("CJobGuard::RunL iJobGuardData.iFsBitmapHandle: %d", iJobGuardData.iFsBitmapHandle);
				iObserver->PreviewImageEvent( iJobGuardData.iFsBitmapHandle );
				break;
			default:
				break;
			}

		LOG1("CDirectPrintBearerMgr::RunL BearerStatus=[%d]", iBearerStatus);

		switch (iBearerStatus)
			{
			case EBearerMngNotConnected:
			case EBearerMngConnected:
			case EBearerMngCreatingJob:
			case EBearerMngPrinting:
				{
				LOG("CDirectPrintBearerMgr::RunL ContinueCreateJob");
				iBearer.ContinueCreateJob( iJobGuardData, iStatus );
				SetActive();
				}
				break;
			case EBearerMngClosing:
			case EBearerMngCanceling:
			default:
				break;
			}

		}
	LOG("CDirectPrintBearerMgr::RunL end");
	}

void CDirectPrintBearerMgr::SubmitPrintJobL()
	{
	LOG("CDirectPrintBearerMgr::SubmitPrintJobL BEGIN");
	SetBearerStatus(EBearerMngPrinting);
	// Submit print job
	TInt err = iBearer.SubmitPrintJob();
	if( err != KErrNone )
		{
		User::Leave(err);
		}
	LOG("CDirectPrintBearerMgr::SubmitPrintJobL END");
	}

void CDirectPrintBearerMgr::CloseSession()
	{
	LOG("CDirectPrintBearerMgr::CloseSession BEGIN");
	SetBearerStatus(EBearerMngClosing);
	Cancel();
//	iBearer.Close();
	SetBearerStatus(EBearerMngConnected);
	LOG("CDirectPrintBearerMgr::CloseSession END");
	}

void CDirectPrintBearerMgr::DoCancel()
	{
	LOG("CDirectPrintBearerMgr::DoCancel BEGIN");
	SetBearerStatus(EBearerMngCanceling);
	iBearer.CancelCreateJob();
	LOG("CDirectPrintBearerMgr::DoCancel END");
	}

void CDirectPrintBearerMgr::SetBearerStatus(TBearerMngStatus aStatus)
	{
	LOG1("CDirectPrintBearerMgr::SetBearerStatus [%d]", aStatus);
	iBearerStatus = aStatus;
	}

CDirectPrintBearerMgr::TBearerMngStatus CDirectPrintBearerMgr::BearerStatus()
	{
	return iBearerStatus;
	}

TInt CDirectPrintBearerMgr::SupportedProtocols()
	{
	return iBearer.SupportedProtocols();
	}

TInt CDirectPrintBearerMgr::GetProtocolNames(RSelectItemArray& aNames)
	{
	return iBearer.GetProtocolNames(aNames);
	}

void CDirectPrintBearerMgr::InitCapabilitiesL(TInt aIndex)
	{
	TInt printerUid = CreatePrinterUid(aIndex);

	RArray<TInt> capabIDs;
	CleanupClosePushL( capabIDs );

	iBearer.GetPrinterCapabilityIDs( printerUid, capabIDs );
	CDirectPrintPrintSettings* printSettings = new ( ELeave ) CDirectPrintPrintSettings;
	CleanupStack::PushL( printSettings );

	TInt i( 0 );
	TInt num( capabIDs.Count() );
	for ( i = 0; i < num; i++ )
		{
		TDirectPrintCapability capab;
		iBearer.GetPrinterCapability( printerUid, capabIDs[i], capab );
		//capab.iType = TDirectPrintCapability::Enum;

		CDirectPrintBaseCapability* capability = 0;

		// Create capability
		switch ( capab.iType )
			{
			case TDirectPrintCapability::Int:
				capability = DirectPrintSettingsConverter::AddTIntCapabilityLC( capab, i, capabIDs[i] );
				break;
			case TDirectPrintCapability::Enum:
				capability = DirectPrintSettingsConverter::AddListCapabilityLC( capab, i, capabIDs[i] );
				break;
			case TDirectPrintCapability::Float:
				capability = DirectPrintSettingsConverter::AddFloatCapabilityLC( capab, i, capabIDs[i] );
				break;
			case TDirectPrintCapability::Text:
				capability = DirectPrintSettingsConverter::AddTextCapabilityLC( capab, i, capabIDs[i] );
				break;
			default:
				User::Leave( KErrUnknown );
				break;
			}
		//iBearer.GetJobSetting( capabIDs[i], capability->iValue );

		// Add the capability to the list
		User::LeaveIfError( printSettings->iCapabilities.Append( capability ) );
		CleanupStack::Pop();    // capability
		}

	delete iPrintSettings;
	iPrintSettings = printSettings;

	CleanupStack::Pop();    // printSettings
	CleanupStack::PopAndDestroy();  // capabIDs
	}

TInt CDirectPrintBearerMgr::GetJobSetting(TInt aCapabilityID, TInt& aValue)
	{
	return iBearer.GetJobSetting(aCapabilityID, aValue);
	}

TInt CDirectPrintBearerMgr::SetJobSetting(TInt aCapabilityID, TInt aValue, TInt& aAffectedCapability)
	{
	return iBearer.SetJobSetting(aCapabilityID, aValue, aAffectedCapability);
	}

void CDirectPrintBearerMgr::SetJobSettings()
	{
	TInt i( 0 );
	TInt num( iPrintSettings->iCapabilities.Count() );
	for ( i = 0; i < num; i++ )
		{
		TInt getSettings;
		iBearer.SetJobSetting(iPrintSettings->iCapabilities[i]->iUid, iPrintSettings->iCapabilities[i]->iValue, getSettings);
		}
	}

CDirectPrintPrintSettings* CDirectPrintBearerMgr::PrinterSettingsL()
	{
	//return iPrintSettings->CloneL();
	return iPrintSettings;
	}

TInt CDirectPrintBearerMgr::CreatePrinterUid(TInt aIndex)
	{
	TInt printerUid = 0;
	TInt protocolIndex = aIndex;
	protocolIndex <<= sizeof(TInt)*8 - PROTOCOL_ID_BIT_COUNT;
	printerUid |= protocolIndex;
	return printerUid;
	}

// End of file