/*

* 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()     ||

    }

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

// 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() )

        {

            iEntry.ClearRepeatingPropertiesL();

                {

                }

                {

                    {

                    TCalRRule rrule;

                    CalculateRepeatRuleL( Edited().StartDateTime(),

                    iEntry.SetRRuleL( rrule );

                    }

                else

                    {

                    TInt count = rDateList.Count();

                        {

                            {

                                {