/*

* Copyright (c) 2009 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:  Functional implementation of PIM service (for vCalendar, vCard)

*

*/

// INCLUDE FILES

#include "HtiPIMServicePlugin.h"

#include "PIMHandler.h"

#include <HtiDispatcherInterface.h>

#include <HTILogging.h>

#include <utf.h>

#include <calcommon.h>

#include <calsession.h>

#include <calenimporter.h>

#include <calentryview.h>

#include <CVPbkContactLinkArray.h>

#include <CVPbkContactManager.h>

#include <CVPbkContactViewDefinition.h>

#include <CVPbkContactStoreUriArray.h>

#include <CVPbkSortOrder.h>

#include <CVPbkVCardEng.h>

#include <MVPbkContactLinkArray.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStoreObserver.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactView.h>

#include <MVPbkContactViewBase.h>

#include <MVPbkViewContact.h>

#include <TVPbkContactStoreUriPtr.h>

#include <VPbkContactStoreUris.h>

// CONSTANTS

_LIT8( KErrorUnrecognizedCommand, "Unrecognized command" );

_LIT8( KErrorVCardImportFailed, "vCard import failed" );

_LIT8( KErrorVCalendarImportFailed, "vCalendar import failed" );

_LIT8( KErrorMissingVCalendar, "Missing vCalendar object" );

_LIT8( KErrorMissingVCard, "Missing vCard object" );

_LIT8( KErrorInvalidId, "Invalid ID parameter" );

_LIT8( KErrorItemNotFound, "Item not found" );

_LIT8( KErrorFailedDelete, "Failed to delete item" );

_LIT8( KErrorFailedDeleteAll, "Failed to delete all items" );

_LIT8( KErrorIdDeleteNotSupported, "Deleting with ID not supported anymore" );

_LIT8( KErrorMissingText, "Text parameter missing" );

_LIT8( KErrorMissingFilepath, "Filepath parameter missing" );

_LIT8( KErrorNotepadAddMemoFailed, "Notepad add memo failed" );

_LIT8( KErrorNotepadAddMemoFromFileFailed, "Notepad add memo from file failed" );

_LIT8( KErrorNotepadDeleteAllFailed, "Notepad delete all failed" );

_LIT( KHtiNpdHlpExe,       "HtiNpdHlp.exe" );

_LIT( KCmdAddMemo,         "AddMemo" );

_LIT( KCmdAddMemoFromFile, "AddMemoFromFile" );

_LIT( KCmdDeleteAll,       "DeleteAll" );

_LIT( KCmdDelim,           " " );

_LIT( KDefaultAgendaFile, "" ); // A default file is opened if fileName is KNullDesC

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

CPIMHandler* CPIMHandler::NewL()

    {

    HTI_LOG_FUNC_IN( "CPIMHandler::NewL" );

    CPIMHandler* self = new (ELeave) CPIMHandler();

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CPIMHandler::Done" );

    return self;

    }

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

CPIMHandler::CPIMHandler():iIsBusy( EFalse ), iEntryViewErr( KErrNone )

    {

    }

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

CPIMHandler::~CPIMHandler()

    {

    HTI_LOG_TEXT( "CPIMHandler destroy" );

    HTI_LOG_TEXT( "Deleting iEntryView" );

    delete iEntryView;

    HTI_LOG_TEXT( "Deleting iCalSession" );

    delete iCalSession;

    if ( iContactView )

        {

        HTI_LOG_TEXT( "Deleting iContactView" );

        iContactView->RemoveObserver( *this );

        delete iContactView;

        }

    HTI_LOG_TEXT( "Deleting iVCardEngine" );

    delete iVCardEngine;

    HTI_LOG_TEXT( "Deleting iContactManager" );

    delete iContactManager;

    HTI_LOG_TEXT( "Deleting iBuffer" );

    delete iBuffer;

    HTI_LOG_TEXT( "Deleting iWaiter" );

    delete iWaiter;

    }

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

void CPIMHandler::ConstructL()

    {

    HTI_LOG_TEXT( "CPIMHandler::ConstructL" );

    iWaiter = new ( ELeave ) CActiveSchedulerWait;

    }

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

void CPIMHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

    {

    iDispatcher = aDispatcher;

    }

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

void CPIMHandler::ProcessMessageL( const TDesC8& aMessage,

    THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CPIMHandler::ProcessMessageL" );

    iIsBusy = ETrue;

    TInt err = KErrNone;

    // Zero legth of aMessage tested already in CHtiPIMServicePlugin.

    // Other sanity checks must be done here.

    iCommand = aMessage.Ptr()[0];

    switch ( iCommand )

        {

        case CHtiPIMServicePlugin::EImportVCard:

            {

            TRAP( err, HandleVCardImportFuncL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            break;

            }

        case CHtiPIMServicePlugin::EImportVCalendar:

            {

            TRAP( err, HandleVCalendarImportFuncL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            break;

            }

        case CHtiPIMServicePlugin::EDeleteContact:

            {

            TRAP( err, HandleContactDeleteFuncL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            break;

            }

        case CHtiPIMServicePlugin::EDeleteCalendar:

            {

            TRAP( err, HandleCalendarDeleteFuncL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            break;

            }

        case CHtiPIMServicePlugin::ENotepadAddMemo:

            {

            TRAP( err, HandleNotepadAddMemoFuncL( aMessage.Mid( 1 ) ) );

            break;

            }

        case CHtiPIMServicePlugin::ENotepadAddMemoFromFile:

            {

            TRAP( err, HandleNotepadAddMemoFromFileFuncL( aMessage.Mid( 1 ) ) );

            break;

            }

        case CHtiPIMServicePlugin::ENotepadDeleteAll:

            {

            TRAP( err, HandleNotepadDeleteAllFuncL() );

            break;

            }

        default:

            {

            TRAP( err, SendErrorMessageL(

                    KErrArgument, KErrorUnrecognizedCommand ) );

            break;

            }

        }

    if ( err != KErrNone )

        {

        iIsBusy = EFalse;

        User::Leave( err );

        }

    HTI_LOG_FUNC_OUT( "CPIMHandler::ProcessMessageL: Done" );

    }

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

TBool CPIMHandler::IsBusy()

    {

    return iIsBusy;

    }

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

void CPIMHandler::HandleVCardImportFuncL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPIMHandler::HandleVCardImportFuncL" );

    if ( aData.Length() == 0 )

        {

        SendErrorMessageL( KErrArgument, KErrorMissingVCard );

        return;

        }

    if ( iBuffer ) // delete if exists (just to be sure)

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    iBuffer = CBufFlat::NewL( aData.Length() );

    iBuffer->ExpandL( 0, aData.Length() );

    HTI_LOG_FORMAT( "Data length = %d", aData.Length() );

    HTI_LOG_FORMAT( "Buffer length = %d", iBuffer->Ptr( 0 ).MaxLength() );

    iBuffer->Ptr( 0 ).Copy( aData );

    if ( iContactManager == NULL )

        {

        CVPbkContactStoreUriArray* uriArray = CVPbkContactStoreUriArray::NewLC();

        uriArray->AppendL( TVPbkContactStoreUriPtr(

            VPbkContactStoreUris::DefaultCntDbUri() ) );

        iContactManager = CVPbkContactManager::NewL( *uriArray );

        CleanupStack::PopAndDestroy( uriArray );

        }

    if ( iVCardEngine == NULL )

        {

        iVCardEngine = CVPbkVCardEng::NewL( *iContactManager );

        }

    MVPbkContactStoreList& stores = iContactManager->ContactStoresL();

    iContactStore = &stores.At( 0 );

    iContactStore->OpenL( *this );

    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleVCardImportFuncL: Done" );

    }

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

void CPIMHandler::HandleVCalendarImportFuncL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPIMHandler::HandleVCalendarImportFuncL" );

    if ( aData.Length() == 0 )

        {

        HTI_LOG_TEXT( "CPIMHandler::HandleVCalendarImportFuncL: Error: length of data is zero" )

        SendErrorMessageL( KErrArgument, KErrorMissingVCalendar );

        return;

        }

    if ( iBuffer ) // delete if exists (just to be sure)

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    iBuffer = CBufFlat::NewL( aData.Length() );

    iBuffer->ExpandL( 0, aData.Length() );

    iBuffer->Ptr( 0 ).Copy( aData );

    RBufReadStream readStream;

    readStream.Open( *iBuffer, 0 );

    CleanupClosePushL( readStream );

    if ( iCalSession == NULL )

        {

        HTI_LOG_TEXT( "CPIMHandler: Creating Calendar session" );

        iCalSession = CCalSession::NewL();

        iCalSession->OpenL( KDefaultAgendaFile );

        HTI_LOG_TEXT( "CPIMHandler: Calendar session open" );

        }

    CCalenImporter* importer = CCalenImporter::NewL( *iCalSession );

    CleanupStack::PushL( importer );

    HTI_LOG_TEXT( "CPIMHandler: Calendar importer created" );

    RPointerArray<CCalEntry> entryArray;

    CleanupClosePushL( entryArray );

    TInt err = KErrNone;

    TInt size = 0;

    importer->SetImportMode( ECalenImportModeExtended );

    // First try to import as iCalendar

    TRAP( err, importer->ImportICalendarL( readStream, entryArray ) );

    HTI_LOG_FORMAT( "ImportICalendarL return value %d", err );

    size = entryArray.Count();

    HTI_LOG_FORMAT( "Import ICalendarL imported %d entries", size );

    // If import didn't succeed, try as vCalendar

    if ( err != KErrNone || size == 0 )

        {

        readStream.Close();

        readStream.Open( *iBuffer, 0 ); // reset read stream

        entryArray.ResetAndDestroy(); // avoid double imports

        TRAP( err, importer->ImportVCalendarL( readStream, entryArray ) );

        HTI_LOG_FORMAT( "ImportVCalendarL return value %d", err );

        size = entryArray.Count();

        HTI_LOG_FORMAT( "Import VCalendarL imported %d entries", size );

        }

    TCalLocalUid uniqueId = 0;

    TInt success = 0;

    if ( size > 0 )

        {

        iEntryView = CCalEntryView::NewL( *iCalSession, *this );

        iWaiter->Start();

        if ( iEntryViewErr == KErrNone )

            {

            TRAP( err, iEntryView->StoreL( entryArray, success ) );

            HTI_LOG_FORMAT( "StoreL return value %d", err );

            HTI_LOG_FORMAT( "Successfully stored %d entries", success );

            uniqueId = entryArray[0]->LocalUidL();

            }

        delete iEntryView;

        iEntryView = NULL;

        }

    entryArray.ResetAndDestroy();

    CleanupStack::PopAndDestroy(); // entryArray

    if ( err == KErrNone && success > 0 )

        {

        TBuf8<8> uniqueIdStr;

        uniqueIdStr.Copy( ( TUint8* ) ( &uniqueId ), sizeof( uniqueId ) );

        SendOkMsgL( uniqueIdStr );

        }

    else

        {

        if ( err == KErrNone ) err = KErrGeneral;

        SendErrorMessageL( err, KErrorVCalendarImportFailed );

        }

    CleanupStack::PopAndDestroy( 2 ); // readStream, importer

    delete iCalSession;

    iCalSession = NULL;

    delete iBuffer;

    iBuffer = NULL;

    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleVCalendarImportFuncL: Done" );

    }

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

void CPIMHandler::HandleContactDeleteFuncL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPIMHandler::HandleContactDeleteFuncL" );

    TInt dataLength = aData.Length();

    if ( dataLength != 0 && dataLength != 4 )

        {

        HTI_LOG_TEXT( "CPIMHandler: Error: wrong length of data" )

        SendErrorMessageL( KErrArgument, KErrorInvalidId );

        return;

        }

    if ( dataLength == 4 )

        {

        SendErrorMessageL( KErrNotSupported, KErrorIdDeleteNotSupported );

        return;

        }

    if ( iContactManager == NULL )

        {

        CVPbkContactStoreUriArray* uriArray = CVPbkContactStoreUriArray::NewLC();

        uriArray->AppendL( TVPbkContactStoreUriPtr(

            VPbkContactStoreUris::DefaultCntDbUri() ) );

        iContactManager = CVPbkContactManager::NewL( *uriArray );

        CleanupStack::PopAndDestroy( uriArray );

        }

    if ( iContactStore == NULL )

        {

        MVPbkContactStoreList& stores = iContactManager->ContactStoresL();

        iContactStore = &stores.At( 0 );

        }

    iContactStore->OpenL( *this );

    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleContactDeleteFuncL" );

    }

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

void CPIMHandler::HandleCalendarDeleteFuncL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPIMHandler::HandleVCalendarDeleteFuncL" );

    TInt dataLength = aData.Length();

    if ( dataLength != 0 && dataLength != 4 )

        {

        HTI_LOG_TEXT( "CPIMHandler: Error: wrong length of data" )

        SendErrorMessageL( KErrArgument, KErrorInvalidId );

        return;

        }

    if ( iBuffer ) // delete if exists (just to be sure)

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    if ( aData.Length() > 0 )

        {

        iBuffer = CBufFlat::NewL( aData.Length() );

        iBuffer->ExpandL( 0, aData.Length() );

        iBuffer->Ptr( 0 ).Copy( aData );

        }

    if ( iCalSession == NULL )

        {

        HTI_LOG_TEXT( "CPIMHandler: Creating Calendar session" );

        iCalSession = CCalSession::NewL();

        iCalSession->OpenL( KDefaultAgendaFile );

        HTI_LOG_TEXT( "CPIMHandler: Calendar session open" );

        }

    HTI_LOG_TEXT( "CPIMHandler: Creating entry view" );

    iEntryView = CCalEntryView::NewL( *iCalSession, *this );

    iWaiter->Start();

    if ( iEntryViewErr != KErrNone )

        {

        delete iEntryView;

        iEntryView = NULL;

        delete iCalSession;

        iCalSession = NULL;

        delete iBuffer;

        iBuffer = NULL;

        User::Leave( iEntryViewErr );

        }

    // If iBuffer is NULL, no ID given, delete all calendar entries

    if ( iBuffer == NULL )

        {

        HTI_LOG_TEXT( "CPIMHandler: Deleting all calendar entries" );

        TCalTime minTime;

        TCalTime maxTime;

        minTime.SetTimeUtcL( TCalTime::MinTime() );

        maxTime.SetTimeUtcL( TCalTime::MaxTime() );

        CalCommon::TCalTimeRange timeRange( minTime, maxTime );

        TRAPD( err, iEntryView->DeleteL( timeRange,

                CalCommon::EIncludeAll, *this ) );

        iWaiter->Start();

        if ( err == KErrNone && iEntryViewErr == KErrNone )

            {

            SendOkMsgL( KNullDesC8 );

            }

        else

            {

            SendErrorMessageL( KErrGeneral, KErrorFailedDeleteAll );

            }

        }

    // If id given, delete only calendar entry having that id

    else

        {

        TPtr8 data = iBuffer->Ptr( 0 );

        TCalLocalUid id = data[0] + ( data[1] << 8 )

                             + ( data[2] << 16 )

                             + ( data[3] << 24 );

        HTI_LOG_FORMAT( "CPIMHandler: Deleting one calendar entry %d", id );

        CCalEntry* entryToDelete = NULL;

        TRAPD( err, entryToDelete = iEntryView->FetchL( id ) );

        if ( err || entryToDelete == NULL )

            {

            HTI_LOG_TEXT( "CPIMHandler: Calendar entry not found" );

            SendErrorMessageL( KErrNotFound, KErrorItemNotFound );

            }

        else

            {

            CleanupStack::PushL( entryToDelete );

            TRAP( err, iEntryView->DeleteL( *entryToDelete ) );

            if ( err == KErrNone )

                {

                SendOkMsgL( KNullDesC8 );

                }

            else

                {

                HTI_LOG_TEXT( "CPIMHandler: Error deleting calendar entry" )

                SendErrorMessageL( KErrGeneral, KErrorFailedDelete );

                }

            CleanupStack::PopAndDestroy( entryToDelete );

            }

        }

    delete iEntryView;

    iEntryView = NULL;

    delete iCalSession;

    iCalSession = NULL;

    delete iBuffer;

    iBuffer = NULL;

    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleVCalendarDeleteFuncL" );

    }

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

void CPIMHandler::SendOkMsgL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CPIMHandler::SendOkMsgL: Starting" );

    User::LeaveIfNull( iDispatcher );

    HBufC8* temp = HBufC8::NewL( aData.Length() + 1 );

    TPtr8 response = temp->Des();

    response.Append( ( TChar ) CHtiPIMServicePlugin::EResultOk );

    response.Append( aData );

    User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(

        temp, KPIMServiceUid ) );

    iIsBusy = EFalse;

    HTI_LOG_FUNC_OUT( "CPIMHandler::SendOkMsgL: Done" );

    }

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

void CPIMHandler::SendErrorMessageL( TInt aError, const TDesC8& aDescription )

    {

    HTI_LOG_FUNC_IN( "CPIMHandler::SendErrorMessageL: Starting" );

    User::LeaveIfNull( iDispatcher );

    User::LeaveIfError( iDispatcher->DispatchOutgoingErrorMessage(

        aError, aDescription, KPIMServiceUid ) );

    iIsBusy = EFalse;

    HTI_LOG_FUNC_OUT( "CPIMHandler::SendErrorMessageL: Done" );

    }

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

TInt CallNpdHlp( const TDesC& aCmd )