/*
* 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:   XDM Engine
*
*/




// INCLUDE FILES
#include <utf.h>
#include <ecom.h>
#include <f32file.h>
#include <flogger.h>
#include "XdmEngine.h"
#include "XdmDocument.h"
#include "XdmProtocol.h"
#include "XdmDirectory.h"
#include "XdmLogWriter.h"
#include "XdmStaticUtils.h"
#include "XdmSettingsApi.h"
#include "XdmProtocolInfo.h"

// ----------------------------------------------------------
// CXdmEngine::CXdmEngine
// 
// ----------------------------------------------------------
//
CXdmEngine::CXdmEngine() : CActive( EPriorityStandard )                                           
    {  
    }

// ----------------------------------------------------------
// CXdmEngine::NewL
// 
// ----------------------------------------------------------
//
EXPORT_C CXdmEngine* CXdmEngine::NewL( const CXdmProtocolInfo& aProtocolInfo )
    {
    CXdmEngine* self = new ( ELeave ) CXdmEngine();
    CleanupStack::PushL( self );
    self->ConstructL( CONST_CAST( CXdmProtocolInfo&, aProtocolInfo ) );
    CleanupStack::Pop();
    return self;
    }

// ----------------------------------------------------------
// CXdmEngine::XdmSettingsLC
// 
// ----------------------------------------------------------
//
EXPORT_C CDesC16Array* CXdmEngine::XdmSettingsLC( RArray<TInt>& aSettingIds )
    {
    return TXdmSettingsApi::CollectionNamesLC( aSettingIds );
    }
    
// ----------------------------------------------------------
// CXdmEngine::ConstructL
// 
// ----------------------------------------------------------
//
void CXdmEngine::ConstructL( CXdmProtocolInfo& aProtocolInfo )
    {
    #ifdef _DEBUG
        iLogWriter = CXdmLogWriter::NewL( KXdmEngLogFile );
        WriteToLog( _L8( "CXdmEngine::ConstructL()" ) );
    #endif
    TRAPD( error, iXdmProtocol = CXdmProtocol::NewL( *this, aProtocolInfo ) );
    if( error == KErrNone && iXdmProtocol != NULL )
        {
        #ifdef _DEBUG
            WriteToLog( _L8( " Protocol implementation created successfully" ) );
        #endif
        CActiveScheduler::Add( this );
        }
    else
        {
        #ifdef _DEBUG
            WriteToLog( _L8( " Protocol creation failed - Error: %d  Protocol: %x" ), error, iXdmProtocol );
        #endif
        User::Leave( KErrUnknown );
        }
    }

// ----------------------------------------------------
// CXdmEngine::~CXdmEngine
// 
// ----------------------------------------------------
//
CXdmEngine::~CXdmEngine()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::~CXdmEngine()" ) );
    #endif
    iDocUpdateQueue.Close();
    iDirUpdateQueue.Close();
    iDocumentQueue.Close();
    iDirectoryQueue.Close();
    #ifdef _DEBUG
        WriteToLog( _L8( "  Queues closed" ) );
    #endif
    delete iXdmProtocol;
    #ifdef _DEBUG
        WriteToLog( _L8( "  Protocol deleted" ) );
    #endif
    REComSession::FinalClose();
    #ifdef _DEBUG
        WriteToLog( _L8( "  Destructor finished" ) );
    #endif
    delete iLogWriter;
    }

// ----------------------------------------------------------
// CXdmEngine::WriteToLog
// 
// ----------------------------------------------------------
//
void CXdmEngine::WriteToLog( TRefByValue<const TDesC8> aFmt,... ) const                                 
    {
    VA_LIST list;
    VA_START( list, aFmt );
    TBuf8<KLogBufferMaxSize> buf;
    buf.FormatList( aFmt, list );
    iLogWriter->WriteToLog( buf );
    }
    
// ----------------------------------------------------
// CXdmEngine::DirectoryCollection
// 
// ----------------------------------------------------
//
EXPORT_C const RPointerArray<CXdmDocument>& CXdmEngine::DocumentCollection() const
    {
    return iDocumentQueue;
    }

// ----------------------------------------------------
// CXdmEngine::DirectoryCollection
// 
// ----------------------------------------------------
//
EXPORT_C const RPointerArray<CXdmDirectory>& CXdmEngine::DirectoryCollection() const
    {
    return iDirectoryQueue;
    }
        
    
// ----------------------------------------------------
// CXdmEngine::CancelUpdate
// 
// ----------------------------------------------------
//
EXPORT_C void CXdmEngine::CancelUpdate( CXdmDocument* aDocument )
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::CancelUpdate( document )" ) );
    #endif
    TInt index = iDocumentQueue.Find( aDocument );
    if( IsActive() )
        {
        #ifdef _DEBUG
            WriteToLog( _L8( " Transfer media init pending, cancel self" ) );
        #endif
        Cancel();
        }
    else if( index != KErrNotFound && aDocument->IsActive() )
        {
        #ifdef _DEBUG
            WriteToLog( _L8( " Cancel document update" ) );
        #endif
        aDocument->CancelUpdate();
        if( iDocUpdateQueue.Find( aDocument ) == KErrNone )
            iDocUpdateQueue.Remove( index );
        }
    }

// ----------------------------------------------------
// CXdmEngine::CancelUpdate
// 
// ----------------------------------------------------
//
EXPORT_C void CXdmEngine::CancelUpdate( CXdmDirectory* aDirectory )
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::CancelUpdate( directory )" ) );
    #endif
    TInt index = iDirectoryQueue.Find( aDirectory );
    if( IsActive() )
        {
        #ifdef _DEBUG
            WriteToLog( _L8( " Transfer media init pending, cancel self" ) );
        #endif
        Cancel();
        }
    else if( index != KErrNotFound && aDirectory->IsActive() )
        {
        #ifdef _DEBUG
            WriteToLog( _L8( " Cancel directory update" ) );
        #endif
        aDirectory->CancelUpdate();
        if( iDirUpdateQueue.Find( aDirectory ) == KErrNone )
            iDirUpdateQueue.Remove( index );
        }
    }
    
// ----------------------------------------------------
// CXdmEngine::CreateDocumentModelL
// 
// ----------------------------------------------------
//
EXPORT_C CXdmDocument* CXdmEngine::CreateDocumentModelL( const TDesC& aDocumentName,
                                                         const TXdmDocType aDocumentType )                                 
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::CreateDocumentModelL()" ) );
    #endif
    CXdmDocument* document = iXdmProtocol->CreateDocumentL( aDocumentName, aDocumentType );
    CleanupStack::PushL( document );
    User::LeaveIfError( iDocumentQueue.Append( document ) );
    CleanupStack::Pop();  //document
    return document;
    }
    
// ----------------------------------------------------
// CXdmEngine::DeleteDocumentModelL
// 
// ----------------------------------------------------
//
EXPORT_C void CXdmEngine::DeleteDocumentModelL( const CXdmDocument* aDocument )                                 
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::DeleteDocumentModelL()" ) );
    #endif
    TInt index = iDocumentQueue.Find( aDocument );
    __ASSERT_ALWAYS( index != KErrNotFound, User::Leave( KErrNotFound ) );
    iDocumentQueue.Remove( index );
    delete aDocument;
    aDocument = NULL;
    }

// ----------------------------------------------------
// CXdmEngine::CreateDirectoryModelL
// 
// ----------------------------------------------------
//
EXPORT_C CXdmDirectory* CXdmEngine::CreateDirectoryModelL( const TDesC& aDirectoryPath )                                 
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::CreateDirectoryModelL()" ) );
    #endif
    CXdmDirectory* directory = iXdmProtocol->CreateDirectoryL( aDirectoryPath );
    CleanupStack::PushL( directory );
    User::LeaveIfError( iDirectoryQueue.Append( directory ) );
    CleanupStack::Pop();  //document
    return directory;
    }

// ----------------------------------------------------
// CXdmEngine::DeleteDirectoryModelL
// 
// ----------------------------------------------------
//
EXPORT_C void CXdmEngine::DeleteDirectoryModelL( const CXdmDirectory* aDirectory )                                 
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::DeleteDirectoryModelL()" ) );
    #endif
    TInt index = iDirectoryQueue.Find( aDirectory );
    __ASSERT_ALWAYS( index != KErrNotFound, User::Panic( _L( "CXdmEngine" ), EDirModelNotFound ) );
    iDirectoryQueue.Remove( index );
    delete aDirectory;
    aDirectory = NULL;
    }

// ----------------------------------------------------
// CXdmEngine::CreateDocumentNodeL
// 
// ----------------------------------------------------
//
EXPORT_C CXdmDocumentNode* CXdmEngine::CreateDocumentNodeL()                                 
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::CreateDocumentNodeL()" ) );
    #endif
    return iXdmProtocol->CreateDocumentNodeL();
    }
        
// ----------------------------------------------------
// CXdmEngine::UpdateL
// 
// ----------------------------------------------------
//
EXPORT_C void CXdmEngine::UpdateL( CXdmDocument* aDocument,
                                   TRequestStatus& aStatus )                                 
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::UpdateL( document )" ) );
    #endif
    iClientStatus = &aStatus;
    aStatus = KRequestPending;
    aDocument->SaveClientStatus( aStatus );
    User::LeaveIfError( iDocUpdateQueue.Append( aDocument ) );
    if( !IsActive() )
        {
        iXdmProtocol->InitTransferMedium( KDefaultIdleTimeout, iStatus );
        SetActive();
        }
    }

// ----------------------------------------------------
// CXdmEngine::UpdateL
// 
// ----------------------------------------------------
//
EXPORT_C void CXdmEngine::UpdateL( TRequestStatus& aStatus,
                                   CXdmDirectory* aDirectory,
                                   TDirUpdatePhase aUpdatePhase )                                 
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::UpdateL( directory )" ) );
    #endif
    iClientStatus = &aStatus;
    aStatus = KRequestPending;
    aDirectory->SaveRequestData( aUpdatePhase, aStatus );
    User::LeaveIfError( iDirUpdateQueue.Append( aDirectory ) ); 
    if( !IsActive() )
        {
        iXdmProtocol->InitTransferMedium( KDefaultIdleTimeout, iStatus );
        SetActive();
        }
    }
    
// ---------------------------------------------------------
// CXdmEngine::RunL
// 
// ---------------------------------------------------------
//
void CXdmEngine::RunL()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::RunL() - Status: %d" ), iStatus.Int() );
    #endif
    if( iStatus == KErrCancel )
        {
        #ifdef _DEBUG
            WriteToLog( _L8( " Update cancelled, complete client request" ) );
        #endif
        if( iClientStatus )
            {
            iDocUpdateQueue.Reset();
            iDirUpdateQueue.Reset();
            User::RequestComplete( iClientStatus, KErrCancel );
            #ifdef _DEBUG
                WriteToLog( _L8( "  Request complete" ) );
            #endif
            }
        }  
    else
        {
        #ifdef _DEBUG
            WriteToLog( _L8( " Transfer media initialised, start update" ) );
        #endif
        TInt dirCount( iDirUpdateQueue.Count() );
        TInt docCount( iDocUpdateQueue.Count() );
        #ifdef _DEBUG
            WriteToLog( _L8( "  Document queue count:  %d" ), docCount );
            WriteToLog( _L8( "  Directory queue count: %d" ), dirCount );
        #endif
        //First check the document queue
        for( TInt i = 0;i < docCount;i++ )
            {
            iDocUpdateQueue[0]->StartUpdateL();
            iDocUpdateQueue.Remove( 0 );
            }
        //Then the directory queue
        for( TInt j = 0;j < dirCount;j++ )
            {
            iDirUpdateQueue[0]->StartUpdateL();
            iDirUpdateQueue.Remove( 0 );
            }
        }
    }

// ---------------------------------------------------------
// CXdmEngine::DoCancel
// 
// ---------------------------------------------------------
//
void CXdmEngine::DoCancel()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::DoCancel()" ) );
    #endif
    iXdmProtocol->CancelTransferMediumInit();
    if( iClientStatus )
        {
        #ifdef _DEBUG
            WriteToLog( _L8( "  Client request pending => Complete" ) );
        #endif
        iDocUpdateQueue.Reset();
        iDirUpdateQueue.Reset();
        User::RequestComplete( iClientStatus, KErrCancel );
        }
    }

// ---------------------------------------------------------
// CXdmEngine::XdmProtocol
// 
// ---------------------------------------------------------
//
CXdmProtocol* CXdmEngine::XdmProtocol() const
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::XdmProtocol()" ) );
    #endif
    return iXdmProtocol;
    }

// ---------------------------------------------------------
// CXdmEngine::ConvertToUTF8L
// 
// ---------------------------------------------------------
//
HBufC8* CXdmEngine::ConvertToUTF8L( const TDesC& aUnicodeDesc )
    {
    /*#ifdef _DEBUG
        WriteToLog( _L8( "CXdmEngine::ConvertToUTF8L()" ) );
    #endif*/
    return CnvUtfConverter::ConvertFromUnicodeToUtf8L( aUnicodeDesc );
    }