/*

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

*

*/

// *** system include files go here:

#include <e32std.h>

#include <s32strm.h>

#include <utf.h>

#include <presenceobjectfactory.h>

#include <presenceinfo.h>

#include <personpresenceinfo.h>

#include <presenceinfofieldcollection.h>

#include <presenceinfofield.h>

#include <presenceinfofieldvaluetext.h>

#include <presenceinfofieldvalueenum.h>

#include <presenceinfofieldvaluebinary.h>

#include <presenceinfofieldvalueenum.h>

#include <presenceerrors.hrh>

#include <ximpobjectfactory.h>

#include <ximpidentity.h>

#include <ximpdatasubscriptionstate.h>

#include <ximpprotocolconnectionhost.h>

#include <ximpstatus.h>

#include <msimpledocument.h>

#include <msimpleelement.h>

#include <msimplepresencelist.h>

#include <msimplemeta.h>

#include <msimplecontent.h>

#include <simpleutils.h>

#include <simplefactory.h>

#include "simpleplugindata.h"

#include "simpleplugincommon.h"

#include "simpleplugindebugutils.h"

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

// CSimplePluginData::CSimplePluginData

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

//

CSimplePluginData::CSimplePluginData( )

    {

    }

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

// CSimplePluginData::~CSimplePluginData

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

//

CSimplePluginData::~CSimplePluginData()

    {

    }

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

// CSimplePluginData::NewL

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

//

CSimplePluginData* CSimplePluginData::NewL( )

    {

    CSimplePluginData* self = CSimplePluginData::NewLC( );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimplePluginData::NewLC

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

//

CSimplePluginData* CSimplePluginData::NewLC( )

    {

    CSimplePluginData* self = new( ELeave ) CSimplePluginData;

    CleanupStack::PushL( self );

    self->ConstructL(  );

    return self;

    }

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

// CSimplePluginData::ConstructL

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

//

void CSimplePluginData::ConstructL( )

    {

    }

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

// CSimplePluginData::NotifyToPrInfoL

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

//

void CSimplePluginData::NotifyToPrInfoL(

        MPresenceObjectFactory& aPresenceFactory,

        MSimpleDocument& aDocument,

        MPresenceInfo& aPrInfo )

    {

    MPersonPresenceInfo* persInfo = aPresenceFactory.NewPersonPresenceInfoLC();

    MPresenceInfoFieldCollection& coll = persInfo->Fields();

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

    RPointerArray<MSimpleElement> elems;

    CleanupClosePushL( elems );

    TInt err = aDocument.SimpleElementsL( elems );

    if ( !err )

        {

        TInt myLatestPosition = SearchLatestTimestampL( elems );

        if ( myLatestPosition != KErrNotFound )

            {

            MSimpleElement* elem = elems[myLatestPosition];

            using namespace NSimplePlugin::NSimpleOma;

            // person element found

            RPointerArray<MSimpleElement> elems2;

            CleanupClosePushL( elems2 );

            elem->SimpleElementsL( elems2 );

            TInt count2 = elems2.Count();

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

                {

                MSimpleElement* elem2 = elems2[j];

                if ( !elem2->LocalName().CompareF( KSimpleOverridingwillingness8 ))

                    {

                    UserOverridingWillingnessToPrFwL( aPresenceFactory, elem2, coll );

                    }

                else if ( !elem2->LocalName().CompareF( KSimpleStatusicon8 ))

                    {

                    UserStatusIconToPrFwL( aPresenceFactory, elem2, coll, aDocument );

                    }

                else if ( !elem2->LocalName().CompareF( KSimpleNote8 ))

                    {

                    UserNoteToPrFwL( aPresenceFactory, elem2, coll );

                    }

                }

            CleanupStack::PopAndDestroy( &elems2 );

            }

        }

    CleanupStack::PopAndDestroy( &elems );

    aPrInfo.SetPersonPresenceL( persInfo );

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

    }

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

// CSimplePluginData::UserOverridingWillingnessToPrFwL

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

//

void CSimplePluginData::UserOverridingWillingnessToPrFwL(

        MPresenceObjectFactory& aPresenceFactory,

        MSimpleElement* aElement,

        MPresenceInfoFieldCollection& aCollection )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginData: UserOverridingWillingnessToPrFwL") );

#endif

    using namespace NSimplePlugin::NSimpleOma;

    RPointerArray<MSimpleElement> elems;

    CleanupClosePushL( elems );

    User::LeaveIfError( aElement->SimpleElementsL( elems ));

    MSimpleElement* elem3 = elems[0]; // notice: we assume that there is no other sub-elements

    if ( !elem3->LocalName().CompareF( KSimpleBasic8 ))

        {

        // write the data into text field.

        HBufC* nodeContent = elem3->ContentUnicodeL();

        CleanupStack::PushL( nodeContent );

        if ( nodeContent )

            {

            // Save availability

            using namespace NPresenceInfo::NFieldType;

            MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

            field->SetFieldTypeL( KAvailability );

            MPresenceInfoFieldValueText* text = aPresenceFactory.NewTextInfoFieldLC();

            text->SetTextValueL( nodeContent->Des() );

            field->SetFieldValue( text );

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

            aCollection.AddOrReplaceFieldL( field );

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

            }

        CleanupStack::PopAndDestroy( nodeContent );

        }

    CleanupStack::PopAndDestroy( &elems );  // close the array, do not delete the content

    }

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

// CSimplePluginData::UserStatusIconToPrFwL

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

//

void CSimplePluginData::UserStatusIconToPrFwL(

        MPresenceObjectFactory& aPresenceFactory,

        MSimpleElement* aElement,

        MPresenceInfoFieldCollection& aCollection,

        MSimpleDocument& aDocument )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginData: UserStatusIconToPrFwL") );

#endif

    using namespace NSimpleDocument;

    using namespace NPresenceInfo::NFieldType;

    HBufC* nodeContent = aElement->ContentUnicodeL();

    CleanupStack::PushL( nodeContent );

    if ( nodeContent )

        {

        RPointerArray<MSimpleContent> contents;

        CleanupClosePushL( contents );

        // Search the corresponding direct content

        aDocument.GetDirectContentsL( contents );

        TInt contCount = contents.Count();

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

            {

            TPtrC8 id = (contents[i])->ContentID();

            // nodecontent = "cid:simple.avatar.com"

            // content-id: simple.avatar.com

            HBufC8* cid8 = NULL;

            cid8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( nodeContent->Des() );

            CleanupStack::PushL( cid8 ); // << cid8

            TInt contentLen = cid8->Des().Length() - 4;  // "cid:"

            TInt headLen = id.Length();

            TPtrC8 pUnquoted( KNullDesC8 );

            if ( id.Locate('"') == 0 )

                {

                // remove "..." characters

                pUnquoted.Set( id.Mid( 1, headLen-2 ));

                }

            else

                {

                pUnquoted.Set( id );

                }

            TInt foundPos = cid8->Des().Find( pUnquoted );

            if ( contentLen == headLen && foundPos >= 0 )

                {

                MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

                field->SetFieldTypeL( KAvatar );

                MPresenceInfoFieldValueBinary* val = aPresenceFactory.NewBinaryInfoFieldLC();

                val->SetMimeTypeL( (contents[i])->ContentType() );

                // Body is not BASE64 encoded internally

                val->SetBinaryValueL( (contents[i])->Body() );

                field->SetFieldValue( val );

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

                aCollection.AddOrReplaceFieldL( field );

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

                }

            CleanupStack::PopAndDestroy( cid8 ); // >> cid8

            }

        CleanupStack::PopAndDestroy( &contents );

        }

    CleanupStack::PopAndDestroy( nodeContent );

    }

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

// CSimplePluginData::UserNoteToPrFwL

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

//

void CSimplePluginData::UserNoteToPrFwL(

        MPresenceObjectFactory& aPresenceFactory,

        MSimpleElement* aElement,

        MPresenceInfoFieldCollection& aCollection )

    {

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginData: UserNoteToPrFwL") );

#endif

    // using namespace NSimplePlugin::NSimpleOma;

    HBufC* nodeContent = aElement->ContentUnicodeL();

    CleanupStack::PushL( nodeContent );

    if ( nodeContent )

        {

        // Save note, convert from unicode

        // notice: consider xml::lang-attribute

        // note <-> KStatusMessage

        using namespace NPresenceInfo::NFieldType;

        MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC();

        field->SetFieldTypeL( KStatusMessage );

        MPresenceInfoFieldValueText* text = aPresenceFactory.NewTextInfoFieldLC();

        text->SetTextValueL( nodeContent->Des() );

        field->SetFieldValue( text );

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

        aCollection.AddOrReplaceFieldL( field );

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

        }

    CleanupStack::PopAndDestroy( nodeContent );

    }

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

// CSimplePluginData::NotifyListToPrInfoL

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

//

void CSimplePluginData::NotifyListToPrInfoL(

    MXIMPObjectFactory& aFactory,

    MPresenceObjectFactory& aPresenceFactory,

    MSimplePresenceList& aList,

    RPointerArray<MPresenceInfo>& aEntities,

    RPointerArray<MXIMPIdentity>& aActives,

    RPointerArray<MXIMPIdentity>& aTerminated,

    TBool& aFullList )

    {

    // Split array into individual prInfos

#ifdef _DEBUG

    PluginLogger::Log(_L("PluginData: NotifyListToPrInfoL") );

#endif

    RPointerArray<MSimpleDocument> docs;

    CleanupClosePushL( docs );

    // get documents, ownership is not transferred.

    aList.GetDocuments( docs );

    CollectAllPresentitiesL( aEntities, aActives, docs, aFactory, aPresenceFactory );

    using namespace NSimplePlugin::NSimpleOma;

    MSimpleMeta* meta = aList.MetaData();

#ifdef _DEBUG

    // TODO: remove

    if ( meta == NULL )

    PluginLogger::Log(_L("PluginData: META Is NULL !!! *****"));

#endif

    // ownership in not transferred

    if ( meta && !meta->LocalName().CompareF( KSimpleList8 ))

        {

        // list element found, find out if fullstate

        const TDesC8* fullStateVal = meta->AttrValue( KSimpleFullState8 );

        if ( fullStateVal && !fullStateVal->CompareF( KSimpleTrue8 ))

            {

            aFullList = ETrue;

            }

        else

            {

            aFullList = EFalse;

            }

#ifdef _DEBUG

        PluginLogger::Log(_L("PluginData: fullState === %d"), aFullList );

#endif

        // Search "terminated" presentities

        RPointerArray<MSimpleElement> elems2;

        CleanupClosePushL( elems2 );

        meta->SimpleElementsL( elems2);

        CollectTerminatedPresentitiesL( aTerminated, elems2, aFactory );

        CleanupStack::PopAndDestroy( &elems2 );

        }

    CleanupStack::PopAndDestroy( &docs );

    }

        /*

        example:

   Content-Transfer-Encoding: binary

   Content-ID: <nXYxAE@pres.vancouver.example.com>

   Content-Type: application/rlmi+xml;charset="UTF-8"

   <?xml version="1.0" encoding="UTF-8"?>

   <list xmlns="urn:ietf:params:xml:ns:rlmi"

         uri="sip:adam-friends@pres.vancouver.example.com"

         version="1" fullState="true">

     <name xml:lang="en">Buddy List at COM</name>

     <name xml:lang="de">Liste der Freunde an COM</name>

     <resource uri="sip:bob@vancouver.example.com"">        <------- note

       <name>Bob Smith</name>

       <instance id="juwigmtboe" state="active"

                 cid="bUZBsM@pres.vancouver.example.com"/>

     </resource>

     <resource uri="sip:dave@vancouver.example.com">

       <name>Dave Jones</name>

       <instance id="hqzsuxtfyq" state="active"

                 cid="ZvSvkz@pres.vancouver.example.com"/>

     </resource>

     <resource uri="sip:ed@dallas.example.net">

       <name>Ed at NET</name>

     </resource>

     <resource uri="sip:adam-friends@stockholm.example.org">

       <name xml:lang="en">My Friends at ORG</name>

       <name xml:lang="de">Meine Freunde an ORG</name>

     </resource>

   </list>

        */

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

// CSimplePluginData::AddPrPersToSimpleDocumentL

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

//

void CSimplePluginData::AddPrPersToSimpleDocumentL(

    const MPersonPresenceInfo* aInfo,

    MSimpleDocument& aDocument,

    const TDesC8& aSipId )

    {

    using namespace NSimpleDocument;

    TPtrC8 p8( KSimpleAvatarCIDURI8 );

    TInt bufSize = p8.Length();

    HBufC16* CIDcontent = HBufC16::NewLC( bufSize );   // << CID

    CIDcontent->Des().Copy( KSimpleAvatarCIDURI8 );

    // notice: we do not generate random id but a static one.

    using namespace NSimplePlugin::NSimpleOma;

    aDocument.SetEntityURIL( aSipId );

    MSimpleElement* persElem = aDocument.AddSimpleElementL(

        KSimpleNsPDM, KSimplePerson8 );

    CleanupClosePushL( *persElem );             // << persElem

    using namespace NPresenceInfo::NFieldType;

    const MPresenceInfoFieldCollection& coll = aInfo->Fields();

    TInt myCount = coll.FieldCount();

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

        {

        const MPresenceInfoField& field =  coll.FieldAt( i );

        const TDesC8& fieldType = field.FieldType();

        const MXIMPBase& storage = field.FieldValue();

        // Notice: tuple id saving for partial data in future.

        /*

        Mapping:

        Avatar -> Person/status-icon

        status-msg -> Person/note

        Availability -> Person/overriding-willingness

        */

        if ( !fieldType.CompareF( KAvatar ) )

            {

            const MPresenceInfoFieldValueBinary* bin =

                  TXIMPGetInterface< const MPresenceInfoFieldValueBinary >::From( storage,

                  MXIMPBase::EReturnNullIfUnknown );

            if ( bin )

                {

                MSimpleElement* elem = persElem->AddSimpleElementL(

                        KSimpleNsRPID,

                        KSimpleStatusicon8 );

                CleanupClosePushL( *elem );             // << elem

                elem->SetContentUnicodeL( CIDcontent->Des());

                // Create the MIME multipart content

                MSimpleContent* content = TSimpleFactory::NewContentL(

                    KSimpleAvatarContent8, bin->MimeType() );

                CleanupClosePushL( *content );          // << content

                content->CopyBodyL( bin->BinaryValue( ) );

                aDocument.AddDirectContentL( *content, EFalse );

                CleanupStack::PopAndDestroy( content );         // >> content

                CleanupStack::PopAndDestroy( elem );  // >> elem

                }

            }

        else if ( !fieldType.CompareF( KStatusMessage ) )

            {

            const MPresenceInfoFieldValueText* text =

                  TXIMPGetInterface< const MPresenceInfoFieldValueText >::From( storage,

                  MXIMPBase::EReturnNullIfUnknown );

            if ( text )

                {

                MSimpleElement* elem = persElem->AddSimpleElementL(

                    KSimpleNsPDM,

                    KSimpleNote8 );

                CleanupClosePushL( *elem );             // << elem

                elem->SetContentUnicodeL( text->TextValue() );

                CleanupStack::PopAndDestroy( elem );  // >> elem

                }

            }

        else if ( !fieldType.CompareF( KAvailability ))

            {

            const MPresenceInfoFieldValueText* text =

                  TXIMPGetInterface< const MPresenceInfoFieldValueText >::From( storage,

                  MXIMPBase::EReturnNullIfUnknown );

            if ( text )

                {

                AddPrPersAvailabilityToDocL( text, persElem );

                }         

            }

        else

            {

            // Notice: currently all the fields in the namespace are supported,

            // but this ensures that if namespace is extended later, it is

            // handled right way in the adaptation

            User::Leave( KPresenceErrPresenceInfoFieldTypeNotSupported );

            }

        }

    CleanupStack::PopAndDestroy( persElem );

    CleanupStack::PopAndDestroy( CIDcontent );

    }

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

// CSimplePluginData::CollectAllPresentitiesL

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

//

void CSimplePluginData::CollectAllPresentitiesL(

    RPointerArray<MPresenceInfo>& aEntities,

    RPointerArray<MXIMPIdentity>& aActives,

    RPointerArray<MSimpleDocument>& aDocs,

    MXIMPObjectFactory& aFactory,

    MPresenceObjectFactory& aPresenceFactory )

    {

    TInt count = aDocs.Count();