/*

* 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:  Defines the CBtSoapCodec class to create and read SOAP-encoded messages.

*

*/

#include "cxmlhandler.h"

#include "cbtsoapcodec.h"

#include "imageprint.h"

#include "clog.h"

#include "tbtmapper.h"

#include "rsutils.h"

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

//

// CBtSoapCodec::NewL

//

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

CBtSoapCodec* CBtSoapCodec::NewL()

	{

		CBtSoapCodec *self = NewLC();

		CleanupStack::Pop();	// self

		return self;

	}

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

//

// CBtSoapCodec::NewLC

//

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

CBtSoapCodec* CBtSoapCodec::NewLC()

	{

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

		CleanupStack::PushL(self);

		self->ConstructL();

		return self;

	}

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

//

// CBtSoapCodec::~CBtSoapCodec

//

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

CBtSoapCodec::~CBtSoapCodec()

{

	if(iXmlHandler)

		delete iXmlHandler;

	iXmlHandler = NULL;

	if(iActionBuffer)

		delete iActionBuffer;

	iActionBuffer = NULL;

}

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

//

// CBtSoapCodec::ConstructL

//

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

void CBtSoapCodec::ConstructL()

{

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

	iXmlHandler = CXmlHandler::NewL();

}

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

//

// CBtSoapCodec::Reset

//

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

void CBtSoapCodec::Reset()

{

	LOG("[CBtSoapCodec::Reset]\t");

	if(iXmlHandler)

		delete iXmlHandler;

	iXmlHandler = NULL;

	if(iActionBuffer)

		delete iActionBuffer;

	iActionBuffer = NULL;

}

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

//

// CBtSoapCodec::CreateSoapL

//

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

TPtrC8 CBtSoapCodec::CreateSoapL(const TInt aAction, const TInt aJobId)

{

	LOG1("[CBtSoapCodec::CreateSoapL]\t action: %d", aAction);

	// Open the template file and read it into buffer

	TPtrC8 soap(KNullDesC8);

	TBtIntString8 jobId;

	jobId.AppendNum(aJobId);

	if(iActionBuffer)

		delete iActionBuffer;

	iActionBuffer = NULL;

	switch(aAction)

	{

		case EBtCreateJob:

			CreateJobSoapL(aJobId);

			break;

		case EBtGetPrinterAttributes:

			GetPrinterAttributesSoapL();

			break;

		case EBtGetPrinterState:

			GetPrinterStateSoapL();

			break;

		case EBtGetPrinterCapabilities:

			GetCapabilitiesSoapL();

			break;

		case EBtCancelJob:

			CancelJobSoapL(jobId);

			break;

		case EBtGetJobAttributes:

			GetJobAttributesSoapL(jobId);

			break;

		case EBtGetEvent:

			GetEventSoapL(jobId);

			break;

		default:

			break;

	}

	TInt offset;

	TPtrC8 ptr = iXmlHandler->GetDataL(KBtBodyStartTag, KBtBodyEndTag, offset);

	iXmlHandler->ComposeDataL(ptr.Length(), KBtBytesInBody());

	return iXmlHandler->FinalizeBufferL(KBtEnvelopeEndTag());

}

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

//

// CBtSoapCodec::ReadSoapL

//

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

void CBtSoapCodec::ReadSoapL(const TDesC8& aSoapBuffer)

{

	LOG("[CBtSoapCodec::ReadSoapL(TDesC8&)]\t ");

	// Open the template file and read it into buffer

	TInt action = 0;

	ReadSoapL(action, aSoapBuffer);

}

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

//

// CBtSoapCodec::ReadSoapL

//

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

void CBtSoapCodec::ReadSoapL(const CBufBase& aSoapBuffer)

{

	LOG("[CBtSoapCodec::ReadSoapL(CBufBase&)]\t ");

	// Open the template file and read it into buffer

	TInt action = 0;

	ReadSoapL(action, aSoapBuffer);

}

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

//

// CBtSoapCodec::ReadSoapL

//

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

void CBtSoapCodec::ReadSoapL(TInt& aAction, const CBufBase& aSoapBuffer)

{

	LOG("[CBtSoapCodec::ReadSoapL(TInt&, CBufBase&)]\t ");

	// Open the template file and read it into buffer

	if(iActionBuffer)

		delete iActionBuffer;

	iActionBuffer = NULL;

	iActionBuffer = static_cast<HBufC8*>(User::LeaveIfNull(HBufC8::NewL(aSoapBuffer.Size())));

	TPtr8 ptr = iActionBuffer->Des();

	aSoapBuffer.Read(0, ptr, aSoapBuffer.Size());

	ReadSoapL(aAction, iActionBuffer->Des());

}

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

//

// CBtSoapCodec::ReadSoapL

//

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

void CBtSoapCodec::ReadSoapL(TInt& aAction, const TDesC8& aSoapBuffer)

{

	LOG("[CBtSoapCodec::ReadSoapL(TInt&, TDesC8&)]\t ");

	// Open the template file and read it into buffer

#ifdef _DEBUG	

	TInt len = aSoapBuffer.Length() < 50 ? aSoapBuffer.Length() : 50;

	TPtrC8 p = aSoapBuffer.Mid(0, len);

#endif

	if(!iXmlHandler)

		iXmlHandler = CXmlHandler::NewL();

	iXmlHandler->InitFromBufferL(aSoapBuffer);

	if(iActionBuffer)

		delete iActionBuffer;

	iActionBuffer = NULL;

	TInt offset = 0;

	TPtrC8 ptr = iXmlHandler->GetDataL(KBtBodyStartTag, KBtBodyEndTag, offset);

	iActionBuffer = static_cast<HBufC8*>(User::LeaveIfNull(ptr.AllocL()));

	aAction = SoapAction();

	iXmlHandler->Reset();

	iXmlHandler->InitFromBufferL(iActionBuffer->Des(), aAction);

}

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

// Responses

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

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

//

// CBtSoapCodec::CreateJobResponseL

//

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

void CBtSoapCodec::CreateJobResponseL(TInt& aJobId, TInt& aErrorCode)

{

	LOG("[CBtSoapCodec::CreateJobResponseL]\t ");

	if(EBtCreateJobResponse != SoapAction())

	{

		User::Leave(KErrInvalidSequence);

	}

	TBtIntString8 jobId;

	jobId.Zero();

	TInt status = OperationStatusL();

	aErrorCode = KErrNotFound;

	GetAttributeL(KBtJobId(), jobId, aErrorCode);

	LOG82("[CBtSoapCodec::CreateJobResponseL]\t %S: %S",&KBtJobId(), &jobId);

	LOG2("[CBtSoapCodec::CreateJobResponseL]\t opStatus: %d, err %d",status, aErrorCode);

	if(aErrorCode == KErrNone)

		aErrorCode = status;

	aJobId = TBtMapper::Int(jobId);

}

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

//

// CBtSoapCodec::GetPrinterAttributesResponseL

//

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

void CBtSoapCodec::GetPrinterAttributesResponseL(TInt& aState, TInt& aStateReasons,

								 			   RArray<TPrintCapability>& aCapabilities,

								 			   TInt& aOperationStatus)

{

	LOG("[CBtSoapCodec::GetPrinterAttributesResponseL]\t");

	// same operationStatus got twce but no matter.

	GetPrinterStateResponseL(aState, aStateReasons, aOperationStatus);

	GetPrinterCapabilitiesResponseL(aCapabilities, aOperationStatus);

}

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

//

// CBtSoapCodec::GetPrinterStateResponseL

//

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

void CBtSoapCodec::GetPrinterStateResponseL(TInt& aState, TInt& aStateReasons, TInt& aOperationStatus)

{

	LOG("[CBtSoapCodec::GetPrinterStateResponseL]\t");

	if(EBtGetPrinterAttributesResponse != SoapAction())

	{

		User::Leave(KErrInvalidSequence);

	}

	aState = EBtStateUnknown;

	aStateReasons = EPbCheckPrinter;

	aOperationStatus = OperationStatusL();

	/*get attribute*/

	TBtAttrString8 value(KNullDesC8());

	/* Get printer status and reason */

	TInt err = KErrNotFound;

	GetAttributeL(KBtPrinterState(), value, err);

	LOG82("[CBtSoapCodec::GetPrinterStateResponseL]\t ** %S: %S",&KBtPrinterState(), &value);

	if(KErrNone == err)

	{

		aState = TBtMapper::State(value);

		GetAttributeL(KBtPrinterStateReasons(), value, err);

		LOG82("[CBtSoapCodec::GetPrinterStateResponseL]\t ** %S: %S",&KBtPrinterStateReasons(), &value);

		if(KErrNone == err)

		{

			aStateReasons = TBtMapper::PrintError(value);

		}

	}

}

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

//

// CBtSoapCodec::GetCapabilitiesResponseL

//

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

void CBtSoapCodec::GetPrinterCapabilitiesResponseL(RArray<TPrintCapability>& aCapabilities,

								 			   TInt& aOperationStatus)

{

	LOG("[CBtSoapCodec::GetPrinterCapabilitiesResponseL]\t");

	if(EBtGetPrinterAttributesResponse != SoapAction())

	{

		User::Leave(KErrInvalidSequence);

	}

	aOperationStatus = OperationStatusL();

	aCapabilities.Reset();

	aCapabilities.Append(ParseLayoutL());

	aCapabilities.Append(ParseQualityL());

	aCapabilities.Append(ParsePaperSizeL());

}

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

//

// CBtSoapCodec::GetJobAttributesResponseL

//

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

void CBtSoapCodec::GetJobAttributesResponseL(const TInt aJobId, TInt& aJobState, TBtAttrString8& aJobName,

										   TBtAttrString8& aOriginator, TInt& aSheetsCompleted, 

										   TInt& aPendingJobs, TInt& aErrorCode )

{

	LOG("[CBtSoapCodec::GetJobAttributesResponseL]\t");

	if(EBtGetJobAttributesResponse != SoapAction())

	{

		User::Leave(KErrInvalidSequence);

	}

	aJobState = EBtStateUnknown;

	aJobName = KNullDesC8();

	aOriginator = KNullDesC8();

	aSheetsCompleted = KErrNotFound;

	aPendingJobs = KErrNotFound;

	aErrorCode = KErrNotFound;

	TBtAttrString8 value(KNullDesC8());

	TInt status = OperationStatusL();

	GetAttributeL(KBtJobId(), value, aErrorCode);

	LOG82("[CBtSoapCodec::GetJobAttributesResponseL]\t %S: %S",&KBtJobId(), &value);

	LOG2("[CBtSoapCodec::GetJobAttributesResponseL]\t opStatus: %d, err %d",status, aErrorCode);

	if(aErrorCode == KErrNone)

	{

		if(	TBtMapper::Int(value) != aJobId)

			aErrorCode = KErrArgument;

		else

			aErrorCode = status;

	}

	// then just get the rest of the arguments. Success or fails, just continue.

	GetAttributeL(KBtJobState(), value, status);

	if(KErrNone == status)

		aJobState = TBtMapper::State(value);

	else

	{

		LOG82("[CBtSoapCodec::GetJobAttributesResponseL]\t %S: %S",&KBtJobState(), &value);

		LOG1("[CBtSoapCodec::GetJobAttributesResponseL]\t err %d",status);

	}

	GetAttributeL(KBtJobMediaSheetsCompleted(), value, status);

	if(KErrNone == status)

		aSheetsCompleted = TBtMapper::Int(value);

	else

	{

		LOG82("[CBtSoapCodec::GetJobAttributesResponseL]\t %S: %S",&KBtJobMediaSheetsCompleted(), &value);

		LOG1("[CBtSoapCodec::GetJobAttributesResponseL]\t err %d",status);

	}

	GetAttributeL(KBtJobPending(), value, status);

	if(KErrNone == status)

		aPendingJobs = TBtMapper::Int(value);

	else

	{

		LOG82("[CBtSoapCodec::GetJobAttributesResponseL]\t %S: %S",&KBtJobPending(), &value);

		LOG1("[CBtSoapCodec::GetJobAttributesResponseL]\t err %d",status);

	}

	GetAttributeL(KBtJobName(), aJobName, status);

	if(KErrNone != status)

	{

		LOG82("[CBtSoapCodec::GetJobAttributesResponseL]\t %S: %S",&KBtJobName(), &aJobName);

		LOG1("[CBtSoapCodec::GetJobAttributesResponseL]\t err %d",status);

	}

	GetAttributeL(KBtJobOriginatingUserName(), aOriginator, status);

	if(KErrNone != status)

	{

		LOG82("[CBtSoapCodec::GetJobAttributesResponseL]\t %S: %S",&KBtJobOriginatingUserName(), &aOriginator);

		LOG1("[CBtSoapCodec::GetJobAttributesResponseL]\t err %d",status);

	}

}

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

//

// CBtSoapCodec::CancelJobResponseL

//

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

void CBtSoapCodec::CancelJobResponseL(const TInt aJobId, TInt& aErrorCode)

{

	LOG("[CBtSoapCodec::CancelJobResponseL]\t");

	TBtIntString8 jobId;

	jobId.Append(aJobId);

	if(EBtCancelJobResponse != SoapAction())

	{

		User::Leave(KErrInvalidSequence);

	}

	TBuf8<KDefaultRealWidth> respJobId;

	TInt status = OperationStatusL();

	aErrorCode = KErrNotFound;

	GetAttributeL(KBtJobId(), respJobId, aErrorCode);

	LOG82("[CBtSoapCodec::CancelJobResponseL]\t %S: %S",&KBtJobId(), &respJobId);

	LOG2("[CBtSoapCodec::CancelJobResponseL]\t opStatus: %d, err %d",status, aErrorCode);

	if(aErrorCode == KErrNone)

	{

		if(TBtMapper::Int(respJobId) != aJobId)

			aErrorCode = KErrArgument;

		else

			aErrorCode = status;

	}

}

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

//

// CBtSoapCodec::GetEventResponseL

//

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

void CBtSoapCodec::GetEventResponseL(const TInt aJobId,

											  TInt& aJobState,

											  TInt& aPrinterState,

											  TInt& aStateReasons,

											  TInt& aErrorCode)

{

	LOG("[CBtSoapCodec::GetEventResponseL]\t");

	if(EBtGetEventResponse != SoapAction())

	{

		User::Leave(KErrInvalidSequence);

	}

	aJobState = EBtStateUnknown;

	aPrinterState = KErrNotFound;

	aStateReasons = KErrNotFound;

	aErrorCode = KErrNotSupported;

	TBtAttrString8 value(KNullDesC8());

	TInt status = OperationStatusL();

	GetAttributeL(KBtJobId(), value, aErrorCode);

	LOG82("[CBtSoapCodec::GetEventResponseL]\t %S: %S",&KBtJobId(), &value);

	LOG2("[CBtSoapCodec::GetEventResponseL]\t opStatus: %d, err %d",status, aErrorCode);

	if(aErrorCode == KErrNone)

	{

		if(TBtMapper::Int(value) != aJobId)

			aErrorCode = KErrArgument;

		else

			aErrorCode = status;

	}

	// then just get the rest of the arguments. Success or fails, just continue.

	GetAttributeL(KBtJobState(), value, status);

	LOG82("[CBtSoapCodec::GetEventResponseL]\t %S: %S",&KBtJobState(), &value);

	LOG1("[CBtSoapCodec::GetEventResponseL]\t err %d",status);

	if(KErrNone == status)

		aJobState = TBtMapper::Int(value);

	GetAttributeL(KBtPrinterState(), value, status);

	LOG82("[CBtSoapCodec::GetEventResponseL]\t %S: %S",&KBtPrinterState(), &value);

	LOG1("[CBtSoapCodec::GetEventResponseL]\t err %d",status);

	if(KErrNone == status)

		aPrinterState = TBtMapper::Int(value);

	GetAttributeL(KBtPrinterStateReasons(), value, status);

	LOG82("[CBtSoapCodec::GetEventResponseL]\t %S: %S",&KBtPrinterStateReasons(), &value);

	LOG1("[CBtSoapCodec::GetEventResponseL]\t err %d",status);

	if(KErrNone == status)

		aStateReasons = TBtMapper::Int(value);

}

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

//

// CBtSoapCodec::OperationStatusL

//

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

TInt CBtSoapCodec::OperationStatusL()

{

	LOG("[CBtSoapCodec::GetOperationStatus]\t");

	/* Get operation status. If NOK or not found, no reason to continue */

	TBtAttrString8 value(KNullDesC8());

	TInt status = KErrNotFound;

	GetAttributeL(KBtOperationStatus(), value, status);

	LOG82("[CBtSoapCodec::GetOperationStatus]\t %S: %S",&KBtOperationStatus(), &value);