/*

* Copyright (c) 2006 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:  CalenEditorDataHandler implements all logic of checking and

*                validating editor data

*

*/

// System includes

#include <calendateutils.h>

#include <calenagendautils.h>

#include <calinstance.h>

#include <calalarm.h>

#include <calentry.h>

#include <calrrule.h>

#include <centralrepository.h>

#include <calattachment.h>

#include <eikenv.h>

#include <CalenInterimUtils2.h>

#include <calencontext.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <calenservices.h>

// User includes

#include "CalenEditorDataHandler.h"

#include "CalendarPrivateCRKeys.h"

#include "CalenDefaultEditors.hrh"

#include "calenentryutil.h"

#include "CleanupResetAndDestroy.h"

#include "calenattachmentutils.h"

#include "calenattachmentinfo.h"

#include "calenattachmentmodel.h"

#include "calenunifiededitor.h"

#include "calendarui_debug.h"

// Constants

#define KNoOfDaysInWeek  7

// ======== LOCAL FUNCTIONS ========

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

// IsTimed

// Returns ETrue if the entry is timed (i.e. an appointment or a

// reminder), EFalse otherwise.

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

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

//

static TBool IsTimed( CCalEntry::TType aEntryType )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return aEntryType == CCalEntry::EAppt || aEntryType == CCalEntry::EReminder;  

    }

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

// ForeverDate

// Returns the date which Calendar presumes to be infinitely far in the future.

// Used, for example, when setting a repeating meeting to repeat forever.

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

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

//

static TTime ForeverDate()

    {

    TRACE_ENTRY_POINT;

    TTime forever = TTime( TDateTime( ECalenForeverYear, static_cast<TMonth>( ECalenForeverMonth ), 

                           ECalenForeverDay, 0, 0, 0, 0) );

    TRACE_EXIT_POINT;

    return forever;

    }

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

// IsForeverDate

// Returns ETrue if the given date is considered by Calendar to be infinitely

// far in the future.

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

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

//

static TBool IsForeverDate( const TTime& aDate )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return CalenDateUtils::OnSameDay( aDate, ForeverDate() );

    }

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

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

// CCalenEditorDataHandler::CCalenEditorDataHandler

// Constructor.

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

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

//

CCalenEditorDataHandler::CCalenEditorDataHandler(

                                            CCalEntry& aEntry,

                                            const TCalTime& aInstanceDateTime,

                                            TBool aIsCreatingNew,

                                            TInt aMaxTextEditorLength,

                                            MCalenServices& aServices,

                                            RArray<TInt>& aCollectionIds)

    : iEntry( aEntry ),

      iInstanceDateTime( aInstanceDateTime ),

      iIsCreatingNew( aIsCreatingNew ),

      iMaxTextEditorLength( aMaxTextEditorLength ),

      iServices( aServices ) , iCalendarFieldEdited(EFalse) , iCollectionIds(aCollectionIds)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenEditorDataHandler::ConstructL

// Two phase construction.

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

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

//

void CCalenEditorDataHandler::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iEntryType = iEntry.EntryTypeL();

    iRecurrenceId = iEntry.RecurrenceIdL();

    iOriginal = CCalenEntryUtil::NewL( iEntry, iInstanceDateTime );

    iEdited = CCalenEntryUtil::NewL( iEntry, iInstanceDateTime );

    if ( IsCreatingNew() )

        {

        SetDefaultNewValuesL( *iOriginal ); // modify iOriginal also

        SetDefaultNewValuesL( *iEdited );

        }

    else

        {

        iInstanceId = iServices.Context().InstanceId();

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenEditorDataHandler::NewL

// Two-phased constructor.

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

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

//

CCalenEditorDataHandler* CCalenEditorDataHandler::NewL(

                                            CCalEntry& aEntry,

                                            const TCalTime& aInstanceDateTime,

                                            TBool aIsCreatingNew,

                                            TInt aMaxTextEditorLength,

                                            MCalenServices& aServices,

                                            RArray<TInt>& aCollectionIds)

    {

    TRACE_ENTRY_POINT;

    CCalenEditorDataHandler* self = new( ELeave ) CCalenEditorDataHandler(

        aEntry, aInstanceDateTime, aIsCreatingNew, aMaxTextEditorLength, aServices,aCollectionIds );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenEditorDataHandler::~CCalenEditorDataHandler

// Destructor.

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

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

//

CCalenEditorDataHandler::~CCalenEditorDataHandler()

    {

    TRACE_ENTRY_POINT;

    delete iOriginal;

    delete iEdited;

    TRACE_EXIT_POINT;

    }

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

// CCalenEditorDataHandler::Edited

// Returns the CCalenEditorDataHandler used to represent the entry the

// user is currently editing.

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

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

//

CCalenEntryUtil& CCalenEditorDataHandler::Edited()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return *iEdited;

    }

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

// CCalenEditorDataHandler::Original

// Returns the CCalenEditorDataHandler used to represent the entry the

// user originally opened.

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

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

//

const CCalenEntryUtil& CCalenEditorDataHandler::Original() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return *iOriginal;

    }

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

// CCalenEditorDataHandler::Entry

// Returns the entry this object is wrapping round.

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

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

//

CCalEntry& CCalenEditorDataHandler::Entry()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iEntry;

    }

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

// CCalenEditorDataHandler::InstanceDateTime

// Returns the instance date/time.

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

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

//

const TCalTime& CCalenEditorDataHandler::InstanceDateTime() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iInstanceDateTime;

    }

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

// CCalenEditorDataHandler::ShouldSaveOrDeleteOrDoNothingL

// Works out whether the entry should be deleted, saved, 

// or whether no action should be taken.

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

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

//

CCalenEditorDataHandler::TAction CCalenEditorDataHandler::ShouldSaveOrDeleteOrDoNothingL()

    {

    TRACE_ENTRY_POINT;

    if ( !IsEditedL() )

        {

        // Not edited at all OR

        // Only added space characters to text fields but not

        // edited the non-text fields

        // no need to save the note

        TRACE_EXIT_POINT;

        return CCalenEditorDataHandler::EActionNothing;        

        }

    // *************** THE NOTE IS EDITED ********************

    if(IsCreatingNew())

        {

        // ************* EDITED NEW NOTE *********   

        // Subject && Location && Description are text fields                   

        // If text fields as a whole is not empty, we can save the note

        // If text fields as a whole IS empty, we can STILL save the note

        // since we edited "non-text" fields

        if ( !NonTextFieldsEditedL() && AreTextFieldsEmptyL() )

            {

            TRACE_EXIT_POINT;

            return CCalenEditorDataHandler::EActionNothing;

            }

        else

            {

            TRACE_EXIT_POINT;

            return CCalenEditorDataHandler::EActionSave;

            }

        }

     // **************** EDITED OLD NOTE **********    

     if(AreTextFieldsClearedL() && !NonTextFieldsEditedL()) // subject && location && description

        {

        // ***** OLD NOTE + TEXT FIELDS EMPTIED + NON-TEXT FIELDS NOT EDITED

        // Even if user may have edited non-text fields, 

        // delete the note 

        TRACE_EXIT_POINT;

        return CCalenEditorDataHandler::EActionDelete;        

        }

    // ****** OLD NOTE WITH TEXT FIELDS **********

    // Save the note, since the text fields contain something

    TRACE_EXIT_POINT;

    return CCalenEditorDataHandler::EActionSave;

    }

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

// CCalenEditorDataHandler::NonTextFieldsEdited

// Returns ETrue if any of the non-text fields (e.g. time fields) of the entry

// have been edited, EFalse otherwise.

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

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

//

TBool CCalenEditorDataHandler::NonTextFieldsEditedL()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return ( IsStartDateTimeEdited() ||

             IsEndDateTimeEdited()   ||

             IsAlarmEditedL()        ||

             IsRepeatRuleEdited()    ||

             IsPriorityEdited()      ||

             IsCalendarEditedL()     ||

             IsAttachmentExists()    ||

             IsEventTypeEdited()     ||

             AllDayFieldEdited() );

    }

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

// CCalenEditorDataHandler::TextFieldsEdited

// Returns ETrue if any of the text fields (e.g. summary) of the entry

// have been edited, EFalse otherwise.

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

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

//

TBool CCalenEditorDataHandler::TextFieldsEdited()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return ( IsSummaryEdited()  || IsLocationEdited() || IsDescriptionEdited()

            || IsAttachmentExists() );

    }

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

// CCalenEditorDataHandler::IsEditedL

// Returns ETrue if the entry has been modified, EFalse otherwise.

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

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

//

TBool CCalenEditorDataHandler::IsEditedL()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return ( TextFieldsEdited() || NonTextFieldsEditedL() );

    }

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

// CCalenEditorDataHandler::WriteChangesToEntryL

// Read the data from the form and set it to the entry.

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

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

//

void CCalenEditorDataHandler::WriteChangesToEntryL( CalCommon::TRecurrenceRange aRepeatTarget )

    {

    TRACE_ENTRY_POINT;

    // This is only place where we can read data from CCalEntry.

    // E.g. when we calculate alarm offset, we need to read start time from

    // entry, not anymore from CCalenEntryUtil.

    TBool isNew = IsCreatingNew();

    WriteStartAndEndTimesToEntryL( aRepeatTarget );

    if ( isNew || IsSummaryEdited() )

        {

        TPtrC summary = Edited().Summary();

        // If text is considered empty, always store as KNullDesC

        if ( CalenAgendaUtils::IsEmptyText( summary ) )

            {

            summary.Set( KNullDesC );

            }

        iEntry.SetSummaryL( summary );

        }

    if ( isNew || IsLocationEdited() )

        {

        TPtrC location = Edited().Location();

        // If text is considered empty, always store as KNullDesC

        if ( CalenAgendaUtils::IsEmptyText( location ) )

            {

            location.Set(KNullDesC);

            }

        iEntry.SetLocationL( location );

        }

    if ( isNew || IsDescriptionEdited() )

        {

        iEntry.SetDescriptionL( Edited().Description() );

        }

    // Repeat rule has to be modified in both cases

    if ( isNew || IsStartDateTimeEdited() || IsRepeatRuleEdited() )

        {

        if ( aRepeatTarget == CalCommon::EThisOnly)

            {

            iEntry.ClearRepeatingPropertiesL();

            }

        else if ( Edited().IsRepeating() )

            {

            // If we're an RDate (with repeat type ERepeatOther), don't try to set an RRule,

            // but don't clear the repeat properties either.

            if( Edited().RepeatType() != ERepeatOther )

                {

                TCalRRule rrule;

                CalculateRepeatRuleL( Edited().StartDateTime(),

                                      Edited().RepeatType(),

                                      Edited().RepeatUntilDateTime(),

                                      rrule );

                iEntry.SetRRuleL( rrule );

                // As there should not be any rdates, remove any that are

                // still present

                RArray<TCalTime> emptyList;

                CleanupClosePushL( emptyList );

                iEntry.SetRDatesL( emptyList );

                CleanupStack::PopAndDestroy(); // emptyList

                }

            else

                {

                // The repeat type is ERepeatOther, therefore as 

                // it is impossible to create an entry of type

                // ERepeat other using the editor either the repeat until

                // date or the start date must have been changed

                // The start date/time has changed, in order for the

                // series to maintain its pattern, any rDates and if

                // present rRule are moved by the same offset

                // The repeat type is ERepeatOther, so check if we have any rdates

                RArray<TCalTime> rDateList;

                CleanupClosePushL( rDateList );

                iEntry.GetRDatesL( rDateList );

                TInt count = rDateList.Count();

                if ( count == 0 )

                    {

                    // There are no rdates so the new until and start date can be applied

                    // directly.

                    TCalRRule rrule;

                    CalculateRepeatRuleL( Edited().StartDateTime(),

                                      Edited().RepeatType(),

                                      Edited().RepeatUntilDateTime(),

                                      rrule );

                    iEntry.SetRRuleL( rrule );

                    }

                else

                    {

                    // There are rDates which need to be checked.

                    if ( IsStartDateTimeEdited() )

                        {

                        // Need to shift any rdates

                        TTime editedStart = iEdited->StartDateTime();

                        TTime origStart = iOriginal->StartDateTime();

                        TTimeIntervalMicroSeconds offSet = editedStart.MicroSecondsFrom( origStart );

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

                            {

                            TCalTime& rDateTime = rDateList[ index ];

                            TTime shiftedTime = rDateTime.TimeUtcL();

                            TDateTime before = shiftedTime.DateTime();

                            shiftedTime += offSet;

                            TDateTime after = shiftedTime.DateTime();

                            rDateTime.SetTimeUtcL( shiftedTime ); 

                            }

                        }

                    //  Check and fix the rDates and rRules match the 

                    //  repeat until date and time.

                    TTime untilTime = Edited().RepeatUntilDateTime();

                    // Remove any rdates that are after the the repeat until date

                    TInt count = rDateList.Count();

                    if ( count > 0 )

                        {

                        TInt index = count - 1;

                        do 

                            {

                            TTime lastRDate = CalenDateUtils::BeginningOfDay( rDateList[ index ].TimeLocalL() );

                            TDateTime before = lastRDate.DateTime();

                            if ( lastRDate > untilTime )

                                {

                                rDateList.Remove( index-- );

                                }

                            else

                                {

                                index = KErrNotFound;

                                }

                            } while ( index != KErrNotFound );

                        }

                    // Need to check if the end date of the

                    // rrule needs adjusting if it exists.

                    TCalRRule rRule;

                    if ( iEntry.GetRRuleL( rRule ) )

                        {

                        count = rDateList.Count();

                        if ( count > 0 )

                            {

                            // There still exists some rdates, so only need to trim 

                            // the rrule if it exists

                            TTime lastRDate = CalenDateUtils::BeginningOfDay( rDateList[ count - 1 ].TimeLocalL() );

                            const TTime& origUntilDate = Original().RepeatUntilDateTime();

                            TTime startDT = rRule.DtStart().TimeLocalL();