/*

* Copyright (c) 2002-2004 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:  ?Description

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <s32mem.h>

#include <f32file.h>

#include <caf/caf.h>

#include <caf/caferr.h>

#include <caf/SupplierOutputFile.h>

#include "Oma2Agent.h"

#include "Oma2AgentImportfile.h"

#include "DcfCommon.h"

#include "DrmRights.h"

#include "DrmMessageParser.h"

#include "Oma1DcfCreator.h"

#include "DrmRightsParser.h"

#include "DrmProtectedRoParser.h"

using namespace ContentAccess;

// LOCAL FUNCTION PROTOTYPES

template<class S>

LOCAL_C void PointerArrayResetDestroyAndClose(TAny* aPtr);

// ============================= LOCAL FUNCTIONS ===============================

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

template<class S>

void PointerArrayResetDestroyAndClose(TAny* aPtr)

    {

    (reinterpret_cast<RPointerArray<S>*>(aPtr))->ResetAndDestroy();

    (reinterpret_cast<RPointerArray<S>*>(aPtr))->Close();

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// COma2AgentImportFile::

// 

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

//

COma2AgentImportFile* COma2AgentImportFile::NewL(

    const TDesC8& aMimeType,

    const CMetaDataArray& aMetaDataArray,

    const TDesC& aOutputDirectory,

    const TDesC& aSuggestedFileName)

	{

	COma2AgentImportFile* self=new(ELeave) COma2AgentImportFile(EFalse);

	CleanupStack::PushL(self);

	self->ConstructL(aMimeType, aMetaDataArray, aOutputDirectory,

	    aSuggestedFileName);

	CleanupStack::Pop(self);

	return self;

	}

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

// COma2AgentImportFile::

// 

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

//

COma2AgentImportFile* COma2AgentImportFile::NewL(

    const TDesC8& aMimeType,

    const CMetaDataArray& aMetaDataArray)

	{

	COma2AgentImportFile* self=new(ELeave) COma2AgentImportFile(EFalse);

	CleanupStack::PushL(self);

	self->ConstructL(aMimeType, aMetaDataArray, KNullDesC(), KNullDesC());

	CleanupStack::Pop(self);

	return self;

	}

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

// COma2AgentImportFile::

// 

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

//

COma2AgentImportFile::COma2AgentImportFile(

    TBool aAgentCreatesOutputFiles):

    iOutputDirectory(NULL),

    iSuggestedFileName(NULL),

    iOutputFileName(NULL),

    iLastWriteData(NULL),

    iAgentCreatesOutputFiles(aAgentCreatesOutputFiles),

    iMessageParser(NULL),

    iDcfCreator(NULL),

    iDcfRights(NULL),

    iDcfMimeType(NULL)

	{

	iImportStatus = EInProgress;

	}

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

// COma2AgentImportFile::

// 

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

//

COma2AgentImportFile::~COma2AgentImportFile()

	{

	if (iFileOpen)

		{

		iFile.Close();

		iFileOpen = EFalse;

		}

	iFs.Close();

	delete iOutputDirectory;

	delete iSuggestedFileName;

    delete iOutputFileName;

	delete iLastWriteData;

	iOutputFiles.ResetAndDestroy();

	iOutputFiles.Close();

	delete iMessageParser;

	delete iDcfCreator;

	delete iDcfRights;

	delete iDcfMimeType;

	}

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

// COma2AgentImportFile::

// 

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

//

void COma2AgentImportFile::ConstructL(

    const TDesC8& aMimeType,

    const CMetaDataArray& aMetaDataArray,

    const TDesC& aOutputDirectory,

    const TDesC& aSuggestedFileName)

	{

	RMemReadStream rights;

	if (aMimeType.CompareF(KOma1DrmMessageContentType) == 0 ||

	    aMimeType.CompareF(KOmaImportContentType) == 0)

	    {

	    if (aMimeType.CompareF(KOma1DrmMessageContentType) == 0)

	        {

            iMessageParser = CDRMMessageParser::NewL();

	        iImportType = EOma1DrmMessage;

	        }

	    else

	        {

	        iDcfCreator = COma1DcfCreator::NewL();

    	    iImportType = EPlainContent;

            const TDesC8& mimeDes = aMetaDataArray.SearchL(

                KOmaImportMimeTypeField);

            if (mimeDes.Length() == 0)

                {

                User::Leave(KErrArgument);

                }

    	    iDcfMimeType = mimeDes.AllocL();

    	    const TDesC8& rightsDes = aMetaDataArray.SearchL(

    	        KOmaImportRightsField);

            if (rightsDes.Length() > 0)

    	        {

    	        rights.Open(rightsDes.Ptr(), rightsDes.Length());

    	        CleanupClosePushL(rights);

        	    iDcfRights = CDRMRights::NewL();

    	        iDcfRights->InternalizeL(rights);

    	        CleanupStack::PopAndDestroy(); // rights

    	        }

	        }

    	iOutputDirectory = aOutputDirectory.AllocL();

    	iSuggestedFileName = aSuggestedFileName.AllocL();

    	iOutputFileName = HBufC::NewL(iOutputDirectory->Des().Length() +

            iSuggestedFileName->Des().Length());

	    iAgentCreatesOutputFiles = ETrue;

	    }

    else if (aMimeType.CompareF(KOma1XmlRoContentType) == 0)

	    {

	    iImportType = EOma1XmlRo;

	    }

    else if (aMimeType.CompareF(KOma1WbxmlRoContentType) == 0)

	    {

	    iImportType = EOma1WbxmlRo;

	    }

    else if (aMimeType.CompareF(KOma2RoContentType) == 0)

	    {

	    iImportType = EOma2Ro;

	    }

    else

        {

		User::Leave(KErrCANotSupported);

		}

	User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iFs.ShareAuto());	

	}

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

// COma2AgentImportFile::

// 

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

//

TInt COma2AgentImportFile::OpenOutputFile()

	{

	TInt r = KErrNone;

	TPtr fileNamePtr = iOutputFileName->Des();

	fileNamePtr.Copy(*iOutputDirectory);

	fileNamePtr.Append(*iSuggestedFileName);

	r = iFile.Create(iFs, fileNamePtr, EFileShareAny  | EFileStream |

	    EFileWrite);

	if (r == KErrNone)

		{

		iFileOpen = ETrue;

		if (iImportType == EOma1DrmMessage)

		    {

		    TRAP(r, iMessageParser->InitializeMessageParserL(iFile));

		    }

		else

		    {

		    TRAP(r, iDcfCreator->EncryptInitializeL(iFile, *iDcfMimeType,

		        iDcfRights));

		    }

		}

    else

        {

        r = KErrCANewFileHandleRequired;

        }

    return r;

	}

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

// COma2AgentImportFile::

// 

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

//

void COma2AgentImportFile::WriteDataL(const TDesC8& aData)

    {

	CDrmRightsParser* oma1Parser = NULL;

	CDrmProtectedRoParser* oma2Parser = NULL;

	RPointerArray<CDRMRights> rights;

    TCleanupItem listCleanup(PointerArrayResetDestroyAndClose<CDRMRights>,

        &rights);

	TInt r;

    switch (iImportType)

        {

        case EOma1DrmMessage:

        	if (!iFileOpen)

        		{

        		r = OpenOutputFile();

        		if (r == KErrNone)

        		    {

                    iMessageParser->ProcessMessageDataL(aData);

        		    }

        		else

        		    {

                    iLastWriteData = aData.AllocL();

                    User::Leave(r);

        		    }

                }

            else

                {

                iMessageParser->ProcessMessageDataL(aData);

                }

            break;

        case EPlainContent:

        	if (!iFileOpen)

        		{

        		r = OpenOutputFile();

        		if (r == KErrNone)

        		    {

                    iDcfCreator->EncryptUpdateL(aData);

        		    }

        		else

        		    {

                    iLastWriteData = aData.AllocL();

                    User::Leave(r);

        		    }

                }

            else

                {

                iDcfCreator->EncryptUpdateL(aData);

                }

            break;

        case EOma1XmlRo:

        case EOma1WbxmlRo:

            oma1Parser = CDrmRightsParser::NewL();

            CleanupStack::PushL(oma1Parser);

            CleanupStack::PushL(listCleanup);

            oma1Parser->ParseAndStoreL(aData, rights);

            CleanupStack::PopAndDestroy(2); // listCleanup, oma1Parser

            break;

        case EOma2Ro:

            __UHEAP_MARK;

            oma2Parser = CDrmProtectedRoParser::NewL();

            CleanupStack::PushL(oma2Parser);

            CleanupStack::PushL(listCleanup);

            oma2Parser->ParseAndStoreL(aData, rights);

            CleanupStack::PopAndDestroy(2); // listCleanup, oma2Parser

            __UHEAP_MARKEND;

            break;

        }

    }

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

// COma2AgentImportFile::

// 

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

//

TInt COma2AgentImportFile::WriteData(const TDesC8& aData)

	{

	TInt r = KErrNone;

	TRAP(r, WriteDataL(aData));

	return r;

	}

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

// COma2AgentImportFile::

// 

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

//

TInt COma2AgentImportFile::WriteDataComplete()

	{

	TInt r = KErrNone;

	CSupplierOutputFile *temp = NULL;

	TPtrC8 type(NULL, 0);

	if (iFileOpen)

		{

		if (iImportType == EOma1DrmMessage)

		    {

		    TRAP(r, iMessageParser->FinalizeMessageParserL());

		    }

		else

		    {

		    TRAP(r, iDcfCreator->EncryptFinalizeL());

		    }

		iFile.Close();

		iFileOpen = EFalse;

		}

	if( r ) 

	    {

		  return r;

      }

	if (iOutputFileName)

		{

		switch (iImportType)

		    {

		    case EPlainContent:

            case EOma1DrmMessage:

                type.Set(KOma1DcfContentType());

                break;

            default:

                return KErrGeneral;;

		    }

		TRAP(r, temp = CSupplierOutputFile::NewL(iOutputFileName->Des(),

		    EContent, type));

		if (r == KErrNone)

			{

			r = iOutputFiles.Append(temp);

			if (r != KErrNone)

				{

				delete temp;

				}

			}

		}

	return r;

	}

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

// COma2AgentImportFile::

// 

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

//

void COma2AgentImportFile::WriteData(

    const TDesC8& aData,

    TRequestStatus &aStatus)

	{

	TRequestStatus *ptr = &aStatus;

	TInt r = WriteData(aData);

	User::RequestComplete(ptr,r);

	}

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

// COma2AgentImportFile::

// 

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

//

void COma2AgentImportFile::WriteDataComplete(

    TRequestStatus &aStatus)

	{

	TRequestStatus *ptr = &aStatus;

	TInt r = WriteDataComplete();

	User::RequestComplete(ptr,r);

	}

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

// COma2AgentImportFile::

// 

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

//

TInt COma2AgentImportFile::OutputFileCountL() const

	{

	return iOutputFiles.Count();

	}

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

// COma2AgentImportFile::

// 

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

//

CSupplierOutputFile& COma2AgentImportFile::OutputFileL(

    TInt aIndex)

	{

	return *iOutputFiles[aIndex];

	}

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

// COma2AgentImportFile::

// 

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

//

TImportStatus COma2AgentImportFile::GetImportStatus() const

	{

	return iImportStatus;

	}	

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

// COma2AgentImportFile::

// 

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

//

TInt COma2AgentImportFile::GetSuggestedOutputFileExtension(

    TDes& aFileExtension)

	{

	aFileExtension.Copy(_L(".dcf"));

	return KErrNone;

	}

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

// COma2AgentImportFile::

// 

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

//

TInt COma2AgentImportFile::GetSuggestedOutputFileName(

    TDes& aFileName)

	{

	aFileName.Append(_L(".dcf"));

	return KErrNone;

	}

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

// COma2AgentImportFile::

// 

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

//

TInt COma2AgentImportFile::ContinueWithNewOutputFile(

    RFile& aFile,

    const TDesC& aFileName)

	{

	RFile file;

	TInt r = KErrNone;

	if (iOutputFileName != NULL)

	    {

	    delete iOutputFileName;

	    iOutputFileName = NULL;

	    }

	TRAP(r, iOutputFileName = aFileName.AllocL());

	if (r == KErrNone)

	    {

	    file.Duplicate(aFile);

        iFile.Attach(file);

        iFileOpen = ETrue;

		if (iImportType == EOma1DrmMessage)

		    {

		    TRAP(r, iMessageParser->InitializeMessageParserL(iFile));

		    }

		else

		    {

		    TRAP(r, iDcfCreator->EncryptInitializeL(iFile, *iDcfMimeType,

		        iDcfRights));

		    }

        if (r == KErrNone)

            {

            r = WriteData(*iLastWriteData);

            }

        delete iLastWriteData;

        iLastWriteData = NULL;

	    }

	return r;

	}

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

// COma2AgentImportFile::

// 

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

//

void COma2AgentImportFile::ContinueWithNewOutputFile(

    RFile& aFile,

    const TDesC& aFileName,

    TRequestStatus& aStatus)

	{

	TRequestStatus *ptr = &aStatus;

	TInt r = ContinueWithNewOutputFile(aFile, aFileName);

	User::RequestComplete(ptr,r);

	}

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

// COma2AgentImportFile::

// 

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

//

void COma2AgentImportFile::NewMimePartL(

    const TDesC8& /*aMimeType*/,