/*

* 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:  This class contains utility method implementation 

*               related to usage of Calendar Interim API.

*

*/

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

// INCLUDE FILES

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

//

#include "CalenInterimUtils2Impl.h"

//debug

#include "calendarengines_debug.h"

#include <calentry.h>

#include <caluser.h>

#include <calentryview.h>

#include <etelmm.h>

#include <e32math.h>

#include <calrrule.h>

#include <cmrmailboxutils.h>

#include <featmgr.h>

#include <MeetingRequestUids.hrh>

#include <ecom/ecom.h>

#include <utf.h>

#include <openssl/md5.h>

#include <string.h>

#include "CleanupResetAndDestroy.h"

#include "RImplInfoPtrArrayOwn.inl"

#include "CalenEcomWatcher.h"       // Watches for ECOM registry changes

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

#ifdef __WINSCW__

    _LIT( KEmulatorImei, "123456789012345" );

#endif

    const TInt KImeiLength = 15; // 15 chars from left of imei

    const TInt KAsciiFirstNumber = 48;             // ASCII character 48 = '0'.

    const TInt KAsciiFirstLowercaseLetter = 97;    // ASCII character 97 = 'a'.

}  // namespace

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

// MEMBER FUNCTIONS

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

//

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

// CCalenInterimUtils2Impl::NewL()

// Creates and returns a new CCalenInterimUtils2Impl object.

// (other items were commented in a header).

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

CCalenInterimUtils2Impl* CCalenInterimUtils2Impl::NewL()

    {

    TRACE_ENTRY_POINT;

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenInterimUtils2Impl::CCalenInterimUtils2Impl()

// Default constructor

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

CCalenInterimUtils2Impl::CCalenInterimUtils2Impl()

    {

    TRACE_ENTRY_POINT;

    iMrEnabledCheck = ETrue;

    iMrEnabled = EFalse;

    TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::ConstructL()

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

void CCalenInterimUtils2Impl::ConstructL()

    {

    TRACE_ENTRY_POINT;

    FeatureManager::InitializeLibL();

    // Only start the ecom watcher if the feature flags are on.

    if ((FeatureManager::FeatureSupported(KFeatureIdMeetingRequestEnabler)) || 

        (FeatureManager::FeatureSupported(KFeatureIdMeetingRequestSupport)) )

        {

        iEcomWatcher  = CCalenEComWatcher::NewL(*this);

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::~CCalenInterimUtils2Impl()

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

CCalenInterimUtils2Impl::~CCalenInterimUtils2Impl()

    {

    TRACE_ENTRY_POINT;

    delete iEcomWatcher;

	FeatureManager::UnInitializeLib();

	TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::PopulateChildFromParentL

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

void CCalenInterimUtils2Impl::PopulateChildFromParentL(CCalEntry& aChild, const CCalEntry& aParent)

    {

    TRACE_ENTRY_POINT;

    if ( aChild.DescriptionL() == KNullDesC )

        {

        aChild.SetDescriptionL( aParent.DescriptionL() );

        }

    if ( aChild.LocationL() == KNullDesC )

        {

        aChild.SetLocationL( aParent.LocationL() );

        }

    if ( aChild.PriorityL() == 0 )

        { // zero is undefined priority according to iCal spec.

        aChild.SetPriorityL( aParent.PriorityL() );

        }

    if ( aChild.SummaryL() == KNullDesC )

        {

        aChild.SetSummaryL( aParent.SummaryL() );

        }

    if ( aChild.StatusL() == CCalEntry::ENullStatus )

        {

        aChild.SetStatusL( aParent.StatusL() );

        }

    CCalAlarm* childAlarm = aChild.AlarmL();

    CCalAlarm* parentAlarm = aParent.AlarmL();

    CleanupStack::PushL(childAlarm);

    CleanupStack::PushL(parentAlarm);

    if( !childAlarm && parentAlarm )

        {

        aChild.SetAlarmL( parentAlarm);

        }

    CleanupStack::PopAndDestroy(childAlarm);

    CleanupStack::PopAndDestroy(parentAlarm);

    if (aChild.ReplicationStatusL() != aParent.ReplicationStatusL())

        {

        aChild.SetReplicationStatusL(aParent.ReplicationStatusL());

        }

    if (aChild.MethodL() == CCalEntry::EMethodNone)

        {

        aChild.SetMethodL(aParent.MethodL());

        }

    if ( !aChild.OrganizerL() && aParent.OrganizerL() )

        {

        CCalUser* owner = CopyUserLC( *( aParent.OrganizerL() ) );

        aChild.SetOrganizerL( owner );

        CleanupStack::Pop(owner); // ownership transferred

        }

    PopulateAttendeeListL( aChild, aParent );

    TRACE_EXIT_POINT;

    // "Categories" property is omitted

    }

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

// CCalenInterimUtils2Impl::PopulateAttendeeListL

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

//

void CCalenInterimUtils2Impl::PopulateAttendeeListL(

    CCalEntry& aChild,

    const CCalEntry& aParent )

    {

    TRACE_ENTRY_POINT;

    RPointerArray<CCalAttendee>& childAtt = aChild.AttendeesL();

    RPointerArray<CCalAttendee>& parentAtt = aParent.AttendeesL();

    CCalUser *po = NULL;

    if ( !aChild.PhoneOwnerL() )

        { // Phone owner is internal data, not part of ical protocol, it's

          // benefit is to avoid heavy "who am I?" resolving operation

        po = aParent.PhoneOwnerL();

        }

    TInt parentAttCount( parentAtt.Count() );

    if ( childAtt.Count() == 0 && parentAttCount > 0 )

        {

        for ( TInt i( 0 ); i < parentAttCount; ++i )

            {

            CCalAttendee* copy = CopyAttendeeLC( *( parentAtt[i] ) );

            aChild.AddAttendeeL( copy );

            CleanupStack::Pop(copy); // ownership transferred

            if(po == parentAtt[i])

                {

                aChild.SetPhoneOwnerL(copy);

                }

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenInterimUtils2Impl::CopyAttendeeLC

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

//

CCalAttendee* CCalenInterimUtils2Impl::CopyAttendeeLC(

    const CCalAttendee& aSource )

    {

    TRACE_ENTRY_POINT;

    CCalAttendee* copy = CCalAttendee::NewL( aSource.Address(),

                                             aSource.SentBy() );

    CleanupStack::PushL( copy );

    copy->SetCommonNameL( aSource.CommonName() );

    copy->SetRoleL( aSource.RoleL() );

    copy->SetStatusL( aSource.StatusL() );

    copy->SetResponseRequested( aSource.ResponseRequested() );

    TRACE_EXIT_POINT;

    return copy;

    }

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

// CCalenInterimUtils2Impl::CopyUserLC

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

//

CCalUser* CCalenInterimUtils2Impl::CopyUserLC( const CCalUser& aSource )

    {

    TRACE_ENTRY_POINT;

    CCalUser* copy = CCalUser::NewL( aSource.Address(),

                                     aSource.SentBy() );

    CleanupStack::PushL( copy );

    copy->SetCommonNameL( aSource.CommonName() );

    TRACE_EXIT_POINT;

    return copy;

    }

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

// CCalenInterimUtils2Impl::GlobalUidL

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

//

HBufC8* CCalenInterimUtils2Impl::GlobalUidL()

    {

    TRACE_ENTRY_POINT;

    // Loosely using UID generation algorithm from

    // http://www.webdav.org/specs/draft-leach-uuids-guids-01.txt

    // Number of 100ns ticks since Oct 15 1582.

    TInt64 timeStamp = GetTicksFromGregorianCalendarStartL();

    // This differs slightly from the spec in that the clock sequence is just a pseudo-random number.

       TUint32 clockSeq = Math::Random();

       // IMEI is read the first time this is called, and stored for subsequent calls.

       if(!iImeiNode)

           {

           iImeiNode = GetImeiAsNodeValueL();

           }

    HBufC8* resultBuf = DoCreateUidLC(clockSeq, timeStamp, iImeiNode);

    CleanupStack::Pop(resultBuf);

    TRACE_EXIT_POINT;

    return resultBuf;

    }

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

// CCalenInterimUtils2Impl::GetTicksFromGregorianCalendarStartL()

// This function returns the number of 100ns ticks since 0:00 15th October 1582.

// (other items were commented in a header).

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

//

TInt64 CCalenInterimUtils2Impl::GetTicksFromGregorianCalendarStartL()

    {

    TRACE_ENTRY_POINT;

    TTime timeNow;

    timeNow.HomeTime();

    TDateTime gregorianStartDT(1582, EOctober, 15, 0, 0, 0, 0);

    TTime gregorianStart(gregorianStartDT);

    TTimeIntervalMicroSeconds msDifference = timeNow.MicroSecondsFrom(gregorianStart);

    TRACE_EXIT_POINT;

    return msDifference.Int64() * 10; // * 10 to convert from micro sec (==1000 ns) count to 100ns count.

    }

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

// CCalenInterimUtils2Impl::GetImeiAsNodeValueL()

// Formats the IMEI returned from GetImeiL() into a 64-bit integer.

// (other items were commented in a header).

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

//

TInt64 CCalenInterimUtils2Impl::GetImeiAsNodeValueL()

    {

    TRACE_ENTRY_POINT;

    TBuf<RMobilePhone::KPhoneSerialNumberSize> serialNumber;

    GetImeiL( serialNumber );

    // Trim off all but the first KImeiLength digits.

    TLex lex( serialNumber.Left(KImeiLength) );

    TInt64 val;

    User::LeaveIfError(lex.Val(val));

    TRACE_EXIT_POINT;

    return val;

    }

inline TUint8 LastFourBits(TUint8& aNum)

    {

    TRACE_ENTRY_POINT;

    // 00001111 b

    TRACE_EXIT_POINT;

    return aNum & 0x0F;

    }

inline TUint8 FirstFourBits(TUint8& aNum)

    {

    TRACE_ENTRY_POINT;

    // 11110000 b

    TRACE_EXIT_POINT;

    return (aNum & 0xF0) >> 4;

    }

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

// CCalenInterimUtils2Impl::DoCreateUidLC()

// Performs the work in creating a GUID.

// (other items were commented in a header).

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

//

HBufC8* CCalenInterimUtils2Impl::DoCreateUidLC( const TUint32& aClockSeq,

                                               const TUint64& aTimeStamp,

                                               const TUint64& aNodeValue )

    {

    TRACE_ENTRY_POINT;

    // The roast beef of the algorithm. Does all the shifting about as described in the web draft.

    TUint32 time_low = aTimeStamp & 0xFFFFFFFF;

    TUint16 time_mid = (aTimeStamp >> 32) & 0xFFFF;

    TUint16 time_high = (aTimeStamp >> 48) & 0x0FFF;

    time_high |= (1 << 12);

    TUint8 clock_seq_low = aClockSeq & 0xFF;

    TUint8 clock_seq_high = (aClockSeq & 0x3F00) >> 8;

    clock_seq_high |= 0x80;

    // Can't use RArray as that's set up for minimum 4 bytes per item.

    CArrayFixFlat<TUint8> *node = new (ELeave) CArrayFixFlat<TUint8>(6);

    CleanupStack::PushL(node);

    // The rest of the function is mapping the 64, 32 and 16 bit numbers to 8 bit numbers

    // while losing as little data as possible.

    TUint64 mask = 0xFF0000000000;

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

        {

        TInt64 temp = aNodeValue & mask;

        temp >>= ((5-i)*8);

        node->AppendL(temp);

        mask = mask >> 8;

        }

    TBuf8<16> rawOutput;

    rawOutput.Append( (time_low  & 0xFF000000) >> 24 );

    rawOutput.Append( (time_low  & 0x00FF0000) >> 16 );

    rawOutput.Append( (time_low  & 0x0000FF00) >> 8 );

    rawOutput.Append( (time_low  & 0x000000FF) );

    rawOutput.Append( (time_mid  & 0xFF00) >> 8 );

    rawOutput.Append( (time_mid  & 0x00FF) );

    rawOutput.Append( (time_high & 0xFF00) >> 8 );

    rawOutput.Append( (time_high & 0x00FF) );

    rawOutput.Append( clock_seq_low );

    rawOutput.Append( clock_seq_high );

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

        {

        rawOutput.Append( node->At(i) );

        }

    CleanupStack::PopAndDestroy(); // node

    TUint8 digest[16];

    HBufC8* resultBuf = rawOutput.AllocLC();

    TPtr8 resultBufPtr = resultBuf->Des();

    TUint length = resultBufPtr.Length();

    // Create a new buffer to provide space for '\0'

    HBufC8* newBuf = HBufC8::NewLC( length + 1 );//+1 space for '\0'

    TPtr8 newBufPtr = newBuf->Des();

    newBufPtr.Copy(resultBufPtr);

    // Appends a zero terminator onto the end of this descriptor's data

    // and returns a pointer to the data.

    char* chPtrTemp = ( char*)newBufPtr.PtrZ();

    char* chPtr = ( char*) User::AllocL( length + 1 );

    strcpy( chPtr , chPtrTemp );

    //md5 context

    MD5_CTX* context = new MD5_CTX();

    //initialize the context

    MD5_Init(context);

    //Append a string to the message

    MD5_Update(context, chPtr, length );

    //Finish the message and return the digest.

    MD5_Final(digest, context );

    // Add the version field in the msb 4 bits. The value of version is 3.

    digest[6] = digest[6] & 0x0F;

    digest[6] |= (3 << 4);

    //Add the variant field in the msb 2 bits. The value of variant is 2.

    digest[9] = digest[9] & 0x3F;

    digest[9] |= 0x80;

    delete chPtr;

    delete context;

    CleanupStack::PopAndDestroy( newBuf );

    CleanupStack::PopAndDestroy( resultBuf );

    TBuf8<36> output;

    TInt i;

    for(i=0; i<16; ++i)

        {

        output.Append( ConvertToCharacterL( FirstFourBits( digest[i] ) ) ); 

        output.Append( ConvertToCharacterL( LastFourBits( digest[i] ) ) );

        if(i == 3 || i == 5 || i == 7 ||i == 9)

            {

            output.Append( '-' );

            }

        }

    HBufC8* md5ResultBuf = output.AllocLC();

    TRACE_EXIT_POINT;

    return md5ResultBuf;

    }

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

// CCalenInterimUtils2Impl::ConvertToCharacterL()

// Converts from a number between 0-15 to a hexadecimal character representation.

// 0-9, a-f

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

//

TChar CCalenInterimUtils2Impl::ConvertToCharacterL(TUint8 aChar)

    {

    TRACE_ENTRY_POINT;

    if(aChar < 10)

        {

        // Convert to a digit.

        TRACE_EXIT_POINT;

        return TChar(aChar + KAsciiFirstNumber);

        }

    else if(aChar < 16)

        {

        // Convert to lower case character.

        TRACE_EXIT_POINT;

        return TChar(aChar - 10 + KAsciiFirstLowercaseLetter);

        }

    // This function should only be passed numbers between 0-15.

    User::Leave(KErrArgument);

    TRACE_EXIT_POINT;

    return TChar(KAsciiFirstLowercaseLetter); // Stops compiler warning.

    }

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

// CCalenInterimUtils2Impl::GetImeiL

// Gets the IMEI of the device. On the emulator, this will return a fake IMEI.

// (other items were commented in a header).

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

//

void CCalenInterimUtils2Impl::GetImeiL( TDes& aImei )

    {

    TRACE_ENTRY_POINT;

    #ifndef __WINSCW__

    RTelServer telServer;

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

    CleanupClosePushL(telServer);

    TInt numPhones = 0;

    User::LeaveIfError( telServer.EnumeratePhones(numPhones) );

    if(numPhones < 1)

        {

        User::Leave(KErrNotFound);

        }

    RTelServer::TPhoneInfo info;

    User::LeaveIfError( telServer.GetPhoneInfo(0, info) );

    RMobilePhone mobilePhone;

    User::LeaveIfError( mobilePhone.Open(telServer, info.iName) );