/*

* Copyright (c) 2008 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:  

*

*/

#include "creator_fileelement.h"

#include <DrmPermission.h>

#include <DrmConstraint.h>

#include "creator_traces.h"

#include "creator_file.h"

using namespace creatorfile;

// 15 minutes per time zone, 60 seconds per minute

const TInt KSecondsPerTimeZone = 900;

const TInt KMinuteInMicroseconds = 60000000;

const TInt KTimeZoneIncrement = 15;

/*

 * 

 */

CCreatorFileElement* CCreatorFileElement::NewL(CCreatorEngine* aEngine, const TDesC& aName, const TDesC& aContext )

    {

    CCreatorFileElement* self = new (ELeave) CCreatorFileElement(aEngine);

    CleanupStack::PushL(self);

    self->ConstructL(aName, aContext);

    CleanupStack::Pop(self);

    return self;

    }

/*

 * 

 */

CCreatorFileElement::CCreatorFileElement(CCreatorEngine* aEngine) 

: 

CCreatorScriptElement(aEngine)

    {

    iIsCommandElement = ETrue;

    TTime currUniversal;

    TTime currLocal;

    TInt64 result( 0 );

    currUniversal.UniversalTime();

    currLocal.HomeTime();

    result = currLocal.Int64() - currUniversal.Int64();

    result /= KMinuteInMicroseconds;

    result /= KTimeZoneIncrement;

    iTimeZone = I64INT( result );

    }

/*

 * 

 */

void CCreatorFileElement::ExecuteCommandL()

    {

    const CCreatorScriptAttribute* amountAttr = FindAttributeByName(KAmount);

    TInt fileAmount = 1;    

    if( amountAttr )

        {

        fileAmount = ConvertStrToIntL(amountAttr->Value());

        }

    // Get 'fields' element 

    CCreatorScriptElement* fieldsElement = FindSubElement(KFields);

    if( fieldsElement && fieldsElement->SubElements().Count() > 0)

        {

        // Get sub-elements

        const RPointerArray<CCreatorScriptElement>& fields = fieldsElement->SubElements();

        // Create files, the amount of files is defined by fileAmount:

        for( TInt cI = 0; cI < fileAmount; ++cI )

            {

            CFilesParameters* param = new (ELeave) CFilesParameters;

            CleanupStack::PushL( param );

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

                {

                CCreatorScriptElement* field = fields[i];

                TPtrC elemName = field->Name();

                TPtrC elemContent = field->Content();

                const CCreatorScriptAttribute* randomAttr = field->FindAttributeByName( KRandomLength );

                if( elemName == KType )

                    {

                    param->iFileCommand = GetFileCommandL(elemContent, randomAttr || elemContent.Length() == 0);

                    }

                else if( elemName == KDirectory )

                    {

                    delete param->iFullFilePath;

                    param->iFullFilePath = 0;

                    if( randomAttr == 0 && elemContent.Length() > 0 )

                    	{

                    	param->iFullFilePath = elemContent.AllocL();

                    	}

                    else

                        {

                        TFileName defaultPath;

                        iEngine->SetDefaultPathForFileCommandL( param->iFileCommand, defaultPath );

                        param->iFullFilePath = defaultPath.AllocL();

                        }

                    }

                else if ( elemName == KEncryption )

                    {

                    ParseDRMElementsL( field, param );

                    }

                }

            if ( !param->iFileCommand )

                {

                param->iFileCommand = ECmdCreateFileEntryEmptyFolder;

                }

            iEngine->AppendToCommandArrayL( param->iFileCommand, param);

            CleanupStack::Pop( param );

            }

        }

    else

    	{

    	_LIT(KDummy, "");

    	for( TInt cI = 0; cI < fileAmount; ++cI )

    		{

    		CFilesParameters* param = new (ELeave) CFilesParameters;

    		CleanupStack::PushL(param);

    		delete param->iFullFilePath;

    		param->iFullFilePath = 0;

    		TFileName defaultPath;

    		param->iFileCommand = GetFileCommandL(KDummy, ETrue);

    		iEngine->SetDefaultPathForFileCommandL(param->iFileCommand, defaultPath);                

    		param->iFullFilePath = defaultPath.AllocL();

    		iEngine->AppendToCommandArrayL(param->iFileCommand, param);

    		CleanupStack::Pop(param);

    		}

    	}

    }

TInt CCreatorFileElement::GetFileCommandL( const TDesC& aFileIdStr, TBool aRandom ) const

    {

    TInt mapCount = sizeof(FileMap) / sizeof(FileMapping);

    if( aRandom )

        {

        return FileMap[iEngine->RandomNumber(0, mapCount-1)].CommandId();

        }

    for( TInt i = 0; i < mapCount; ++i )

        {

        if( CompareIgnoreCase(FileMap[i].FileName(), aFileIdStr) == 0 )

            return FileMap[i].CommandId();

        }

    LOGSTRING2("CCreatorFileElement::GetFileCommandL: Unknown file id: %S", &aFileIdStr);

    User::Leave(KErrGeneral);

    return 0; // Not reached, but disables compiler warning...

    }

void CCreatorFileElement::ParseDRMElementsL( CCreatorScriptElement* aField, CFilesParameters* aParam )

    {

    const CCreatorScriptAttribute* encryptionTypeAttr = aField->FindAttributeByName( KType );

    if ( encryptionTypeAttr && encryptionTypeAttr->Value().Length() > 0 )

        {

        aParam->iEncrypt = ETrue;

        if ( encryptionTypeAttr->Value() == KDRMCD ) 

            {

            delete aParam->iPermission;

            aParam->iPermission = NULL;

            // ownership transferred:

            aParam->iPermission = CDRMPermission::NewL();

            }

        else if ( encryptionTypeAttr->Value() != KDRMFL )

            {

            // must be either KDRMCD or KDRMFL

            User::Leave( KErrArgument );

            }

        }

    else

        {

        User::Leave( KErrArgument );

        }

    const RPointerArray<CCreatorScriptElement>& rights = aField->SubElements();

    if ( encryptionTypeAttr->Value() == KDRMFL && rights.Count() )

        {

        // Right definitions not allowed with DRM Forward Lock

        // User::Leave( KErrArgument ); // Do not leave here

        return; // Just omit rights definitions

        }

    // parse right elements

    CDRMPermission* drmPermission = aParam->iPermission;

    for ( TInt r = 0; r < rights.Count(); r++ )

        {

        const CCreatorScriptAttribute* rightAttr = rights[r]->FindAttributeByName( KType );

        if ( rightAttr->Value() == KDRMPlayRight &&

             !( drmPermission->iAvailableRights & ERightsPlay ) )

            {

            drmPermission->iAvailableRights |= ERightsPlay;

            ParseDRMConstraintsL( rights[r], drmPermission->iPlay );

            }

        else if ( rightAttr->Value() == KDRMDisplayRight  &&

                !( drmPermission->iAvailableRights & ERightsDisplay ))

            {

            drmPermission->iAvailableRights |= ERightsDisplay;

            ParseDRMConstraintsL( rights[r], drmPermission->iDisplay );

            }

        else if ( rightAttr->Value() == KDRMPrintRight  &&

                !( drmPermission->iAvailableRights & ERightsPrint ) )

            {

            drmPermission->iAvailableRights |= ERightsPrint;

            ParseDRMConstraintsL( rights[r], drmPermission->iPrint );

            }

        else if ( rightAttr->Value() == KDRMExecuteRight  &&

                !( drmPermission->iAvailableRights & ERightsExecute ) )

            {

            drmPermission->iAvailableRights |= ERightsExecute;

            ParseDRMConstraintsL( rights[r], drmPermission->iExecute );

            }

        }

    }

void CCreatorFileElement::ParseDRMConstraintsL( CCreatorScriptElement* aRight, CDRMConstraint* aConstraint )

    {

    const RPointerArray<CCreatorScriptElement>& constraints = aRight->SubElements();

    for ( TInt c = 0; c < constraints.Count(); c++ )

        {

        TPtrC elemName = constraints[c]->Name();

        TPtrC elemContent = constraints[c]->Content();

        if ( elemName == KDRMCount )

            {

            TInt count = ConvertStrToIntL( elemContent );

            // apply count constraint

            aConstraint->iActiveConstraints |= EConstraintCounter;

            aConstraint->iCounter = count;

            aConstraint->iOriginalCounter = count;

            }

        else if ( elemName == KDRMInterval )

            {

            // apply interval constraint           

            aConstraint->iActiveConstraints |= EConstraintInterval;

            aConstraint->iInterval = ParseTimeInterval( elemContent );

            aConstraint->iIntervalStart = Time::NullTTime();

            }

        else if ( elemName == KDRMStartTime )

            {

            // apply start time constraint           

            aConstraint->iActiveConstraints |= EConstraintStartTime;

            TTimeIntervalSeconds offset( iTimeZone * KSecondsPerTimeZone );

            aConstraint->iStartTime = ConvertToDateTimeL( elemContent ) - offset;

            }

        else if ( elemName == KDRMEndTime )

            {

            // apply end time constraint

            aConstraint->iActiveConstraints |= EConstraintEndTime;

            TTimeIntervalSeconds offset( iTimeZone * KSecondsPerTimeZone );

            aConstraint->iEndTime = ConvertToDateTimeL( elemContent ) - offset;

            }

        else if ( elemName == KDRMAccumulated )

            {

            // apply accumulated time constraint

            aConstraint->iActiveConstraints |= EConstraintAccumulated;

            if ( aConstraint->iEndTime == Time::NullTTime() )

                {

                aConstraint->iEndTime = Time::MaxTTime();

                }

            if ( aConstraint->iStartTime == Time::NullTTime() )

                {

                aConstraint->iStartTime = Time::MinTTime();

                }

            aConstraint->iAccumulatedTime = ParseTimeInterval( elemContent );

            }

        }

    }

TTimeIntervalSeconds CCreatorFileElement::ParseTimeInterval( TDesC& aTimeString )

    {

    // Iso8601 format (P1Y2M3DT4H5M6S) to TimeIntervalSeconds

    TLex lex;

    TInt year = 0;

    TInt month = 0;

    TInt day = 0;

    TInt hour = 0;

    TInt minute = 0;

    TInt second = 0;

    if (aTimeString.Length() > 0)

        {    

        lex = aTimeString;

        lex.Inc(); // skip 'P'

        lex.Val(year);

        lex.Inc();

        lex.Val(month);

        lex.Inc();

        lex.Val(day);

        lex.Inc(2);

        lex.Val(hour);

        lex.Inc();

        lex.Val(minute);

        lex.Inc();

        lex.Val(second);

        }

    TTimeIntervalSeconds result( ( ( ( year * 365 + month * 30 + day ) * 24 + hour )

                * 60 + minute ) * 60 + second );

    return result;

    }

// End of file