/*

* 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 CUPJobState class

*

*/

#include <e32math.h>

#include "cupjobstate.h"

#include "upconsts.h"

#include "cupprintingjob.h"

#include "cuplogger.h"

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

//

// CUPJobState::NewL

//

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

CUPJobState* CUPJobState::NewL()

	{

		CUPJobState *self = NewLC();

		CleanupStack::Pop();	// self

		return self;

	}

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

//

// CUPJobState::NewLC

//

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

CUPJobState* CUPJobState::NewLC()

{

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

		CleanupStack::PushL(self);

		self->ConstructL();

		return self;

}

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

//

// CUPJobState::ConstructL

//

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

void CUPJobState::ConstructL()

{

	LOG("[CUPFileParser]\t ConstructL");

	Init();

	InitErrorValues();

}

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

//

// CUPJobState::CUPJobState

//

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

CUPJobState::~CUPJobState()

{

	Init();

	iErrorValues.Reset();

}

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

//

// CUPJobState::Init

//

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

void CUPJobState::Init()

{

	iSheetsCompleted = KErrNotFound;

	iSheetsToPrint = 0; // cannot be negative for progress

	iId.Copy(KNullDesC8());

	iReason = ENoMessage;

	iState = EStateUnknown;

	iActiveId.Copy(KNullDesC8());

	iEndState.Init();

}

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

//

// CUPJobState::InitErrorValues

//

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

void CUPJobState::InitErrorValues()

{

	TMapError err;

	err.iErrorCode = ENoMessage;

	err.iErrorString.Set(KUPnPStateNone);

	iErrorValues.Append(err);

	err.iErrorCode = EPbCheckPrinter;

	err.iErrorString.Set(KUPnPStateAttentionRequired);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonPaperJam;

	err.iErrorString.Set(KUPnPStateMediaJam);

	iErrorValues.Append(err);

	err.iErrorCode = EPbCheckPrinter;

	err.iErrorString.Set(KUPnPStatePaused);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonHardwareCoverOpen;

	err.iErrorString.Set(KUPnPStateDoorOpen);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonPaperNearlyEmpty;

	err.iErrorString.Set(KUPnPStateMediaLow);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonPaperEmpty;

	err.iErrorString.Set(KUPnPStateMediaEmpty);

	iErrorValues.Append(err);

	err.iErrorCode = ENoMessage;

	err.iErrorString.Set(KUPnPStateOutputAreaAlmostFull);

	iErrorValues.Append(err);

	err.iErrorCode = EPbCheckPrinter;

	err.iErrorString.Set(KUPnPStateOutputAreaFull);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonInkLow;

	err.iErrorString.Set(KUPnPStateMarkerSupplyLow);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonInkEmpty;

	err.iErrorString.Set(KUPnPStateMarkerSupplyEmpty);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonInk;

	err.iErrorString.Set(KUPnPStateMarkerFailure);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonPaperMedia;

	err.iErrorString.Set(KUPnPStateMediaChangeRequest);

	iErrorValues.Append(err);

	err.iErrorCode = EPbCheckPrinter;

	err.iErrorString.Set(KUPnPStateVendorDefined);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateCopies);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateSides);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateNumberUp);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateOrientationRequested);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateMediaSize);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateMediaType);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStatePrintQuality);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateTextLayout);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateImageLayout);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateImageOrientation);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStatePdlFidelity);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateFontFamily);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateFontSize);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateFormatError);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateHttpError);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonHardware;

	err.iErrorString.Set(KUPnPJobStateHwError);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateObjectFailure);

	iErrorValues.Append(err);

	err.iErrorCode = EPbStatusErrorReasonFile;

	err.iErrorString.Set(KUPnPJobStateUriNotFound);

	iErrorValues.Append(err);

}

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

//

// CUPJobState::GetErrorValue

//

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

TInt CUPJobState::GetErrorValue(const TDesC8& aError)

{

	LOG81("[CUPJobState::GetErrorValue]\t  for: %S", &aError);

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

	{

		if(0 == aError.Compare(iErrorValues[i].iErrorString))

		{

//			LOG1("[CUPJobState::GetErrorValue]\t returns: %d", iErrorValues[i].iErrorCode);

			return iErrorValues[i].iErrorCode;

		}

	}

//	LOG("[CUPJobState::GetErrorValue]\t returns: EPbCheckPrinter");

	return EPbCheckPrinter;

}

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

//

// CUPJobState::SetState

//

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

void CUPJobState::SetState(TUPnPState aState)

{

	LOG1("[CUPJobState::SetState]\t %d", aState);

	if(iActiveId.Length() < 1)

	{

		iState = EStateUnknown;

		return;

	}

	// return if state is one of the terminating states

	if(	EStateReady == iState ||	

		EPrinterStateStopped == iState ||

		EStatePending == iState ||

		EJobStateAborted == iState ||

		EJobStateCanceled == iState )

		return;

	switch ( aState )

	{

		case EPrinterStateStopped:

		case EStatePending:

		case EJobStateAborted:

		case EJobStateCanceled:

		case EStateReady:

			Init();

			iState = aState;

			break;

		case EStatePrinting:

			iState = aState;

			break;

		case EJobStateSuccessful:

			iState = EStatePrinting;

			break;

		default:

			if(0 == iId.Compare(ActiveId()))

			{

				if(SheetsToPrint() == SheetsCompleted())

					iState = EStateReady;

				else if (EStateUnknown == iState)

					iState = EStatePrinting;

			}

			break;

	}

}

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

//

// CUPJobState::State

//

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

TUPnPState CUPJobState::State()

{

//	LOG1("[CUPJobState::State]\t : %d",iState);

	return iState;

}

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

//

// CUPJobState::SetActiveId

//

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

void CUPJobState::SetActiveId(const TDesC8& aId)

{

	Init();

	iActiveId.Copy(aId);

}

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

//

// CUPJobState::ActiveId

//

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

TPtrC8 CUPJobState::ActiveId()

{

	return iActiveId;

}

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

//

// CUPJobState::SetSheetsCompleted

//

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

void CUPJobState::SetSheetsCompleted(const TDesC8& aSheetsCompleted)

{

//	LOG1("[CUPJobState::SetSheetsCompleted]\t - at the beginning SheetsCompleted(): %d",SheetsCompleted());

//	LOG8S("[CUPJobState::SetSheetsCompleted]\t - aSheetsCompleted: ",aSheetsCompleted);

	if(EStateReady == State())

	{

		iSheetsCompleted = SheetsToPrint();

		LOG1("[CUPJobState::SetSheetsCompleted]\t - State ready, set SheetsToPrint(): %d",SheetsToPrint());

	}

	else

	{

		TLex8 sheetsLex(aSheetsCompleted);

		//Should here be an check about return value of Val??? /TTP

		sheetsLex.Val(iSheetsCompleted);

	}

	LOG1("[CUPJobState::SetSheetsCompleted]\t - iSheetsCompleted: %d",SheetsCompleted());

}

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

//

// CUPJobState::SheetsCompleted

//

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

TInt CUPJobState::SheetsCompleted()

{

	return iSheetsCompleted;

}

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

//

// CUPJobState::SetReason

//

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

void CUPJobState::SetReason(TInt aReason)

{

	iReason = aReason;

}

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

//

// CUPJobState::Reason

//

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

TInt CUPJobState::Reason()

{

	return iReason;

}

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

//

// CUPJobState::SetJobList

//

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

TUPnPState CUPJobState::SetJobList(const TDesC8& aJobIdList)

{

	TInt pos = PendingJobId(aJobIdList);

	if(1 < pos)

		SetState(EStatePending);

	else if (1 == pos)

	{

		iId = ActiveId();

		SetState(EStatePrinting);

	}

	return State();

}

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

//

// CUPJobState::SetSheetsToPrint

//

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

void CUPJobState::SetSheetsToPrint(TInt aSheets)

{

	LOG1("[CUPJobState::SetSheetsToPrint]\t aSheets\t = %d", aSheets);

	if(0 < aSheets)

		iSheetsToPrint = aSheets;

}

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

//

// CUPJobState::SheetsToPrint

//

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

TInt CUPJobState::SheetsToPrint()

{

//	LOG1("[CUPJobState::SheetsToPrint]\t iSheetsToPrint\t = %d", iSheetsToPrint);

	return iSheetsToPrint;

}

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

//

// CUPJobState::Progress

//

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

TInt CUPJobState::Progress(TInt aSheets)

{

	TInt percentage = 0;

	if(State() == EStateReady)

		percentage = 100;

	else if(0 < SheetsCompleted() && 0 < aSheets)

		percentage = (((SheetsCompleted() << 8) / aSheets) * 100) >> 8;

//	LOG1("[CUPJobState::Progress]\t SheetsCompleted()\t = %d", SheetsCompleted());

//	LOG1("[CUPJobState::Progress]\t aSheets\t\t\t = %d", aSheets);

	LOG1("[CUPJobState::Progress]\t percentage\t\t\t = %d%%", percentage);

	return percentage;

}

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

//

// CUPJobState::Progress

//

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

TInt CUPJobState::Progress()

{

	return Progress(SheetsToPrint());

}

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

//

// CUPJobState::UpdateJobState

//

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

TUPnPState CUPJobState::UpdateJobState(const TDesC8& aPrinterState, const TDesC8& aReason, const TDesC8& aJobList, const TDesC8& aJobId, const TDesC8& aSheetsCompleted)

{

	LOG81("[CUPJobState::UpdateJobState]\t active job: %S", &(ActiveId()));

	LOG81("[CUPJobState]\t - aPrinterState: %S", &aPrinterState);

	LOG81("[CUPJobState]\t - aReason: %S", &aReason);

	LOG81("[CUPJobState]\t - aJobList: %S", &aJobList);

	LOG81("[CUPJobState]\t - aJobId: %S", &aJobId);

	LOG81("[CUPJobState]\t - aSheetsCompleted: %S", &aSheetsCompleted);

	SetReason(GetErrorValue(aReason));

	//Set sheets for progress

	SetSheetsCompleted(aSheetsCompleted);

	// If printer state stopped, no reason to continue

	if(KErrNotFound != aPrinterState.Find(KUPnPPrinterStateStopped()))

	{

		SetState(EPrinterStateStopped);

		return State();

	}

	// If job is in the list, state is printing or pending. Else the job does not exist.

	SetJobList(aJobList);

	if(EStatePending == State())

	{

		SetReason(EPbStatusErrorReasonHardwarePrinterBusy);

	}

	else if(State() == EStatePrinting  && aJobId.Compare(ActiveId()) != 0 )

	{

		LOG82("[CUPJobState::State]\t - Ready: iState: %d, aJobId; %S",iState, &aJobId);

		SetState(EStateReady);

	}

	return State();

}

//// PRIVATE ///

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

//

// CUPJobState::CUPJobState

//

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

CUPJobState::CUPJobState()

{

}

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

//

// CUPJobState::PendingJobId

//

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

TInt CUPJobState::PendingJobId(const TDesC8& aJobIdList)

{

	if(0 >= aJobIdList.Length())

		return KErrNotFound;

	TInt count = 0;

	TLex8 list(aJobIdList);

	TLex8 idLex(ActiveId());