/*

* Copyright (c) 2007-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:  ESMR MR Entry implementation

*

*/

// INCLUDE FILES

//<cmail>

#include "emailtrace.h"

#include "cesmralarminfohandler.h"

#include "cesmrrecurrenceinfohandler.h"

//</cmail>

#include <centralrepository.h>

#include <calalarm.h>

#include "cesmrmeetingrequestentry.h"

#include "cesmrfsmailboxutils.h"

#include "cesmrcaldbmgr.h"

#include "esmrhelper.h"

#include "esmrentryhelper.h"

#include "cesmrconflictchecker.h"

#include "cesmrcaluserutil.h"

#include "esmrconfig.hrh"

#include <esmralarminfo.rsg>

#include <calentry.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <caluser.h>

#include <CalenInterimUtils2.h>

#include <cmrmailboxutils.h>

#include <calrrule.h>

//<cmail>

#include "mmrinfoobject.h"

#include "mmrattendee.h"

//</cmail>

#include <CalendarInternalCRKeys.h>

#include <data_caging_path_literals.hrh>

#include <coemain.h>

#include <calentryview.h>

#include <ct/rcpointerarray.h>

/// Unnamed namespace for local definitions

namespace {

// Alarm resource file location

_LIT( KAlarmInfoResource, "esmralarminfo.rsc" );

// Definition for first index

const TInt KFirstIndex = 0;

// Definition for 0

const TInt KZero = 0;

// Definition for 1

const TInt KOne = 1;

// Definition for number of hours within day

const TInt KHoursInDay = 24;

// Definition for default alarm time for meeting

const TInt KDefaultMeetingAlarmMinutes( 15 );

_LIT( KReplaceLineFeedChar, "\n" );

_LIT( KLineFeed, "\x2029");

/**

 * Finds matching calendar instance from calendar db. Ownership is

 * transferred, If instance cannot be found, NULL is returned.

 *

 * @param aCalDb Reference to cal db manager.

 * @param aEntry Reference to calendar entry

 * @return Pointer to calendar entry instance.

 */

CCalInstance* FindInstanceL(

        MESMRCalDbMgr& aCalDb,

        CCalEntry& aEntry )

    {

    CCalInstance* instance = NULL;

    RCPointerArray<CCalInstance> calInstances;

    CleanupClosePushL( calInstances );

    CCalInstanceView* instanceView =

            aCalDb.NormalDbInstanceView();

    CalCommon::TCalViewFilter instanceFilter =

            CalCommon::EIncludeAppts |

            CalCommon::EIncludeEvents;

    // Removing one seconds from start time and adding one second to stop

    // time. Otherwise wanted entry is not included into results.

    TCalTime startTime;

    startTime.SetTimeLocalL(

        aEntry.StartTimeL().TimeLocalL() - TTimeIntervalSeconds(KOne) );

    TCalTime endTime;

    endTime.SetTimeLocalL(

        aEntry.EndTimeL().TimeLocalL() + TTimeIntervalSeconds(KOne) );

    TDateTime start = startTime.TimeLocalL().DateTime();

    TDateTime end   = endTime.TimeLocalL().DateTime();

    CalCommon::TCalTimeRange timeRange(

            startTime,

            endTime );

    instanceView->FindInstanceL(

            calInstances,

            instanceFilter,

            timeRange);

    TInt instanceCount( calInstances.Count() );

    for (TInt i = 0; (i < instanceCount && !instance); ++i)

        {

        CCalEntry& entry = calInstances[i]->Entry();

        // Finding the entry we are intrested for

        if ( !entry.UidL().Compare( aEntry.UidL() ) )

            {

            instance = calInstances[i];

            calInstances.Remove( i );

            }

        }

    CleanupStack::PopAndDestroy(); // arrayCleanup

    return instance;

    }

#ifdef _DEBUG

// Definition for panic text

_LIT( KESMREntryPanicTxt, "ESMRMeetingRequestEntry" );

/**

 * ES MR Entry panic codes

 */

enum TESMRMeetingRequestEntry

    {

    EESMREntryNotExist = 1, // Entry does not exist

    EESMRInvalidRole,       // Phone owner has invalid role

    EESMRNoInfoObjectAttendeeFound,

    EESMRPhoneOwnerNotSet,

    EESMRRecurrenceError,

    EESMRInvalidReplyType,

    EESMRInvalidInvalidAttendeeStatus,

    EESMRParentNotFound

    };

/**

 * Raises panic.

 * @param aPanic Panic code

 */

void Panic(TESMRMeetingRequestEntry aPanic)

    {

    User::Panic( KESMREntryPanicTxt, aPanic);

    }

#endif // _DEBUG

}  // namespace

// ======== MEMBER FUNCTIONS ========

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

// CESMRMeetingRequestEntry::CESMRMeetingRequestEntry

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

//

inline CESMRMeetingRequestEntry::CESMRMeetingRequestEntry(

        CMRMailboxUtils& aMRMailboxUtils,

        MESMRCalDbMgr& aCalDb,

        TBool aConflictsExists,

        TESMRInputParams* aESMRInputParams )

:   iMRMailboxUtils( aMRMailboxUtils ),

    iConflictsExists( aConflictsExists),

    iCalDb( aCalDb ),

    iESMRInputParams( aESMRInputParams )

    {

    FUNC_LOG;

    // Not yet implementation

    }

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

// CESMRMeetingRequestEntry::~CESMRMeetingRequestEntry

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

//

CESMRMeetingRequestEntry::~CESMRMeetingRequestEntry()

    {

    FUNC_LOG;

    delete iEntry;

    delete iForwardEntry;

    delete iOrginalEntry;

    delete iParameterEntry;

    }

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

// CESMRMeetingRequestEntry::NewL

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

//

CESMRMeetingRequestEntry* CESMRMeetingRequestEntry::NewL(

        const CCalEntry& aEntry,

        CMRMailboxUtils& aMRMailboxUtils,

        MESMRCalDbMgr& aCalDb,

        TBool aConflictsExists,

        TESMRInputParams* aESMRInputParams )

    {

    FUNC_LOG;

    CESMRMeetingRequestEntry* self =

            new (ELeave) CESMRMeetingRequestEntry(

                aMRMailboxUtils,

                aCalDb,

                aConflictsExists,

                aESMRInputParams );

    CleanupStack::PushL( self );

    self->ConstructL( aEntry );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRMeetingRequestEntry::ConstructL

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

//

void CESMRMeetingRequestEntry::ConstructL(

        const CCalEntry& aEntry )

    {

    FUNC_LOG;

    iParameterEntry = ESMRHelper::CopyEntryL(

        aEntry,

        aEntry.MethodL(),

        ESMRHelper::ECopyFull );    

    iEntry = ESMRHelper::CopyEntryL(

        aEntry,

        aEntry.MethodL(),

        ESMRHelper::ECopyFull );

    if ( !IsStoredL() && !IsOpenedFromMail() )

        {

        // by default when creating a meeting the priority value is normal

        SetPriorityL( EFSCalenMRPriorityNormal );

        }

    iOrginalEntry  = ESMRHelper::CopyEntryL(

        aEntry,

        aEntry.MethodL(),

        ESMRHelper::ECopyFull );

    if ( EESMRRoleOrganizer == RoleL() && IsStoredL() )

        {

        // Increase sequence number

        TInt seqNo( iEntry->SequenceNumberL() + 1);

        iEntry->SetSequenceNumberL( seqNo );

        iOrginalEntry->SetSequenceNumberL( seqNo );

        }

    CCalEntry::TMethod method( iEntry->MethodL() );

    if ( CCalEntry::EMethodNone == method )

        {

        iEntry->SetMethodL( CCalEntry::EMethodRequest );

        iOrginalEntry->SetMethodL( CCalEntry::EMethodRequest );

        }

    HBufC* newDescription = ReplaceCharactersFromBufferLC(

                                    iEntry->DescriptionL(),       

                                    KReplaceLineFeedChar(),

                                    KLineFeed() );

    iEntry->SetDescriptionL( *newDescription );

    CleanupStack::PopAndDestroy( newDescription );

    }

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

// CESMRMeetingRequestEntry::ReplaceCharactersFromBufferL

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

//

HBufC* CESMRMeetingRequestEntry::ReplaceCharactersFromBufferLC( const TDesC& aTarget, 

                              const TDesC& aFindString, 

                              const TDesC& aReplacement )

    {

    FUNC_LOG;

    HBufC* newBuffer = aTarget.AllocLC();

    TPtr16 ptr = newBuffer->Des();

    // find next occurance:

    TInt offset = ptr.Find(aFindString);

    while ( offset != KErrNotFound )

        {

        // replace the data:

        ptr.Replace( offset, aFindString.Length(), aReplacement);

        // find next occurance:

        offset = ptr.Find(aFindString);

        }

    return newBuffer;

    }         

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

// CESMRMeetingRequestEntry::Type

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

//

MESMRCalEntry::TESMRCalEntryType CESMRMeetingRequestEntry::Type() const

    {

    FUNC_LOG;

    // This is meeting request

    return MESMRCalEntry::EESMRCalEntryMeetingRequest;

    }

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

// CESMRMeetingRequestEntry::MESMRCalEntryRef

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

//

MESMRCalEntry& CESMRMeetingRequestEntry::MESMRCalEntryRef()

    {

    FUNC_LOG;

    return *this;

    }

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

// CESMRMeetingRequestEntry::MESMRCalEntryRef

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

//

const MESMRCalEntry& CESMRMeetingRequestEntry::MESMRCalEntryRef() const

    {

    FUNC_LOG;

    return *this;

    }

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

// CESMRMeetingRequestEntry::Entry

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

//

CCalEntry& CESMRMeetingRequestEntry::Entry()

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    if ( iForwardEntry )

        {

        return *iForwardEntry;

        }

    return *iEntry;

    }

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

// CESMRMeetingRequestEntry::Entry

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

//

const CCalEntry& CESMRMeetingRequestEntry::Entry() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    if ( iForwardEntry )

        {

        return *iForwardEntry;

        }

    return *iEntry;

    }

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

// CESMRMeetingRequestEntry::InstanceL

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

//

CCalInstance* CESMRMeetingRequestEntry::InstanceL() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    __ASSERT_DEBUG( iOrginalEntry, Panic(EESMREntryNotExist ) );

    CCalInstance* instance = NULL;

    instance = FindInstanceL( iCalDb, *iEntry );

    if ( !instance )

        {

        // Instance not found by using the edited entry

        // Trying with orginal.

        instance = FindInstanceL( iCalDb, *iOrginalEntry );

        }

    if ( !instance )

        {

        // Instance not found by using edited or orginal entry.

        // --> Leave

        User::Leave( KErrNotFound );

        }

    return instance;

    }

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

// CESMRMeetingRequestEntry::CanSetRecurrenceL

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

//

TBool CESMRMeetingRequestEntry::CanSetRecurrenceL() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    TBool canSetRecurrence( ETrue );

    if ( iEntry->EntryTypeL() == CCalEntry::EAppt &&

            ESMREntryHelper::IsRepeatingMeetingL(*iEntry) &&

        (!ESMREntryHelper::IsModifyingEntryL(*iEntry) &&

          MESMRCalEntry::EESMRThisOnly == iRecurrenceModRule ))

        {

        canSetRecurrence = EFalse;

        }

    return canSetRecurrence;

    }

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

// CESMRMeetingRequestEntry::IsRecurrentEventL

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

//

TBool CESMRMeetingRequestEntry::IsRecurrentEventL() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    TBool recurrenceEvent( EFalse );

    if ( IsStoredL() )

        {

        // Entry is stored in calendar db

        // Lets look recurrence using instance

        // Ownership is transferred

        CCalInstance* instance = NULL;

        TRAPD(err, instance = InstanceL() );

        if ( KErrNotFound != err )

            {

            User::LeaveIfError( err );

            }

        if ( instance )

            {

            CleanupStack::PushL( instance );

            CCalEntry& instanceParentEntry = instance->Entry();

            if ( ESMREntryHelper::IsRepeatingMeetingL( instanceParentEntry ) )

                {

                recurrenceEvent = ETrue;

                }

            CleanupStack::PopAndDestroy( instance );

            }

        else if ( ESMREntryHelper::IsRepeatingMeetingL( *iEntry ) )

            {

            recurrenceEvent = ETrue;

            }

        }

    else

        {

        // Entry is not stored in calendar db

        if ( ESMREntryHelper::IsRepeatingMeetingL( *iEntry ) )

            {

            // This is repeating meeting

            recurrenceEvent = ETrue;

            }

        }

    return recurrenceEvent;

    }

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

// CESMRMeetingRequestEntry::SetRecurrenceL

//

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

//

void CESMRMeetingRequestEntry::SetRecurrenceL(

        TESMRRecurrenceValue aRecurrence,

        TTime aUntil )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    // Check if this entry's recurrence can be edited

    if ( !CanSetRecurrenceL() )

        {

        User::Leave( KErrNotSupported );

        }

    if ( aRecurrence != ERecurrenceNot &&

            MESMRCalEntry::EESMRAllInSeries != iRecurrenceModRule )

        {

        // Make sure that mod rule is correct

        SetModifyingRuleL(

                MESMRCalEntry::EESMRAllInSeries );

        }

    CESMRRecurrenceInfoHandler* recurrenceHandler =

            CESMRRecurrenceInfoHandler::NewLC( *iEntry );

    recurrenceHandler->SetRecurrenceL( aRecurrence, aUntil );

    CleanupStack::PopAndDestroy( recurrenceHandler );

    }

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

// CESMRMeetingRequestEntry::GetRecurrenceL

//

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