/*

* Copyright (c) 2007-2010 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:  IETF SIMPLE Protocol implementation for XIMP Framework

*

*/

#include <e32std.h>

#include <e32base.h>

#include <s32strm.h>

#include <e32def.h>

#include <e32svr.h>

#include <e32math.h> 

#include <utf.h>

#include <ximpbase.h>

#include <ximpobjectfactory.h>

#include <ximpobjectcollection.h>

#include <presenceobjectfactory.h>

#include <presenceinfo.h>

#include <personpresenceinfo.h>

#include <presenceinfofieldcollection.h>

#include <presenceinfofield.h>

#include <presenceinfofieldvaluetext.h>

#include <presenceinfofieldvalueenum.h>

#include <ximpidentity.h>

#include <msimpledocument.h>

#include <msimpleelement.h>

#include <msimplepresencelist.h>

#include <msimplemeta.h>

#include <simpleutils.h>

#include <presencecachewriter2.h>

#include <presencecachereader2.h>

#include <presencebuddyinfo.h>

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

#include <spdefinitions.h>

#include <avabilitytext.h>

#include <cvimpstsettingsstore.h>

#include "presenceplugindata.h"

#include "presenceplugincommon.h"

#include "presencepluginvirtualgroup.h"

#include "presencepluginlanguagecodes.h"

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

// CPresencePluginData::CPresencePluginData

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

//

CPresencePluginData::CPresencePluginData( 

	MPresencePluginConnectionObs& aObs,

	TInt aServiceId ):

	iConnObs( aObs ), 

	iServiceId( aServiceId ),

	iPresenceCacheWriter( NULL ),

	iPresenceCacheReader( NULL )

    {

    }

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

// CPresencePluginData::~CPresencePluginData

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

//

CPresencePluginData::~CPresencePluginData()

    {

    DP_SDA("CPresencePluginData::~CPresencePluginData");

    delete iPresenceCacheWriter;

    delete iPresenceCacheReader;

    }

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

// CPresencePluginData::NewL

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

//

CPresencePluginData* CPresencePluginData::NewL( 

	MPresencePluginConnectionObs& aObs, TInt aServiceId )

    {

    CPresencePluginData* self = CPresencePluginData::NewLC( 

		aObs,

		aServiceId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPresencePluginData::ConstructL

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

//

void CPresencePluginData::ConstructL()

    {

    DP_SDA("CPresencePluginData::ConstructL");

    iPresenceCacheWriter =  MPresenceCacheWriter2::CreateWriterL();

    iPresenceCacheReader = MPresenceCacheReader2::CreateReaderL();

    }

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

// CPresencePluginData::NewLC

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

//

CPresencePluginData* CPresencePluginData::NewLC(

    MPresencePluginConnectionObs& aObs, TInt aServiceId )

    {

    CPresencePluginData* self =

    	new( ELeave ) CPresencePluginData( aObs, aServiceId );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CPresencePluginData::NotifyToBlockedToXIMPL

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

//

void CPresencePluginData::NotifyToBlockedToXIMPL(

    MPresenceObjectFactory& aPresenceFactory,

    MPresenceInfo& aPrInfo,

    const TDesC& aUnicodeNoteContent )

    {

    DP_SDA("CPresencePluginData::NotifyToBlockedToXIMPL");

    MPersonPresenceInfo* persInfo =

        aPresenceFactory.NewPersonPresenceInfoLC();

    MPresenceInfoFieldCollection& coll = persInfo->Fields();

    //Set pending

    using namespace NPresenceInfo::NFieldType;

    using namespace NPresencePlugin::NPresenceStates;

    MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

    field->SetFieldTypeL( KAvailabilityEnum );

    // use mapped enums to pass status    

    MPresenceInfoFieldValueEnum* enumField = 

        aPresenceFactory.NewEnumInfoFieldLC();

    // HOX: BLOCKED ENUM NEEDED TO XIMP

    enumField->SetValueL( NPresenceInfo::ENotAvailable ); 

    field->SetFieldValue( enumField );

    coll.AddOrReplaceFieldL( field );

    CleanupStack::Pop( 2 );            // >> field, enumField      

    // Add status msg field

    MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC();

    noteField->SetFieldTypeL( KStatusMessage );

    MPresenceInfoFieldValueText* textField = 

        aPresenceFactory.NewTextInfoFieldLC();

    textField->SetTextValueL( aUnicodeNoteContent );

    noteField->SetFieldValue( textField );

    coll.AddOrReplaceFieldL( noteField );

    CleanupStack::Pop( 2 );            // >> noteField, enumField      

    aPrInfo.SetPersonPresenceL( persInfo );

    CleanupStack::Pop();   // >> persInfo

    DP_SDA("CPresencePluginData::NotifyToBlockedToXIMPL end");

    }

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

// CPresencePluginData::NotifyToPendingToXIMPL

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

//

void CPresencePluginData::NotifyToPendingToXIMPL(

    MPresenceObjectFactory& aPresenceFactory,

    MPresenceInfo& aPrInfo,

    const TDesC& aUnicodeNoteContent )

    {

    DP_SDA("CPresencePluginData::NotifyToPendingToXIMP");

    MPersonPresenceInfo* persInfo =

        aPresenceFactory.NewPersonPresenceInfoLC();

    MPresenceInfoFieldCollection& coll = persInfo->Fields();

    //Set pending

    using namespace NPresenceInfo::NFieldType;

    using namespace NPresencePlugin::NPresenceStates;

    MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

    field->SetFieldTypeL( KAvailabilityEnum );

    // use mapped enums to pass status    

    MPresenceInfoFieldValueEnum* enumField = 

        aPresenceFactory.NewEnumInfoFieldLC();

    enumField->SetValueL( NPresenceInfo::ERemotePending );

    field->SetFieldValue( enumField );

    coll.AddOrReplaceFieldL( field );

    CleanupStack::Pop( 2 );            // >> field, enumField      

    // Add status msg field

    MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC();

    noteField->SetFieldTypeL( KStatusMessage );

    MPresenceInfoFieldValueText* textField = 

        aPresenceFactory.NewTextInfoFieldLC();

    textField->SetTextValueL( aUnicodeNoteContent );

    noteField->SetFieldValue( textField );

    coll.AddOrReplaceFieldL( noteField );

    CleanupStack::Pop( 2 );            // >> noteField, enumField      

    aPrInfo.SetPersonPresenceL( persInfo );

    CleanupStack::Pop();   // >> persInfo

    DP_SDA("CPresencePluginData::NotifyToPendingToXIMP end");

    }

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

// CPresencePluginData::NotifyActiveToPrInfoL

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

//

void CPresencePluginData::NotifyToActiveToXIMPL(

    MPresenceObjectFactory& aPresenceFactory,

    MPresenceInfo& aPrInfo,

    const TDesC& aUnicodeNoteContent,

    NPresenceInfo::TAvailabilityValues aAvailability )

    {

    DP_SDA("CPresencePluginData::NotifyToActiveToXIMPL");

    MPersonPresenceInfo* persInfo =

        aPresenceFactory.NewPersonPresenceInfoLC();

    MPresenceInfoFieldCollection& coll = persInfo->Fields();

    //Set pending

    using namespace NPresenceInfo::NFieldType;

    using namespace NPresencePlugin::NPresenceStates;

    MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

    field->SetFieldTypeL( KAvailabilityEnum );

    // use mapped enums to pass status    

    MPresenceInfoFieldValueEnum* enumField = 

        aPresenceFactory.NewEnumInfoFieldLC();

    enumField->SetValueL( aAvailability );

    field->SetFieldValue( enumField );

    coll.AddOrReplaceFieldL( field );

    CleanupStack::Pop( 2 );            // >> field, enumField      

    // Add status msg field

    MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC();

    noteField->SetFieldTypeL( KStatusMessage );

    MPresenceInfoFieldValueText* textField = 

        aPresenceFactory.NewTextInfoFieldLC();

    textField->SetTextValueL( aUnicodeNoteContent );

    noteField->SetFieldValue( textField );

    coll.AddOrReplaceFieldL( noteField );

    CleanupStack::Pop( 2 );            // >> noteField, enumField      

    aPrInfo.SetPersonPresenceL( persInfo );

    CleanupStack::Pop();   // >> persInfo

    DP_SDA("CPresencePluginData::NotifyToActiveToXIMPL end");

    }

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

// CPresencePluginData::NotifyTerminatedToPrInfoL

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

//

void CPresencePluginData::NotifyTerminatedToXIMPL(

    MPresenceObjectFactory& aPresenceFactory,

    MPresenceInfo& aPrInfo,

    const TDesC& aUnicodeNoteContent )

    {

    DP_SDA("CPresencePluginData::NotifyTerminatedToXIMPL");

    MPersonPresenceInfo* persInfo =

        aPresenceFactory.NewPersonPresenceInfoLC();

    MPresenceInfoFieldCollection& coll = persInfo->Fields();

    //Set pending

    using namespace NPresenceInfo::NFieldType;

    using namespace NPresencePlugin::NPresenceStates;

    MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

    field->SetFieldTypeL( KAvailabilityEnum );

    // use mapped enums to pass status    

    MPresenceInfoFieldValueEnum* enumField = 

        aPresenceFactory.NewEnumInfoFieldLC();

    enumField->SetValueL( NPresenceInfo::EOffline );

    field->SetFieldValue( enumField );

    coll.AddOrReplaceFieldL( field );

    CleanupStack::Pop( 2 );            // >> field, enumField      

    // Add status msg field

    MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC();

    noteField->SetFieldTypeL( KStatusMessage );

    MPresenceInfoFieldValueText* textField = 

        aPresenceFactory.NewTextInfoFieldLC();

    textField->SetTextValueL( aUnicodeNoteContent );

    noteField->SetFieldValue( textField );

    coll.AddOrReplaceFieldL( noteField );

    CleanupStack::Pop( 2 );            // >> noteField, enumField      

    aPrInfo.SetPersonPresenceL( persInfo );

    CleanupStack::Pop();   // >> persInfo

    DP_SDA("CPresencePluginData::NotifyTerminatedToXIMPL end");

    }

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

// CPresencePluginData::NotifyToPrInfoL

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

//

void CPresencePluginData::NotifyToPrInfoL(

    MXIMPObjectFactory& /*aFactory*/,

    MPresenceObjectFactory& aPresenceFactory,

    MSimpleDocument& aDocument,

    MPresenceInfo& aPrInfo )

    {

    DP_SDA("CPresencePluginData::NotifyToPrInfoL");

    MPersonPresenceInfo* persInfo =

        aPresenceFactory.NewPersonPresenceInfoLC();

    DP_SDA("CPresencePluginData::NotifyToPrInfoL persInfo");

    if( !aDocument.EntityURI() )

    	{

    	DP_SDA("CPresencePluginData::NotifyToPrInfoL entity URL not valid");

    	User::Leave( KErrCancel );

    	}

    MPresenceInfoFieldCollection& coll = persInfo->Fields();

    DP_SDA("CPresencePluginData::NotifyToPrInfoL collection");

    // Search own person info. Notice: Extend supported attributes later

    TBool basicElementFound = EFalse;

    TBool activitiesElementFound = EFalse;

    TBool noteElemFound = EFalse;

    DP_SDA("CPresencePluginData::NotifyToPrInfoL RPointerArray");

    RPointerArray<MSimpleElement> elems;

    DP_SDA("CPresencePluginData::NotifyToPrInfoL Push elems");

    CleanupClosePushL( elems );

    DP_SDA("CPresencePluginData::NotifyToPrInfoL aDocument");

    TInt err = aDocument.SimpleElementsL( elems );

    DP_SDA2("CPresencePluginData::NotifyToPrInfoL err %d", err);

    RPointerArray<MSimpleElement> basicElems;

	CleanupClosePushL( basicElems );

	MSimpleElement* basicSimpleElem(NULL);

	RPointerArray<MSimpleElement> activitiesElems;

	CleanupClosePushL( activitiesElems );

	MSimpleElement* activitiesSimpleElem(NULL);

	MSimpleElement* noteSimpleElem(NULL);

    if ( !err )

        {

        DP_SDA("CPresencePluginData::NotifyToPrInfoL, elements ok");       

        TInt count = elems.Count();

        DP_SDA2("CPresencePluginData::NotifyToPrInfoL, element count: %d", count );       

        using namespace NPresencePlugin::NPresence;

        MSimpleElement* elem = NULL;

        TPtrC8 p8;

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

            {

            DP_SDA2("CPresencePluginData::NotifyToPrInfoL, handling elem[%d]", i );

            elem = elems[i];

            p8.Set( elem->LocalName());

            if (!( p8.CompareF( KPresencePerson8 )) ||

                !( p8.CompareF( KPresenceTuple8 )) )

                {

                // person element found

                RPointerArray<MSimpleElement> elems2;

                CleanupClosePushL( elems2 );

                elem->SimpleElementsL( elems2 );

                TInt count2 = elems2.Count();

                DP_SDA2("CPresencePluginData::NotifyToPrInfoL count2 %d", count2);

                for ( TInt j = 0; j < count2; j++ )

                    {

                    DP_SDA("CPresencePluginData::NotifyToPrInfoL 4");

                    //

                    MSimpleElement* elem2 = elems2[j];

                    //FIND BASIC/ACTIVITIES ELEMENT

                    if ( !elem2->LocalName().CompareF( KPresenceStatus8 ) &&

                        !basicElementFound )

             	        {

             	        DP_SDA("NotifyToPrInfoL PresenceStatus");

             	        //Get elem2 childs

			            elem2->SimpleElementsL( basicElems );

			            TInt count3 = basicElems.Count();  //Child count

			            for ( TInt k = 0; k < count3; k++ )

			                {

			                MSimpleElement* tempElem = basicElems[k];

			                if ( !tempElem->LocalName().CompareF( 

			                		KPresenceBasic8 ))

			                    {

			                    DP_SDA("NotifyToPrInfoL basic elem true");

			                    basicSimpleElem = basicElems[k];

			                    basicElementFound = ETrue;

			                    }

			                else if( !tempElem->LocalName().CompareF( 

			                		KPresenceActivities8 ))

			                    {

			                    DP_SDA("NotifyToPrInfoL activities under basic");

			                    activitiesSimpleElem = basicElems[k];

			                    activitiesElementFound = ETrue;

			                    }

			                } 

             	        }

                    //FIND ACTIVITIES ELEMENT

             	    if ( basicElementFound && !activitiesElementFound &&

             	        !elem2->LocalName().CompareF( KPresenceActivities8 ) )

             	        {

             	        DP_SDA("NotifyToPrInfoL activities found outside basic");

			            elem2->SimpleElementsL( activitiesElems );

			            TInt count4 = activitiesElems.Count();

			            for ( TInt l = 0; l < count4; l++ )

			                {

			                activitiesSimpleElem = activitiesElems[l];

			                activitiesElementFound = ETrue;

			                DP_SDA("CPresencePluginData::NotifyToPrInfoL 6");

			                }

             	        }

                    }

                if ( basicElementFound && !noteSimpleElem )

                    {

                    noteSimpleElem = ResolveNoteElementL( elems2 );

                    }

                DP_SDA("NotifyToPrInfoL ALL DONE"); 

                CleanupStack::PopAndDestroy( &elems2 );

                if ( basicElementFound && activitiesElementFound && noteElemFound )

                    {

                    DP_SDA("NotifyToPrInfoL ALL DONE break out"); 

                    //Just handle first status information from document

                    // In future server should support <timestamp>

                    //Also client should be can handle timestaps if there are present

                    break;

                    }

                }

     	    // Check note field    

     	    else if ( basicElementFound && !( p8.CompareF( KPresenceNote8 )) &&

     	         !noteSimpleElem )

     	        {

     	        DP_SDA("NotifyToPrInfoL note field found outside tuple");

	            noteSimpleElem = elem;

     	        }             	    

            }                

        }

    if ( basicElementFound )

    	{

    	DP_SDA("NotifyToPrInfoL basic proceed to handling");

    	SingleUserStatusToXIMPL( 

            aPresenceFactory, basicSimpleElem, 

    		activitiesSimpleElem, noteSimpleElem, coll );  

    	}

    CleanupStack::PopAndDestroy( &activitiesElems );

    CleanupStack::PopAndDestroy( &basicElems );

    CleanupStack::PopAndDestroy( &elems );

    aPrInfo.SetPersonPresenceL( persInfo );

    CleanupStack::Pop();   // >> persInfo

    // TODO2: Notice: the following crashes in old PrFW version

    /*

    aPrInfo.AddDevicePresenceL ( NULL );

    aPrInfo.AddServicePresenceL( NULL );

    */

    DP_SDA("CPresencePluginData::NotifyToPrInfoL end");        

    }

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

// CPresencePluginData::CacheEntriesFromPrInfo

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

//

void CPresencePluginData::CacheEntriesFromPrInfo(

    MPresenceInfo& aPrInfo,

    MPresenceBuddyInfo2::TAvailabilityValues& aAvailability,

    TPtr& aExtendedAvailability,

    TPtr& aStatusMessage )

    {

    DP_SDA("CPresencePluginData::CacheEntriesFromPrInfoL");

    DP_SDA(" -> CacheEntriesFromPrInfoL, fetch status enum field");

    MPresenceInfoField* statusEnumInfoField = NULL;

    MPersonPresenceInfo* presInfo = aPrInfo.PersonPresence();

    if ( presInfo )

        {

        DP_SDA(" -> CacheEntriesFromPrInfoL, has person presence, get field");

        presInfo->Fields().LookupFieldByFieldType( 

            statusEnumInfoField, 

            NPresenceInfo::NFieldType::KAvailabilityEnum );

        DP_SDA(" -> CacheEntriesFromPrInfoL, fetch status enum field done, check item");

        if ( statusEnumInfoField )

            {

            DP_SDA(" -> status enum field found");

            const MPresenceInfoFieldValueEnum* availability = 

            TXIMPGetInterface< const MPresenceInfoFieldValueEnum >::From( 

                statusEnumInfoField->FieldValue(), MXIMPBase::EPanicIfUnknown );

             switch( availability->Value() )

                {

                case NPresenceInfo::EAvailable:

                    {

                    DP_SDA(" -> status enum field => available");

                    aAvailability = MPresenceBuddyInfo2::EAvailable;

                    aExtendedAvailability.Copy( KDefaultAvailableStatus() );

                    }

                    break;