/*

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

*       Provides CUniDataModel class methods.

*

*/

// ========== INCLUDE FILES ================================

#include <eikenv.h>

#include <eikdoc.h>

#include <msvstd.h>                     // TMsvEntry

#include <msvapi.h>

#include <msvuids.h>                    // Msgs Uids

#include <mtclbase.h>                   // CBaseMtm

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

#include <cmsvmimeheaders.h>

#include <bautils.h>

#include <MuiuMsvUiServiceUtilities.h>  //Disk space check

#include <MsgAttachmentInfo.h>

#include <gmxmldocument.h>

#include <gmxmlnode.h>

#include <gmxmlelement.h>

// Features

#include <featmgr.h>	

#include <bldvariant.hrh>

#include <messagingvariant.hrh>

// MsgMedia

#include <MsgMimeTypes.h>

#include <MsgMediaResolver.h>

#include <MsgMediaInfo.h>

#include <MsgTextInfo.h>

#include <MmsConformance.h>

#include "UniDataModel.h"

#include "UniSmilModel.h"

#include "UniDataUtils.h"

#include "UniModelConst.h"

#include "UniObjectList.h"

#include "UniSmilList.h"

#include "UniObject.h"

#include "UniTextObject.h"

#include "UniMimeInfo.h"

#include "UniSmilUtils.h"

#include "UniEditorLogging.h"

// ========== CONSTANTS ====================================

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

// CUniDataModel::Constructor

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

//

CUniDataModel::CUniDataModel( RFs& aFs, CBaseMtm& aMtm ) :

    iFs( aFs ),

    iMtm( aMtm ),

    iSmilModel( NULL ),

    iDom( NULL )

    {

    }

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

// CUniDataModel::NewL

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

//

EXPORT_C CUniDataModel* CUniDataModel::NewL( RFs& aFs, CBaseMtm& aMtm )

    {

    CUniDataModel* self =  new ( ELeave ) CUniDataModel( aFs, aMtm );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUniDataModel::ConstructL

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

//

EXPORT_C void CUniDataModel::ConstructL()

    {

    iDataUtils = CUniDataUtils::NewL( iFs );

    iObjectList = CUniObjectList::NewL( iMtm, *iDataUtils );

    iAttachmentList = CUniObjectList::NewL( iMtm, *iDataUtils );

    iSmilList = CUniSmilList::NewL( iMtm );

    iSmilModel = CUniSmilModel::NewL( iFs, iMtm, *iDataUtils, *iObjectList );

    iMediaResolver = CMsgMediaResolver::NewL();

    iMediaResolver->SetCharacterSetRecognition( EFalse );

    iMmsConformance = CMmsConformance::NewL();

    iMmsConformance->CheckCharacterSet( EFalse );

    }

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

// CUniDataModel::~CUniDataModel

//

// Destructor.

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

//

EXPORT_C CUniDataModel::~CUniDataModel()

    {

    delete iMediaResolver;

    delete iMmsConformance;

    delete iSmilModel;

    delete iObjectList;

    delete iAttachmentList;

    delete iSmilList;

    delete iDataUtils;

    delete iParser;

    delete iDom;

    }

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

// CUniDataModel::RestoreL

// 

// Initialise the model. 

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

//

EXPORT_C void CUniDataModel::RestoreL(

        MUniDataModelObserver& aObserver,

        TBool aRemoveCorrupted /*= ETrue*/,

        TBool aAllowSmil /*= ETrue*/ )

    {

    iObserver = &aObserver;

    iSmilType = ENoSmil;

    if ( iMtm.Entry().HasStoreL() )

    	{

        FindAndHandleCorruptL( aRemoveCorrupted );

        TBool readOnly = iMtm.Entry().Entry().ReadOnly();

        CMsvStore* store = readOnly

        	? iMtm.Entry().ReadStoreL()

        	: iMtm.Entry().EditStoreL();

        CleanupStack::PushL( store );

        MMsvAttachmentManager& manager = store->AttachmentManagerL();

        CMsvMimeHeaders* msvMime = CMsvMimeHeaders::NewLC();

        iParseResult = 0;

        iOrigAttachmentCount = manager.AttachmentCount();

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

            {

            CMsvAttachment* attachment = manager.GetAttachmentInfoL( i );

            CleanupStack::PushL( attachment );

            msvMime->RestoreL( *attachment );

            TBuf8<KMaxDataTypeLength> contentType;

            contentType.Copy( msvMime->ContentType() );

            contentType.Append( _L8("/") );

            contentType.Append( msvMime->ContentSubType() );

            // Put smil attas to own array, except if SendUi

            if ( aAllowSmil &&

                contentType.CompareF( KMsgMimeSmil ) == 0 )

                {

                iSmilList->AddSmilAttachmentL( manager, attachment->Id() );

                CleanupStack::PopAndDestroy( attachment );

                continue;

                }

            RFile readFile = manager.GetAttachmentFileL( i );

            CleanupClosePushL( readFile );

            CUniObject* newObj = CreateObjectFromAttachmentLC(

                contentType,

                readFile,

                manager,

                *attachment );

            if ( newObj->Attachment() )

                {

                iAttachmentList->AddObjectL( newObj );

                }

            else

                {

                iObjectList->AddObjectL( newObj );

                }

            CleanupStack::Pop( newObj );

            CleanupStack::PopAndDestroy( &readFile ); 

            CleanupStack::PopAndDestroy( attachment );

            } // for

        CleanupStack::PopAndDestroy( msvMime );

        UNILOGGER_WRITE_TIMESTAMP("CUniDataModel::RestoreL commit start");

        if ( !readOnly && iOrigAttachmentCount > 0 )

    	    {

    	    store->CommitL();	

    	    }

        UNILOGGER_WRITE_TIMESTAMP("CUniDataModel::RestoreL commit end");

        CleanupStack::PopAndDestroy( store );

        if ( iSmilList->Count() == 1 )

            {

            RFile smilFile = iDataUtils->GetAttachmentFileL( iMtm, iSmilList->GetSmilAttachmentByIndex( 0 ) );

            iParser = CMDXMLParser::NewL( this );

            iParser->ParseFile( smilFile );

            }

        else

            {

            if ( iSmilList->Count() > 1 )

                {

                iSmilType = EMultipleSmil;

                }

            iParseResult = iSmilModel->ParseL( NULL ); // Try to create something anyway

            FinalizeRestoreL( KErrNone );

            }

    	}

    else

    	{

        FinalizeRestoreL( KErrNone );

    	}

    }

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

// CUniDataModel::AddAttachmentL

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

//

EXPORT_C CUniObject* CUniDataModel::AddAttachmentL(

        MUniObjectSaveObserver& aObserver,

        CMsgMediaInfo* aMedia,

        CMsvAttachment::TMsvAttachmentType aSaveType /*= CMsvAttachment::EMsvLinkedFile*/ )

    {

    CUniObject* obj = CUniObject::NewLC( iFs, iMtm, *iDataUtils, aMedia );

    // Update attachment list

    iAttachmentList->AddObjectL( obj );

    obj->SetAttachment( ETrue );

    CleanupStack::Pop( obj );

    obj->Save( aObserver, aSaveType );

    return obj;

    }

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

// CUniDataModel::AddStoredAttachmentL

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

//

EXPORT_C CUniObject* CUniDataModel::AddStoredAttachmentL( TMsvAttachmentId aAttachmentId,

                                                          CMsgMediaInfo* aMedia )

    {

    CMsvStore* store = iMtm.Entry().EditStoreL();

    CleanupStack::PushL( store );

    MMsvAttachmentManager& manager = store->AttachmentManagerL();

    MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();

    CMsvAttachment* attachment = manager.GetAttachmentInfoL( aAttachmentId );

    CleanupStack::PushL( attachment );

    CUniObject* obj = CUniObject::NewLC( iFs, iMtm, *iDataUtils, aMedia, manager, *attachment );

    managerSync.ModifyAttachmentInfoL( attachment );

    CleanupStack::Pop( 2, attachment ); //obj, attachment

    CleanupStack::PushL( obj );

    store->CommitL();

    // Update attachment list

    iAttachmentList->AddObjectL( obj );

    obj->SetAttachment( ETrue );

    CleanupStack::Pop( obj );

    CleanupStack::PopAndDestroy( store );

    return obj;

    }

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

// CUniDataModel::FinalizeMediaParse

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

//

EXPORT_C void CUniDataModel::FinalizeMediaParse()

    {

    while ( iObjectToParse )

        {

        iObjWait.Start();

        }

    }

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

// CUniDataModel::MediaInfoParsed

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

//

void CUniDataModel::MediaInfoParsed()

    {

    if ( iObjectToParse->MediaInfo()->Corrupt() )

        {

        iObjectToParse->SetCorrupted( ETrue );

        }

    ParseNextObject();

    if ( iObjWait.IsStarted() )

        {

        iObjWait.AsyncStop();

        }

    }

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

// CUniDataModel::ParseNextObject

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

//

void CUniDataModel::ParseNextObject()

    {

    CUniObjectList* list = iObjectList;

    while ( list )

        {

        for ( TInt i = 0; i < list->Count(); i++ )

            {

            iObjectToParse = list->GetByIndex( i );

            if ( !iObjectToParse->MediaInfo()->Parsed() &&

                 !iObjectToParse->MediaInfo()->ParseError() )

                {

                RFile file;

                TRAPD( error, file = iDataUtils->GetAttachmentFileL( iMtm, iObjectToParse->AttachmentId() ) );

                if ( error == KErrNone )

                    {

                    iObjectToParse->MediaInfo()->ParseInfoDetails( file, *( iMediaResolver->DRMHelper() ), *this );

                    file.Close();

                    return;

                    }

                else

                    {

                    iObjectToParse->SetCorrupted( ETrue );

                    file.Close();

                    }

                }

            }

        if ( list == iObjectList )

            {

            list = iAttachmentList;

            }

        else

            {

            list = NULL;

            }

        }

   iObjectToParse = NULL;

   }

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

// CUniDataModel::ParseFileCompleteL

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

//

void CUniDataModel::ParseFileCompleteL()

    {

    TRAPD( err, DoParseFileCompleteL() );

    FinalizeRestoreL( err );

    }

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

// CUniDataModel::DoParseFileCompleteL

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

//

void CUniDataModel::DoParseFileCompleteL()

    {

    iDom = iParser->DetachXMLDoc();

    iSmilType = UniSmilUtils::GetSmilTypeL( iDom );

    if ( iSmilType == ENoSmil )

        {

        iParseResult = iSmilModel->ParseL( NULL );

        }

    else if ( iSmilType == EMmsSmil )

        {

        TRAPD( err, ( iParseResult = iSmilModel->ParseL( iDom ) ) );

        if ( err )

            {

            iSmilType = E3GPPSmil;

            iParseResult = 0;

            FindDomObjectRefCountsL();

            }

        }

    else 

        {

        FindDomObjectRefCountsL();

        }

    }

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

// CUniDataModel::FinalizeRestoreL

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

//

void CUniDataModel::FinalizeRestoreL( TInt aError )

    {

    if ( !aError )

        {

        // Won't leave.

        FindAttachmentsL();

        }

    iObserver->RestoreReady( iParseResult, aError );

    ParseNextObject();

    }

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

// CUniSmilModel::FindAttachmentsL

//

//

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

//

void CUniDataModel::FindAttachmentsL()

    {

    for ( TInt i = iObjectList->Count(); --i >= 0; )

        {

        CUniObject* obj = iObjectList->GetByIndex( i );

        if ( !obj->ReferenceCount() )

            {

            //don't remove from store -> cannot leave

            iObjectList->RemoveObjectL( obj, EFalse );

            iAttachmentList->AddObjectL( obj );

            obj->SetAttachment( ETrue );

            }

        }

    }

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

// FindAndHandleCorruptL

// 

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

void CUniDataModel::FindAndHandleCorruptL( TBool aRemoveCorrupted )

    {

    CMsvEntrySelection* corSel = FindCorruptLC();

    iCorruptedCount = corSel->Count();

    if ( iCorruptedCount > 0 )

        {

        if ( aRemoveCorrupted )

            {

            CMsvStore* store = iMtm.Entry().EditStoreL();

            CleanupStack::PushL( store );

            MMsvAttachmentManager& manager = store->AttachmentManagerL();

            MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();    

            for (TInt i = iCorruptedCount; --i >= 0 ;)

                {

                // Editor tries to recover by deleting corrupted ones

                // Note: This means that SMIL parsing will fail with ESmil_Missing_Objects. 

                //       and object order is not maintained. But better to do it this

                //       way so that message can be opened.

                TRAP_IGNORE ( managerSync.RemoveAttachmentL( 

                    CUniDataUtils::IndexPositionOfAttachmentL( manager, corSel->At( i ) ) ) );

                }

            store->CommitL();

            CleanupStack::PopAndDestroy( store );

            }

        else

            {

            // In viewer case consider message corrupted and leave.

            // Model not made viewer should exit.

            User::Leave( KErrCorrupt );

            }

        }

    CleanupStack::PopAndDestroy( corSel );

    }

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

// FindCorruptLC

// 

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

CMsvEntrySelection* CUniDataModel::FindCorruptLC()

    {

    CMsvEntrySelection* corrupts = new(ELeave) CMsvEntrySelection();

    CleanupStack::PushL( corrupts );

    if ( iMtm.Entry().HasStoreL() )

    	{

        CMsvStore* store = iMtm.Entry().ReadStoreL();

        CleanupStack::PushL( store );

        MMsvAttachmentManager& manager = store->AttachmentManagerL();

        TInt count = manager.AttachmentCount();

        for( TInt i = count; --i >= 0; )

            {

            CMsvAttachment* atta = manager.GetAttachmentInfoL( i );

            TMsvAttachmentId attaId = atta->Id();

            delete atta;

            RFile attaFile;

            TRAPD( err, attaFile = manager.GetAttachmentFileL( attaId ) );

            // if error, hardly no need to close

            attaFile.Close();

            if ( err )

                {

                corrupts->AppendL( attaId );

                }

            }

        CleanupStack::PopAndDestroy( store ); 

    	}

    return corrupts;

    }

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

// CreateObjectFromAttachmentLC

// 

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

CUniObject* CUniDataModel::CreateObjectFromAttachmentLC( 

                            const TPtrC8&               aMimeType,

                            RFile&                      aFile,