/*

* Copyright (c) 2007-2008 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:  Calendar Entry wrapper implementation

*

*/

// INCLUDE FILES

#include "cmrcalentry.h"

#include "esmrhelper.h"

#include "cesmrrecurrenceinfohandler.h"

#include "cesmralarminfohandler.h"

#include "tesmralarminfo.h"

#include "cesmrcaluserutil.h"

#include "cesmrcaldbmgr.h"

#include "esmrentryhelper.h"

#include "cesmrconflictchecker.h"

#include <mrcaleventdata.rsg>

#include <coemain.h>

#include <e32std.h>

#include <aknutils.h>

#include <data_caging_path_literals.hrh>

#include <centralrepository.h>

#include <calentry.h>

#include <calattachment.h>

#include <calalarm.h>

#include <calrrule.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <caleninterimutils2.h>

#include <calendarinternalcrkeys.h>

#include <ct/rcpointerarray.h>

#include <calenservices.h>

#include "emailtrace.h"

namespace { // codescanner::namespace

const TInt KHoursInDay( 24 );

const TInt KDefaultTodoAlarmHours( 12 );

const TInt KDefaultAnniversaryAlarmHours( 12 );

// Definition for max hours, minutes, seconds in day for To-Do

const TInt KMaxHoursForTodo( 23 );

const TInt KMaxMinutesForTodo( 59 );

const TInt KMaxSecondsForTodo( 00 );

// Definition for max hours, minutes, seconds in day for Memo

const TInt KMaxHoursForMemo( 23 );

const TInt KMaxMinutesForMemo( 59 );

const TInt KMaxSecondsForMemo( 59 );

// Definition for default alarm time for meeting

const TInt KDefaultMeetingAlarmMinutes( 15 );

// Definitions for alarm information resource file

_LIT( KAlarmInfoResource, "mrcaleventdata.rsc" );

#ifdef _DEBUG

// Definition for panic text

_LIT( KBCCalEntryPanicTxt, "MRCalEntry" );

enum TBCCalEntryPanic

    {

    EBCCalEntryNotExist = 1, // Entry does not exist

    };

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

// Raises panic.

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

//

void Panic(TBCCalEntryPanic aPanic)

    {

    User::Panic( KBCCalEntryPanicTxt, aPanic);

    }

#endif // _DEBUG

}  // namespace

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

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

// CMRCalEntry::CMRCalEntry

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

//

CMRCalEntry::CMRCalEntry(

        MESMRCalDbMgr& aCalDb  )

:   iCalDb( aCalDb )

    {

    FUNC_LOG;

    }

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

// CMRCalEntry::~CMRCalEntry

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

//

CMRCalEntry::~CMRCalEntry()

    {

    FUNC_LOG;

    delete iEntry;

    delete iOriginalEntry;

    delete iComparativeEntry;

    }

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

// CMRCalEntry::NewL

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

//

CMRCalEntry* CMRCalEntry::NewL(

        CCalEntry& aEntry,

        MESMRCalDbMgr& aCalDb )

    {

    FUNC_LOG;

    CMRCalEntry* self = new (ELeave) CMRCalEntry( aCalDb );

    CleanupStack::PushL( self );

    self->ConstructL( aEntry );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMRCalEntry::ConstructL

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

//

void CMRCalEntry::ConstructL(

        CCalEntry& aEntry )

    {

    FUNC_LOG;

    iOriginalEntry = CreateCopyL( aEntry );

    // Create the entry for editing:

    iEntry = CreateCopyL( *iOriginalEntry );   

    // Create copy of initialized entry for 

    // comparing purposes e.g. IsEntryEdited.

    iComparativeEntry = CreateCopyL( *iEntry );

    }

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

// CMRCalEntry::CreateCopyL

//

CCalEntry* CMRCalEntry::CreateCopyL( CCalEntry& aSourceEntry )

    {

    FUNC_LOG;

    CCalEntry* entry = 

        ESMRHelper::CopyEntryL(

                aSourceEntry,

                aSourceEntry.MethodL(),

                ESMRHelper::ECopyFull );

    return entry;

    }

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

// CMRCalEntry::Type

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

//

MESMRCalEntry::TESMRCalEntryType CMRCalEntry::Type() const

    {

    FUNC_LOG;

    MESMRCalEntry::TESMRCalEntryType type( EESMRCalEntryNotSupported );

    CCalEntry::TType entryType( CCalEntry::EAppt );

    TRAP_IGNORE( {

                 entryType = DoGetEntry()->EntryTypeL();

                 } );

    switch ( entryType )

        {

        case CCalEntry::EAppt:

            {

            type = EESMRCalEntryMeeting;

            break;

            }

        case CCalEntry::ETodo:

            {

            type = EESMRCalEntryTodo;

            break;

            }

        case CCalEntry::EEvent:

            {

            type = EESMRCalEntryMemo;

            break;

            }

        case CCalEntry::EReminder:

            {

            type = EESMRCalEntryReminder;

            break;

            }

        case CCalEntry::EAnniv:

            {

            type = EESMRCalEntryAnniversary;

            break;

            }

        default:

            break;

        }

    return type;

    }

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

// CMRCalEntry::MESMRCalEntryRef

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

//

MESMRCalEntry& CMRCalEntry::MESMRCalEntryRef()

    {

    FUNC_LOG;

    return *this;

    }

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

// CMRCalEntry::MESMRCalEntryRef

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

//

const MESMRCalEntry& CMRCalEntry::MESMRCalEntryRef() const

    {

    FUNC_LOG;

    return *this;

    }

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

// CMRCalEntry::Entry

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

//

const CCalEntry& CMRCalEntry::Entry() const

    {

    FUNC_LOG;

    return *DoGetEntry();

    }

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

// CMRCalEntry::Entry

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

//

CCalEntry& CMRCalEntry::Entry()

    {

    FUNC_LOG;

    return *DoGetEntry();

    }

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

// CMRCalEntry::InstanceL

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

//

CCalInstance* CMRCalEntry::InstanceL() const

    {

    FUNC_LOG;

    CCalInstance* instance = NULL;

    instance = iCalDb.FindInstanceL( *DoGetEntry() );

    if ( !instance )

        {

        // Instance not found by using the edited entry

        // Trying with orginal.

        instance = iCalDb.FindInstanceL( *iComparativeEntry );

        }

    if ( !instance )

        {

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

        // --> Leave

        User::Leave( KErrNotFound );

        }

    return instance;

    }

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

// CMRCalEntry::CanSetRecurrenceL

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

//

TBool CMRCalEntry::CanSetRecurrenceL() const

    {

    FUNC_LOG;

    TBool canSetRecurrence( ETrue );

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

         IsRepeatingMeetingL(*iEntry) &&

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

          MESMRCalEntry::EESMRThisOnly == iRecurrenceModRule ))

        {

        canSetRecurrence = EFalse;

        }

    return canSetRecurrence;

    }

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

// CMRCalEntry::GetRecurrenceL

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

//

void CMRCalEntry::GetRecurrenceL(

        TESMRRecurrenceValue& aRecurrence,

        TTime& aUntil ) const

    {

    FUNC_LOG;

    CESMRRecurrenceInfoHandler* recurrenceHandler =

    		CESMRRecurrenceInfoHandler::NewLC( *DoGetEntry() );

    recurrenceHandler->GetRecurrenceL( aRecurrence, aUntil );

    CleanupStack::PopAndDestroy( recurrenceHandler );

    }

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

// CMRCalEntry::IsAllDayEventL

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

//

TBool CMRCalEntry::IsAllDayEventL() const

    {

    FUNC_LOG;

    TBool allDayEvent(EFalse);

    CCalEntry::TType entryType = DoGetEntry()->EntryTypeL();

    if ( (CCalEntry::EAppt == entryType) || 

         (CCalEntry::EEvent == entryType) )        

    	{    

	    TCalTime startTime = iEntry->StartTimeL();

	    TCalTime stopTime  = iEntry->EndTimeL();

	    TTimeIntervalHours hoursBetweenStartAndEnd;

	    stopTime.TimeLocalL().HoursFrom(

	            startTime.TimeLocalL(),

	            hoursBetweenStartAndEnd );

	    TCalTime::TTimeMode mode = startTime.TimeMode();

	    TInt hoursBetweenStartAndEndAsInt( hoursBetweenStartAndEnd.Int() );

	    TInt alldayDivident( hoursBetweenStartAndEndAsInt % KHoursInDay );

	    if ( hoursBetweenStartAndEndAsInt && 0 == alldayDivident )

	        {

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

	        TDateTime stopTimeLocal =  stopTime.TimeLocalL().DateTime();

            if ( startTimeLocal.Hour() == 0 &&

	             startTimeLocal.Minute() == 0 && 

	             startTimeLocal.Minute() == stopTimeLocal.Minute() && 

	        	 startTimeLocal.Second() == 0 && 

	        	 startTimeLocal.Second() == stopTimeLocal.Second() )

	            {

	            allDayEvent = ETrue;

	            }

	        }

    	}

    return allDayEvent;

    }

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

// CMRCalEntry::SetRecurrenceL

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

//

void CMRCalEntry::SetRecurrenceL(

        TESMRRecurrenceValue aRecurrence,

        TTime aUntil )

    {

    FUNC_LOG;

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

    if ( !CanSetRecurrenceL() )

        {

        User::Leave( KErrNotSupported );

        }

    CESMRRecurrenceInfoHandler* recurrenceHandler =

            CESMRRecurrenceInfoHandler::NewLC( *DoGetEntry() );

    recurrenceHandler->SetRecurrenceL( aRecurrence, aUntil );

    CleanupStack::PopAndDestroy( recurrenceHandler );

    iRecurrenceModRule = MESMRCalEntry::EESMRAllInSeries;

    }

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

// CMRCalEntry::SetAllDayEventL

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

//

void CMRCalEntry::SetAllDayEventL( TTime aStartDate, TTime aEndDate)

    {

    FUNC_LOG;

    TCalTime startTime;

    TCalTime stopTime;

    TDateTime start;

    TDateTime end;

    // set the start time to 0:00

    start.Set( aStartDate.DateTime().Year(),

               aStartDate.DateTime().Month(),

               aStartDate.DateTime().Day(),

               0,

               0,

               0,

               0);

    // set the end date to next day from given end date since

    // all day event should last 24 hours.

    aEndDate += TTimeIntervalDays( 1 );

    end.Set( aEndDate.DateTime().Year(),

             aEndDate.DateTime().Month(),

             aEndDate.DateTime().Day(),

             0,

             0,

             0,

             0);

    startTime.SetTimeLocalL( start );

    stopTime.SetTimeLocalL( end );

    DoGetEntry()->SetStartAndEndTimeL( startTime, stopTime );

    }

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

// CMRCalEntry::IsStoredL

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

//

TBool CMRCalEntry::IsStoredL() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EBCCalEntryNotExist ) );

    TBool ret(EFalse);

    CCalEntry* dbEntry = NULL;

    TRAPD( err, dbEntry = iCalDb.FetchEntryL(

                                iEntry->UidL(),

                                iEntry->RecurrenceIdL() ) );

    if ( KErrNotFound == err )

        {

        // Error has occured while retrieving an entry        

        ret = EFalse;

        }    

    else if ( dbEntry)

        {

        // Entry was found from the calendar db --> it is stored for sure.

        ret = ETrue;

        }

    delete dbEntry;

    return ret;

    }

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

// CMRCalEntry::IsEntryEditedL

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

//

TBool CMRCalEntry::IsEntryEditedL() const

    {

    FUNC_LOG;

    TBool isSame(ETrue);    

    // The compare entry has not been created yet; so 

    // entry has not changed. 

    if ( iComparativeEntry )

        {

        isSame = iComparativeEntry->CompareL( *DoGetEntry() );

        // CCalEntry's CompareL doesn't check the priority value:

        if ( isSame && iEntry->PriorityL() != iComparativeEntry->PriorityL() )

            {

            isSame = EFalse;

            }

        else if ( iEntry->DescriptionL() != iComparativeEntry->DescriptionL() )

            {

            isSame = EFalse;

            }

        else if ( iEntry->LocationL() != iComparativeEntry->LocationL() )

            {

            isSame = EFalse;

            }

        else if ( iEntry->ReplicationStatusL() != iComparativeEntry->ReplicationStatusL() )

            {

            isSame = EFalse;

            }

        if ( IsStoredL() )

            if ( iCalDb.EntryViewL( *iEntry ) != iCalDb.EntryView() )

                {

                isSame = EFalse;

                }

        }

    return !isSame;

    }

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

// CMRCalEntry::IsRecurrentEventL

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

//

TBool CMRCalEntry::IsRecurrentEventL() const

    {