/*
* Copyright (c) 2006, 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:  This class parses the dps xml script. 
*
*/


#include "dpsxmlparser.h"
#include "dpsconst.h"
#include "pictbridge.h"
#include "dpsxmlstring.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "dpsxmlparserTraces.h"
#endif


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CDpsXmlParser* CDpsXmlParser::NewL(CDpsEngine* aEngine)
	{
    CDpsXmlParser* self = new (ELeave) CDpsXmlParser(aEngine);
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
CDpsXmlParser::~CDpsXmlParser()
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_CDPSXMLPARSER_DES_ENTRY );
    iDpsArgs.Close();
    OstTraceFunctionExit0( CDPSXMLPARSER_CDPSXMLPARSER_DES_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
CDpsXmlParser::CDpsXmlParser(CDpsEngine* aEngine) : iEngine(aEngine)
    {
    OstTraceFunctionEntry0( DUP1_CDPSXMLPARSER_CDPSXMLPARSER_CONS_ENTRY );
	Reset();
	OstTraceFunctionExit0( DUP1_CDPSXMLPARSER_CDPSXMLPARSER_CONS_EXIT );
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CDpsXmlParser::OnStartDocumentL(
		const RDocumentParameters& /*aDocParam*/, TInt aErrorCode)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONSTARTDOCUMENTL_ENTRY );
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONSTARTDOCUMENTL, "---, error code is %d", aErrorCode );
        User::Leave(aErrorCode);
        }
	OstTraceFunctionExit0( CDPSXMLPARSER_ONSTARTDOCUMENTL_EXIT );
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CDpsXmlParser::OnEndDocumentL(TInt aErrorCode)
	{
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONENDDOCUMENTL_ENTRY );
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONENDDOCUMENTL, "---, error code is %d", aErrorCode );
        User::Leave(aErrorCode);
        }
    
    OstTraceFunctionExit0( CDPSXMLPARSER_ONENDDOCUMENTL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
void CDpsXmlParser::OnStartElementL(const RTagInfo& aElement, 
									const RAttributeArray& aAttributes, 
									TInt aErrCode)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONSTARTELEMENTL_ENTRY );
    
    if (aErrCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONSTARTELEMENTL, "---, error code is %d", aErrCode );
        User::Leave(aErrCode);
        }
    if (aAttributes.Count() > 1)
        {
        OstTrace0( TRACE_ERROR, DUP1_CDPSXMLPARSER_ONSTARTELEMENTL, "---cannot have more than one attribute!" );
        User::Leave(KErrArgument);
        }
    	
    // Gets the name of the tag
    const TDesC8& name = aElement.LocalName().DesC();
    
    OstTraceExt1( TRACE_NORMAL, DUP2_CDPSXMLPARSER_ONSTARTELEMENTL, "---Start---%s", name );
    //Checks the element
    // this is the first layer <dps>
    if (!name.Compare(KDpsXml))
        {
        iAction = EDpsXmlStart;
        }
    // this is the second layer	<input|output>
    else if (!name.Compare(KDpsXmlOutput))
        {
        iAction = EDpsXmlOutput;
        }
    else if (!name.Compare(KDpsXmlInput))
        {
        // operation and event cannot be distiguised here
        iAction = EDpsXmlInput;
        }
    // this is the third layer <operation|event|result>	
    else if (iAction == EDpsXmlOutput && !name.Compare(KDpsXmlResult))
        {
        // output must be result
        iAction = EDpsXmlResult;
        }		
    else if (iAction == EDpsXmlInput &&
        (!name.Compare(iEngine->DpsParameters()->iDpsEventStrings[0]) ||
        !name.Compare(iEngine->DpsParameters()->iDpsEventStrings[1])))
        {
        if (!name.Compare(iEngine->DpsParameters()->iDpsEventStrings[0]))
            {
            iDpsEvent = EDpsEvtNotifyJobStatus;
            }
        else
            {
            iDpsEvent = EDpsEvtNotifyDeviceStatus;	
            }
        iAction = EDpsXmlEvent;	
        }
    else if (iAction == EDpsXmlInput || iAction == EDpsXmlResult)
        {
        iAction = EDpsXmlOperation;
        for (TInt i= 0; i < EDpsOpMax-1; i++) //i=0 as AppendL() method adds item on first free position in array
            {
            if (!name.Compare(iEngine->DpsParameters()->iDpsOperationStrings[i]))
                {
                OstTraceExt1( TRACE_NORMAL, DUP3_CDPSXMLPARSER_ONSTARTELEMENTL, "---found the operation---%s", name );
                iDpsOperation = (TDpsOperation)(i+1);// i+1 to by pass first operation EDpsOpEmpty in enum which is not added to array
                break;
                }
            }
        }
		
    // below is the fourth layer, e.g. the argument list/element. there
    // could be many arugments, but only one element	
    else if (iAction == EDpsXmlOperation || iAction == EDpsXmlEvent)
        {
        // only element in output is capability
        if (!name.Compare(iEngine->DpsParameters()->iDpsElementStrings[0]))
            {
            OstTraceExt1( TRACE_NORMAL, DUP4_CDPSXMLPARSER_ONSTARTELEMENTL, "---the element is %s", name );
            iElement = EDpsCapability;
            }
        else
            {
            for (TInt i = 0; i < EDpsArgMax; i++)
                {
                if (!name.Compare(iEngine->DpsParameters()->iDpsArgStrings[i]))
                    {
                    OstTraceExt1( TRACE_NORMAL, DUP5_CDPSXMLPARSER_ONSTARTELEMENTL, "---the argument is %s", name );
                    TDpsArg arg;
                    arg.iElement = (TDpsArgument)i;
                    arg.iContent.Copy(_L(""));
                    iDpsArgs.Append(arg);
                    break;
                    }
                }
            }
		
        }
    else
        {
        // something wrong
        OstTraceExt1( TRACE_ERROR, DUP6_CDPSXMLPARSER_ONSTARTELEMENTL, "--- non-PB element! %S", name );
        User::Leave(KErrNotSupported);
        }
    if (aAttributes.Count() == 1)
        {
        ParseAttributesL(aAttributes, name);
        }
    OstTraceFunctionExit0( CDPSXMLPARSER_ONSTARTELEMENTL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	     
void CDpsXmlParser::ParseAttributesL(const RAttributeArray& aAttributes, 
                                     const TDesC8& tag)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_PARSEATTRIBUTESL_ENTRY );
    // element
    const TDesC8& name = aAttributes[0].Attribute().LocalName().DesC();
    // only "layouts" and "paperTypes" have attributes
    if (tag.Compare(KDpsXmlPaperTypes) && tag.Compare(KDpsXmlLayouts))
        {
        // error
        OstTraceExt1( TRACE_ERROR, CDPSXMLPARSER_PARSEATTRIBUTESL, "--- this tag %s have no attribute", name );
        User::Leave(KErrArgument);
        }
    // the element of the attributes must be "paperSize"	
    if (name.Compare(KDpsXmlPaperSize))
        {
        // error
        OstTraceExt1( TRACE_ERROR, DUP1_CDPSXMLPARSER_PARSEATTRIBUTESL, "--- wrong attribute--- %s", name );
        User::Leave(KErrArgument);
        }
    // value
    HBufC8* value = aAttributes[0].Value().DesC().AllocLC();
    TUint32 result;    
    TLex8 converter(*value);
    TInt error = converter.Val(result, EHex);
    if (error != KErrNone)
        {
        OstTrace1( TRACE_ERROR, DUP2_CDPSXMLPARSER_PARSEATTRIBUTESL, "--- convert error %d", error );
        User::Leave(error);
        }
    iAttrib = result >> KShiftLength; 
    CleanupStack::PopAndDestroy(value);
    OstTrace1( TRACE_NORMAL, DUP3_CDPSXMLPARSER_PARSEATTRIBUTESL, "--- attribte value %x", result );
  
    OstTraceFunctionExit0( CDPSXMLPARSER_PARSEATTRIBUTESL_EXIT );
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
void CDpsXmlParser::OnEndElementL(const RTagInfo& aElement, 
								  TInt aErrorCode)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONENDELEMENTL_ENTRY );
    
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONENDELEMENTL, "--- error code is %d", aErrorCode );
        User::Leave(aErrorCode);
        }
        
    // Get the name of the tag
    const TDesC8& name = aElement.LocalName().DesC();
    OstTraceExt1( TRACE_NORMAL, DUP1_CDPSXMLPARSER_ONENDELEMENTL, "%s", name );    
    OstTraceFunctionExit0( CDPSXMLPARSER_ONENDELEMENTL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CDpsXmlParser::OnContentL(const TDesC8& aBytes, TInt aErrorCode)
	{
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONCONTENTL_ENTRY );
    OstTraceExt1( TRACE_NORMAL, CDPSXMLPARSER_ONCONTENTL, "content is %s", aBytes );
    
    if (aErrorCode != KErrNone)
   	    {
        OstTrace1( TRACE_ERROR, DUP1_CDPSXMLPARSER_ONCONTENTL, "--- error code %d", aErrorCode );
        User::Leave(aErrorCode);
        }	
    if (aBytes[0] >= KSOH && aBytes[0] <= KSpace)
        {
        OstTrace1( TRACE_NORMAl, DUP2_CDPSXMLPARSER_ONCONTENTL, "the unprintable char %d", aBytes[0] );
        OstTraceFunctionExit0( CDPSXMLPARSER_ONCONTENTL_EXIT );
        return; 
        }
    // parses the result	
    if (iAction == EDpsXmlResult)
        {
        TUint32 value;
        TLex8 converter(aBytes);
        TInt error = converter.Val(value, EHex);
        if (error != KErrNone)
            {
            OstTrace1( TRACE_ERROR, DUP3_CDPSXMLPARSER_ONCONTENTL, "--- convert error %d", error );
            User::Leave(error);
            }
        OstTrace1( TRACE_NORMAL, DUP4_CDPSXMLPARSER_ONCONTENTL, "--- result %x", value);
        
        // we have got the result
        iDpsResult.iMajorCode = 
            static_cast<TDpsResultMajorCode>(value >> KShiftLength);
        iDpsResult.iMinorCode = 
            static_cast<TDpsResultMinorCode>(value & KDpsMinorMask);
        }
    // gets the argument	
    else if (iAction == EDpsXmlOperation || iAction == EDpsXmlEvent)
        {
        iDpsArgs[iDpsArgs.Count() - 1].iContent.Copy(aBytes);
        }
    OstTraceFunctionExit0( DUP1_CDPSXMLPARSER_ONCONTENTL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CDpsXmlParser::OnStartPrefixMappingL(const RString& /*aPrefix*/, 
										  const RString& /*aUri*/, 
										  TInt aErrorCode)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONSTARTPREFIXMAPPINGL_ENTRY );
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONSTARTPREFIXMAPPINGL, "--- error code %d", aErrorCode );
        User::Leave(aErrorCode);
        }
    OstTraceFunctionExit0( CDPSXMLPARSER_ONSTARTPREFIXMAPPINGL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
void CDpsXmlParser::OnEndPrefixMappingL(const RString& /*aPrefix*/, 
									    TInt aErrorCode)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONENDPREFIXMAPPINGL_ENTRY );
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONENDPREFIXMAPPINGL, "--- error code %d", aErrorCode );
        User::Leave(aErrorCode);
        }
    OstTraceFunctionExit0( CDPSXMLPARSER_ONENDPREFIXMAPPINGL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CDpsXmlParser::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, 
                                           TInt aErrorCode)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONIGNORABLEWHITESPACEL_ENTRY );
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONIGNORABLEWHITESPACEL, "--- error code %d", aErrorCode );
        User::Leave(aErrorCode);
        }
    OstTraceFunctionExit0( CDPSXMLPARSER_ONIGNORABLEWHITESPACEL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
void CDpsXmlParser::OnSkippedEntityL(const RString& /*aName*/, 
								     TInt aErrorCode)
	{
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONSKIPPEDENTITYL_ENTRY );
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONSKIPPEDENTITYL, "--- error code %d", aErrorCode );
        User::Leave(aErrorCode);
        }
    OstTraceFunctionExit0( CDPSXMLPARSER_ONSKIPPEDENTITYL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
void CDpsXmlParser::OnProcessingInstructionL(const TDesC8& /*aTarget*/, 
											 const TDesC8& /*aData*/, 
											 TInt aErrorCode)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONPROCESSINGINSTRUCTIONL_ENTRY );
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_ERROR, CDPSXMLPARSER_ONPROCESSINGINSTRUCTIONL, "--- error code %d", aErrorCode );
        User::Leave(aErrorCode);
        }
    OstTraceFunctionExit0( CDPSXMLPARSER_ONPROCESSINGINSTRUCTIONL_EXIT );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
void CDpsXmlParser::OnError(TInt aErrorCode)
    {
    OstTraceFunctionEntry0( CDPSXMLPARSER_ONERROR_ENTRY );
    if (aErrorCode != KErrNone)
        {
        OstTrace1( TRACE_NORMAL, CDPSXMLPARSER_ONERROR, "---error code %d", aErrorCode );
        }
    OstTraceFunctionExit0( CDPSXMLPARSER_ONERROR_EXIT );
    }

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

TAny* CDpsXmlParser::GetExtendedInterface(const TInt32 aUid)
    {
    return aUid == MDpsExtensionHandler::EInterfaceUid ?
    static_cast<MDpsExtensionHandler*>(this) : 0;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
void CDpsXmlParser::Reset()
    {
    iDpsArgs.Reset();
    iAction = EDpsXmlEmpty;
    iDpsEvent = EDpsEvtEmpty; 
    iDpsOperation = EDpsOpEmpty;
    iElement = EDpsEleEmpty; 
    iAttrib = 0;
    }