/*

* 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:  

*

*/

#include <gdi.h>

#include <utf.h>

#include <barsc.h>

#include <e32std.h>

#include <bautils.h>

#include <implementationproxy.h>

#include <calsession.h>

#include <calenmulticalutil.h>

#include <calenmulticaluids.hrh>

#include <calcalendarinfo.h>

#include <nsmlfolderparser.h>

#include <nsmldefaultagendahandler_1_2.rsg>

#include "nsmldefaultagendahandlerplugin.h"

#include "nsmldefaultagendahandlerutil.h"

#include "nsmldefaultagendahandlerdebug.h"

// CONSTANTS

const TInt KBuffLength = 128;

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

// CNSmlDefaultAgendaHandlerPlugin::NewL

// Two Phase Construction

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

EXPORT_C CNSmlDefaultAgendaHandlerPlugin* CNSmlDefaultAgendaHandlerPlugin::NewL()

	{

	FLOG( _L("CNSmlDefaultAgendaHandlerPlugin::NewL, BEGIN"));

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

	self->ConstructL();

	FLOG( _L("CNSmlDefaultAgendaHandlerPlugin::NewL, END"));

	return self;

	}

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

// CNSmlDefaultAgendaHandlerPlugin::~CNSmlDefaultAgendaHandlerPlugin

// Destructor

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

CNSmlDefaultAgendaHandlerPlugin::~CNSmlDefaultAgendaHandlerPlugin()

	{

	FLOG( _L("CNSmlDefaultAgendaHandlerPlugin::~CNSmlDefaultAgendaHandlerPlugin, BEGIN"));	 

	FLOG( _L("CNSmlDefaultAgendaHandlerPlugin::~CNSmlDefaultAgendaHandlerPlugin, END"));

	}

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

// C++ constructor - not exported;

// implicitly called from NewL()

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

CNSmlDefaultAgendaHandlerPlugin::CNSmlDefaultAgendaHandlerPlugin() 

	{

	FLOG( _L("CNSmlDefaultAgendaHandlerPlugin::CNSmlDefaultAgendaHandlerPlugin, BEGIN"));  

	FLOG( _L("CNSmlDefaultAgendaHandlerPlugin::CNSmlDefaultAgendaHandlerPlugin, END"));

	}

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

// 2nd phase constructor

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

void CNSmlDefaultAgendaHandlerPlugin::ConstructL()

    {

    FLOG( _L("CNSmlDefaultAgendaHandlerPlugin::ConstructL, BEGIN"));

    // Initialize server supports for folder

    iServerSupportsForFolder.iSSName = EFalse;

    iServerSupportsForFolder.iSSCreated = EFalse;

    iServerSupportsForFolder.iSSModified = EFalse;

    FLOG( _L("CNSmlDefaultAgendaHandlerPlugin::ConstructL, END"));

    }

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

// CNSmlDefaultAgendaHandlerPlugin::CheckServerSupportForFolder

// Method to check if needed properties are supported by remote server.

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

void CNSmlDefaultAgendaHandlerPlugin::CheckServerSupportForFolder( const CSmlDataStoreFormat& aServerDataStoreFormat )

    {

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CheckServerSupportForFolder: BEGIN"));

    iServerSupportsForFolder.iSSName = EFalse;

    iServerSupportsForFolder.iSSCreated = EFalse;

    iServerSupportsForFolder.iSSModified = EFalse;

    if ( aServerDataStoreFormat.FolderPropertyCount() == 0 )

        {

        // Server has no restricition on folder property

        iServerSupportsForFolder.iSSName = ETrue;

        iServerSupportsForFolder.iSSCreated = ETrue;

        iServerSupportsForFolder.iSSModified = ETrue;

        return;

        }

    else

        {

        for ( TInt i = 0; 

                   i < aServerDataStoreFormat.FolderPropertyCount(); 

                   i++ )

            {

            if ( aServerDataStoreFormat.FolderProperty( i ).Field().Name().DesC().Compare( KNSmlDataObjectNAME ) == 0 )

                {

                FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CheckServerSupportForFolder: Supports NAME Property"));

                iServerSupportsForFolder.iSSName = ETrue;

                }

            else if ( aServerDataStoreFormat.FolderProperty( i ).Field().Name().DesC().Compare( KNSmlDataObjectCREATED ) == 0 )

                {

                FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CheckServerSupportForFolder: Supports CREATED Property"));

                iServerSupportsForFolder.iSSCreated = ETrue;

                }

            else if ( aServerDataStoreFormat.FolderProperty( i ).Field().Name().DesC().Compare( KNSmlDataObjectMODIFIED ) == 0 )

                {

                FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CheckServerSupportForFolder: Supports MODIFIED Property"));

                iServerSupportsForFolder.iSSModified = ETrue;

                }

            }

        }

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CheckServerSupportForFolder: END"));

    }

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

// CNSmlDefaultAgendaHandlerPlugin::FetchFolderL

// Method to read folder item from database.

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

void CNSmlDefaultAgendaHandlerPlugin::FetchFolderL( const TSmlDbItemUid aUid, RBufWriteStream& aStream )

    {

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::FetchFolderL: begin"));

    // Create parser and set properties

    CNSmlFolderParser* parser = CNSmlFolderParser::NewLC();

    TNSmlParserGeneratorError parseError = EErrorNone;

    HBufC8* generatedBuf = NULL;

    HBufC8* nameBuf = NULL;

    //Get the Folder Information

    CNSmlDefaultAgendaHandlerUtil* agendautil = CalendarInfoL(aUid);

    if( NULL == agendautil )

        {

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::FetchFolderL:Invalid CalendarInfo"));

        CleanupStack::PopAndDestroy( parser );

        User::Leave( KErrNotFound );

        }

    if ( iServerSupportsForFolder.iSSCreated )

        {

        parser->iCreated = agendautil->iCreated;

        }

    else

        {

        parser->iCreated = Time::NullTTime();

        }

    if ( iServerSupportsForFolder.iSSName )

        {

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::FetchFolderL: retrieving name"));

        nameBuf = HBufC8::NewL( agendautil->iName->Length() );

        TPtr8 name( nameBuf->Des() );

        CnvUtfConverter::ConvertFromUnicodeToUtf8(name , agendautil->iName->Des());

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::FetchFolderL: name converted"));

        parser->iName = nameBuf;        

        }    

    // Generate data and write it to buffer   

    generatedBuf = HBufC8::NewLC( 1 );

    generatedBuf->Des() = KNullDesC8;

    CleanupStack::Pop(); // generatedBuf

    parseError = parser->GenerateXml( generatedBuf );

    CleanupStack::PushL( generatedBuf );

    aStream.WriteL( generatedBuf->Des() );

    delete agendautil;

    CleanupStack::PopAndDestroy( generatedBuf ); 

    CleanupStack::PopAndDestroy( parser );

    if ( parseError != EErrorNone )

        {       

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::FetchFolderL(): end with leave"));

        User::Leave( KErrGeneral );

        }

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::FetchFolderL: end"));

    }

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

// CNSmlDefaultAgendaHandlerPlugin::SynchronizableCalendarIdsL

// Retrieve the CalendarFile ID

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

void CNSmlDefaultAgendaHandlerPlugin::SynchronizableCalendarIdsL( CArrayFixFlat<TUint>* aFolderUidArray )

    {

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::SynchronizableCalendarIdsL BEGIN"));

    CCalSession* vCalSession = NULL;

    CCalSession* vCalSubSession = NULL;   

    TBuf8<KBuffLength> keyBuff;

    aFolderUidArray->Reset();

    vCalSession = CCalSession::NewL();

    CleanupStack::PushL(vCalSession);

    CDesCArray* calfilearr = vCalSession->ListCalFilesL();            

    CleanupStack::PushL(calfilearr);

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

        {

        TInt err = KErrNone;

        vCalSubSession = CCalSession::NewL();

        CleanupStack::PushL(vCalSubSession);

        vCalSubSession->OpenL(calfilearr->MdcaPoint(i));

        CCalCalendarInfo* caleninfo = vCalSubSession->CalendarInfoL(); 

        CleanupStack::PushL(caleninfo);

        //Get UID value associated with the CalFile

        keyBuff.Zero();

        TUint UidVal;

        keyBuff.AppendNum( EFolderLUID );

        TPckgC<TUint> pckUidValue(UidVal);

        TRAP(err,pckUidValue.Set(caleninfo->PropertyValueL( keyBuff )));

        UidVal = pckUidValue();

        if( err != KErrNone )

            {

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::SynchronizableCalendarIdsL: Error while retrieving CalFile Property: '%d'"), err);

			CleanupStack::PopAndDestroy(caleninfo);

            CleanupStack::PopAndDestroy(vCalSubSession);  	  	 

            continue;

            }

        //Get OWNER value associated with the CalFile

        keyBuff.Zero();

        TInt SyncServiceOwnerVal;

        keyBuff.AppendNum( EDeviceSyncServiceOwner );

        TPckgC<TInt> pckOwnerValue(SyncServiceOwnerVal);

        TRAP(err,pckOwnerValue.Set(caleninfo->PropertyValueL( keyBuff )));

        SyncServiceOwnerVal = pckOwnerValue();

        if( err == KErrNotFound )

            {

            // Set DS Application as owner

            SyncServiceOwnerVal = KCRUidNSmlDSApp.iUid;

            TPckgC<TInt> pckOwnerValue(SyncServiceOwnerVal);

            caleninfo->SetPropertyL( keyBuff, pckOwnerValue );

            vCalSubSession->SetCalendarInfoL( *caleninfo );

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::SynchronizableCalendarIdsL: Empty Owner LUID '%d'"), UidVal );

            aFolderUidArray->AppendL(UidVal);

            }

        else if( err == KErrNone )

            {

            if( KCRUidNSmlDSApp.iUid == SyncServiceOwnerVal )

                {

                FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::SynchronizableCalendarIdsL: DS Owner LUID '%d'"), UidVal );

                aFolderUidArray->AppendL(UidVal);

                }

            }

        else

            {

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::SynchronizableCalendarIdsL: Error while retrieving Owner Property: '%d'"), err);

            }

        CleanupStack::PopAndDestroy(caleninfo);

        CleanupStack::PopAndDestroy(vCalSubSession); 

        }

    CleanupStack::PopAndDestroy(calfilearr);

    CleanupStack::PopAndDestroy(vCalSession);

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::SynchronizableCalendarIdsL END"));

    }

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

// CNSmlDefaultAgendaHandlerPlugin::CreateFolderItemL

// Creates the Folder item with the stream provided 

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

TCalLocalUid CNSmlDefaultAgendaHandlerPlugin::CreateFolderL( RBufReadStream& aStream )

    {

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CreateFolderItemL BEGIN"));

    TBuf8<KBuffLength> keyBuff;

    TUint calValue = 0;

    CNSmlDefaultAgendaHandlerUtil* agendautil = NULL;

    CCalCalendarInfo* calinfo = CCalCalendarInfo::NewL();

    CleanupStack::PushL(calinfo);    

    // Parse the buffer for the folder data and construct the calendar info   

    agendautil = ParseFolderDataL( aStream );

    if( agendautil )

        {

        // Visibility

        calinfo->SetEnabled( agendautil->iEnabled );

        // LUID Meta Property

        keyBuff.Zero();

        keyBuff.AppendNum( EFolderLUID );

        calValue = CCalenMultiCalUtil::GetNextAvailableOffsetL();

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CreateFolderItemL: nextoffset: '%d'"), calValue);

        TPckgC<TUint> pckgUidValue( calValue );

        calinfo->SetPropertyL( keyBuff, pckgUidValue );      

        // Create & Modified Time Meta Property

        keyBuff.Zero();

        keyBuff.AppendNum( ECreationTime );

        TTime time;

        time.HomeTime();

        TPckgC<TTime> pckgCreateTimeValue( time );

        calinfo->SetPropertyL( keyBuff, pckgCreateTimeValue );

        keyBuff.Zero();

        keyBuff.AppendNum( EModificationTime );

        calinfo->SetPropertyL( keyBuff, pckgCreateTimeValue );

        // Sync Status Meta Property

        keyBuff.Zero();

        keyBuff.AppendNum( ESyncStatus );

        TBool syncstatus( ETrue );

        TPckgC<TBool> pckgSyncStatusValue( syncstatus );

        calinfo->SetPropertyL( keyBuff, pckgSyncStatusValue );

        // Add

        CCalSession* calsession = CCalSession::NewL();

        TInt err(KErrNone);

        if( agendautil->iName != NULL )

            {

            calinfo->SetNameL( agendautil->iName->Des() );

			HBufC* calfilename = CCalenMultiCalUtil::GetNextAvailableCalFileL();

            TRAP( err, calsession->CreateCalFileL( *calfilename, *calinfo ) );

			delete calfilename;

			}

        else

            {

            err = KErrNotFound;

            }

        delete calsession;

        delete agendautil;

        CleanupStack::PopAndDestroy(calinfo);

        if( err != KErrNone )

            {

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CreateFolderItemL: Error while Creating Calfile"));

            User::Leave( KErrGeneral );

            }

        }

    else

        {

        CleanupStack::PopAndDestroy(calinfo);

        User::Leave( KErrGeneral );

        }

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::CreateFolderItemL END"));

    return calValue;   

    }

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

// CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL

// Replaces the Folder item with the ID provided 

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

void CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderL( const TCalLocalUid& aUid, 

                                                      RBufReadStream& aStream, TBool& aSyncStatus )

    {

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL: BEGIN"));

    TBuf8<KBuffLength> keyBuff;

    CNSmlDefaultAgendaHandlerUtil* agendautil = NULL;

    // Parse the buffer for the folder data and construct the calendar info   

    agendautil = ParseFolderDataL( aStream );

    if( agendautil )

        {

        //Get the associated Calendar File 

        CNSmlDefaultAgendaHandlerUtil* updateagendautil = CalendarInfoL( aUid );

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL: After CalendarInfoL '%d'"), updateagendautil);

        if( NULL == updateagendautil )

            {

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:Invalid Updatable CalendarInfo"));

            delete agendautil;

            User::Leave( KErrNotFound );

            }

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:valid CalendarInfo"));

        if( updateagendautil->iFileName != NULL )            

            {            

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:valid name '%S'"), updateagendautil->iFileName);

            CCalSession* vCalSession = CCalSession::NewL();

            CleanupStack::PushL(vCalSession);

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:Open the session")); 

            vCalSession->OpenL(updateagendautil->iFileName->Des());          

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:Get the Calendar Info")); 

            CCalCalendarInfo* caleninfo = vCalSession->CalendarInfoL();  

            CleanupStack::PushL(caleninfo);

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:Set the status"));

            caleninfo->SetEnabled(agendautil->iEnabled);            

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:Set the name"));

            caleninfo->SetNameL(agendautil->iName->Des());

            // Modified Time Meta Property

            keyBuff.Zero();

            keyBuff.AppendNum( EModificationTime );

            TTime time;

            time.HomeTime();

            TPckgC<TTime> pckgCreateTimeValue( time );

            caleninfo->SetPropertyL( keyBuff, pckgCreateTimeValue );

            aSyncStatus = updateagendautil->iSyncStatus;

            // Update

            vCalSession->SetCalendarInfoL(*caleninfo);

            CleanupStack::PopAndDestroy(caleninfo);

            CleanupStack::PopAndDestroy( vCalSession );

            }

        else

            {

            FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:Invalid Updatable CalendarInfo Name"));

            delete agendautil;

            delete updateagendautil;

            User::Leave( KErrNotFound );

            }

        }

    else

        {

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL:Invalid Parsed CalendarInfo"));

        User::Leave( KErrNotFound );

        }

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::ReplaceFolderItemL: END"));

    }

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

// CNSmlDefaultAgendaHandlerPlugin::FolderNameL

// Returns the FolderName for the given ID

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

HBufC* CNSmlDefaultAgendaHandlerPlugin::FolderNameL( TSmlDbItemUid aUid )

    {

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::FolderNameL: BEGIN"));

    HBufC* calfilename = NULL;

    CNSmlDefaultAgendaHandlerUtil* agendautil = CalendarInfoL( aUid );

    if( agendautil != NULL )

        {

        calfilename = agendautil->iFileName->Alloc();

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::foldername: '%S'"), calfilename);

        }    

    delete agendautil;

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::FolderNameL: END"));

    return calfilename;

    }

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

// CNSmlDefaultAgendaHandlerPlugin::StoreFormatL

// Returns adapters supported store format which is read from Calendar Plug

// In Adapter own resource file.

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

CSmlDataStoreFormat* CNSmlDefaultAgendaHandlerPlugin::StoreFormatL( RStringPool& aStringPool )

    {

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::StoreFormatL: BEGIN"));

    TFileName fileName;

    TParse* parse = new(ELeave) TParse();

    CleanupStack::PushL( parse );

    parse->Set( KNSmlDefaultAgendaHandlerRsc_1_2,

                &KDC_RESOURCE_FILES_DIR, NULL );

    fileName = parse->FullName();

    RResourceFile resourceFile;

    RFs rfs;

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

    BaflUtils::NearestLanguageFile( rfs, fileName );

    TRAPD( leavecode, resourceFile.OpenL( rfs,fileName ) );

    if ( leavecode != 0 )

        {

        CleanupStack::PopAndDestroy(); // parse

        rfs.Close();

        FLOG(_L("CNSmlDefaultAgendaHandlerPlugin:::StoreFormatL(): Error END"));

        User::Leave( leavecode );

        }

    CleanupClosePushL( resourceFile );

    HBufC8* buffer = resourceFile.AllocReadLC( NSML_DEFAULT_AGENDA_HANDLER );

    TResourceReader reader;

    reader.SetBuffer( buffer );

    CSmlDataStoreFormat* dsFormat = NULL;

    dsFormat = CSmlDataStoreFormat::NewLC( aStringPool, reader );

    CleanupStack::Pop(); // dsFormat

    CleanupStack::PopAndDestroy( 3 ); // buffer, resourceFile, parse

    rfs.Close();

    FLOG(_L("CNSmlDefaultAgendaHandlerPlugin::StoreFormatL: END"));