/*

* 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 time and date sanity checks and saving

 *

*/

#include "emailtrace.h"

#include <eikmfne.h>

#include <calentry.h>

#include <calinstance.h>

#include <calalarm.h>

#include <calrrule.h>

#include "cesmrmeetingtimevalidator.h"

#include "cesmrglobalnote.h"

#include "mesmrfieldstorage.h"

#include "mesmrcalentry.h"

#include "mesmrmeetingrequestentry.h"

#include "mesmrfieldeventqueue.h"

#include "cesmrgenericfieldevent.h"

// Unnamed namespace for local definitions

namespace { // codescanner::namespace

// Definition fom max possible time

#define KMaxTTime (TTime(TDateTime(2100, EDecember, 31-2, 23, 59, 59, 999999)))

// Definition fom min possible time

#define KMinTTime (TTime(TDateTime(1900, EJanuary, 2-1, 0, 0, 0, 0)))

// Definition for max alarm duration

#define KMaxAlarmTime TTimeIntervalDays(31)

// Definition for alarm time offset, when alarm is off

const TInt KAlarmNotSet(-1);

#ifdef _DEBUG

// Literal for panics

_LIT( KESMRMeetingTimeValidator, "ESMRMeetingTimeValidator" );

/** Panic code definitions */

enum TKESMRMeetingTimeValidator

    {

    /** Start time field not set */

    EESMRMeetingTimeValidatorNullStartTime,

    /** Stop time field not set */

    EESMRMeetingTimeValidatorNullStopTime,

    /** Start date field not set */

    EESMRMeetingTimeValidatorNullStartDate,

    /** Stop date field not set */

    EESMRMeetingTimeValidatorNullStopDate,

    /** Stop time field not set */

    EESMRMeetingTimeValidatorStartLaterThanEnd,

    /** Invalid date field id */

    EESMRMeetingTimeValidatorInvalidDateField

    };

/**

 * Raises system panic.

 * @param aPanic Panic code

 * @see TESMRRecurrentEditValidatorPanic

 */

void Panic( TKESMRMeetingTimeValidator aPanic )

    {

    User::Panic( KESMRMeetingTimeValidator, aPanic );

    }

#endif // _DEBUG

const TInt KZero( 0 );

const TInt KOne( 1 );

const TInt KDaysInWeek( 7 );

const TInt KDaysInFortnight( 14 );

const TInt KNoon(12);

/**

 * Calculates time for next instance for recurrent event.

 * @param aRecurrenceValue Defines the used recurrence.

 * @param aPrevInstanceStartTime Start time of the previous instance.

 */

TTime TimeForNextInstaceStartTime(

        TESMRRecurrenceValue aRecurrenceValue,

        TTime& aPrevInstanceStartTime )

    {

    TTime nextStartTime = aPrevInstanceStartTime;

    switch ( aRecurrenceValue )

        {

        case ERecurrenceDaily:

            {

            nextStartTime += TTimeIntervalDays( KOne );

            }

            break;

        case ERecurrenceWeekly:

            {

            nextStartTime += TTimeIntervalDays( KDaysInWeek );

            }

            break;

        case ERecurrenceEverySecondWeek:

            {

            nextStartTime += TTimeIntervalDays( KDaysInFortnight );

            }

            break;

        case ERecurrenceMonthly:

            {

            nextStartTime += TTimeIntervalMonths( KOne );

            }

            break;

        case ERecurrenceYearly:

            {

            nextStartTime += TTimeIntervalYears( KOne );

            }

            break;

        default:

            nextStartTime = aPrevInstanceStartTime;

            break;

        }

    return nextStartTime;

    }

/**

 * Returns the default alarm time for all day event

 * @param allday event start time

 * @return alarm time

 */

TTime DefaultAlldayEventAlarmTime( TTime& aMeetingStartTime )

    {

    TTime defaultAlarmTime = aMeetingStartTime - TTimeIntervalHours(KNoon);

    if ( defaultAlarmTime < KMinTTime )

        {

        defaultAlarmTime = KMinTTime;

        }

    return defaultAlarmTime;

    }

/**

 * Sets time to editor. Time is checked and adjusted

 * between min and max before setting

 * @param aEditor Reference to time editor

 * @param aTime On return contains the set time.

 */

void SetTimeToEditor(

        CEikTimeEditor& aEditor,

        TTime& aTime )

    {

    if ( aTime < KMinTTime )

        {

        aTime = KMinTTime;

        }

    else if ( aTime > KMaxTTime )

        {

        aTime = KMaxTTime;

        }

    if ( aEditor.IsVisible() )

        {

        aEditor.SetTime( aTime );

        }

    }

/**

 * Sets date to editor. Date is checked and adjusted

 * between min and max before setting

 * @param aEditor Reference to time editor

 * @param aDate On return contains the set date.

 */

void SetDateToEditor(

        CEikDateEditor& aEditor,

        TTime& aDate )

    {

    if ( aDate < KMinTTime )

        {

        aDate = KMinTTime;

        }

    else if ( aDate > KMaxTTime )

        {

        aDate = KMaxTTime;

        }

    if ( aEditor.IsVisible() )

        {

        aEditor.SetDate( aDate );

        }

    }

} // namespace

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

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

// CESMRMeetingTimeValidator::CESMRMeetingTimeValidator

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

//

inline CESMRMeetingTimeValidator::CESMRMeetingTimeValidator()

:   iRecurrenceValue( ERecurrenceNot ),

    iCurrentStartTime( Time::NullTTime() ),

    iCurrentEndTime( Time::NullTTime() ),

    iCurrentAlarmTime( Time::NullTTime() ),

    iCurrentRecurrenceUntil( Time::NullTTime() ),

    iStartTimeBeforeAlldayEvent( Time::NullTTime() ),

    iEndTimeBeforeAlldayEvent( Time::NullTTime() ),

    iAlldayEvent( EFalse ),

    iAlarmOnOff( EFalse ),

    iComparativeStartTime( Time::NullTTime().DateTime() )

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRMeetingTimeValidator::~CESMRMeetingTimeValidator

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

//

CESMRMeetingTimeValidator::~CESMRMeetingTimeValidator( )

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRMeetingTimeValidator::NewL

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

//

CESMRMeetingTimeValidator* CESMRMeetingTimeValidator::NewL( )

    {

    FUNC_LOG;

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

    return self;

    }

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

// CESMRMeetingTimeValidator::ValidateL

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

//

MESMRFieldValidator::TESMRFieldValidatorError

        CESMRMeetingTimeValidator::ValidateL(

                    TBool aCorrectAutomatically )

    {

    FUNC_LOG;

    MESMRFieldValidator::TESMRFieldValidatorError KErrorNone(

            MESMRFieldValidator::EErrorNone );

    MESMRFieldValidator::TESMRFieldValidatorError error(

            MESMRFieldValidator::EErrorNone );

    if( aCorrectAutomatically )

        {

        ForceValuesL();

        }

    else

        {

        TTime startTime = StartDateTime();

        TTime endTime = EndDateTime();

        // In recurrent events if user has changed the start date and

        // presses Save or Done, we have to force the end date to same

        // value as start date and modify the recurrence until according

        // to the new start time value

        if ( ERecurrenceNot != iRecurrenceValue &&

                ( startTime.DateTime().Day() != endTime.DateTime().Day() ||

                startTime.DateTime().Month() != endTime.DateTime().Month() ||

                startTime.DateTime().Year() != endTime.DateTime().Year() ) )

            {

            endTime = ForceEndDateTime();

            SetTimeToEditor( *iEndTime, endTime );

            SetDateToEditor( *iEndDate, endTime );

            // We have to also adjust the recurrence until time

            // according to the new start time

            TTime newUntil = ForceRecurrenceUntilTime();

            SetDateToEditor( *iRecurrenceUntilDate, newUntil );

            }

        TTime currentAlarmTime = startTime - iCurrentAlarmTimeOffset;

        TTime currentTime;

        currentTime.HomeTime();

        if ( endTime < startTime )

            {

            error = MESMRFieldValidator::EErrorEndEarlierThanStart;

            }

        if ( KErrorNone == error && ERecurrenceNot != iRecurrenceValue )

            {

            TDateTime startDt = startTime.DateTime();

            TDateTime endDt = endTime.DateTime();

            if ( startDt.Day() != endDt.Day() ||

                    startDt.Month() != endDt.Month() ||

                    startDt.Year() != endDt.Year() )

                {

                error = MESMRFieldValidator::EErrorRecDifferetStartAndEnd;

                }

            if ( KErrorNone == error &&

                 ERecurrenceNot != iRecurrenceValue &&

                 iRecurrenceUntilDate && iRecurrenceUntilDate->IsVisible() )

                {

                TTime recurUntil = RecurrenceUntilTime();

                if ( ERecurrenceUnknown != iRecurrenceValue &&

                     recurUntil < startTime )

                    {

                    error = MESMRFieldValidator::EErrorRecUntilEarlierThanStart;

                    }

                }

            }

        if (  KErrorNone == error &&  

              MESMRCalEntry::EESMRCalEntryMeetingRequest == iEntry->Type() )

            {

            // Check that is modified entry 

            MESMRMeetingRequestEntry* mrEntry = 

                    static_cast<MESMRMeetingRequestEntry*>( iEntry );

            if ( mrEntry->IsRecurrentEventL() &&

                 MESMRCalEntry::EESMRThisOnly == mrEntry->RecurrenceModRule() )

                {

                TBool instanceAlreadyOnThisDay( 

                           mrEntry->AnyInstanceOnDayL(startTime, endTime) );

                if ( instanceAlreadyOnThisDay )

                    {

                    error = MESMRFieldValidator::EErrorRescheduleInstance;

                    }

                }

            }         

        if ( KErrorNone == error && iAlldayEvent && iAlarmOnOff )

            {

            TTime alarmTime = AlarmDateTime();

            if ( alarmTime > startTime )

                {

                SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );

                SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );

                error = MESMRFieldValidator::EErrorAlarmLaterThanStart;

                }

            TTime currentTime;

            currentTime.HomeTime();

            if ( KErrorNone == error && alarmTime < currentTime )

                {

                error = MESMRFieldValidator::EErrorAlarmInPast;

                }

            if ( KErrorNone == error && alarmTime < startTime )

                {

                TTimeIntervalDays alarmBefore = startTime.DaysFrom(alarmTime);

                if ( alarmBefore > KMaxAlarmTime )

                    {

                    error =  MESMRFieldValidator::EErrorAlarmTooMuchInPast;

                    }

                }

            }

        MESMRCalEntry::TESMRRecurrenceModifyingRule rule =

            MESMRCalEntry::EESMRThisOnly;

        // Checking if entry is recurrent

        if ( iEntry->IsRecurrentEventL())

            {

            // Getting the recurrence information

            rule = iEntry->RecurrenceModRule();

            }

        // Showing error note if alarm in past, when

        // entry has no recurrence

        if ( KErrorNone == error &&

             currentAlarmTime < currentTime &&

             !iAlldayEvent &&

             iCurrentAlarmTimeOffset.Int() != KAlarmNotSet &&

             iRecurrenceValue == ERecurrenceNot )

            {

            error = MESMRFieldValidator::EErrorRelativeAlarmInPast;

            }

        TTime until;

        if ( iRecurrenceValue != ERecurrenceNot &&

            {

            until = RecurrenceUntilTime();

            // Showing error note if is alarm in past, 

            // when entry has recurrence

            if ( KErrorNone == error &&

                 iCurrentAlarmTimeOffset.Int() != KAlarmNotSet &&

                 until < currentTime &&

                 rule != MESMRCalEntry::EESMRAllInSeries )

                {

                error = MESMRFieldValidator::EErrorRelativeAlarmInPast;

                }

            }

        }

    return error;

    }

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

// CESMRMeetingTimeValidator::ReadValuesFromEntryL

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

//

void CESMRMeetingTimeValidator::ReadValuesFromEntryL(

        MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    MESMRCalEntry::TESMRCalEntryType entryType( aEntry.Type() );

    if ( MESMRCalEntry::EESMRCalEntryMeetingRequest == entryType ||

         MESMRCalEntry::EESMRCalEntryMeeting == entryType   )

        {

        // Meeting or meeting request

        __ASSERT_DEBUG(

                iStartTime,

                Panic(EESMRMeetingTimeValidatorNullStartTime) );

        __ASSERT_DEBUG(

                iEndTime,

                Panic(EESMRMeetingTimeValidatorNullStopTime) );

        __ASSERT_DEBUG(

                iStartDate,

                Panic(EESMRMeetingTimeValidatorNullStartTime) );

        __ASSERT_DEBUG(

                iEndDate,

                Panic(EESMRMeetingTimeValidatorNullStopTime) );

        iEntry = &aEntry;

        CCalEntry& entry( aEntry.Entry() );

        iCurrentStartTime = entry.StartTimeL().TimeLocalL();

        iCurrentEndTime   = entry.EndTimeL().TimeLocalL();

        //Comparative start time required for comparisons in editor

        //recurrence handling

        iComparativeStartTime = iCurrentStartTime.DateTime();

        if ( aEntry.IsAllDayEventL() )

            {

            iCurrentEndTime -= TTimeIntervalDays( KOne );

            }

        TTime start = iCurrentStartTime;

        TTime end = iCurrentEndTime;

        SetTimeToEditor( *iStartTime, start );

        SetDateToEditor( *iStartDate, start );

        SetTimeToEditor( *iEndTime, end );

        SetDateToEditor( *iEndDate, end );

        ReadAlarmFromEntryL( entry );

        ReadRecurrenceFromEntryL( aEntry );

        DrawEditorsDeferred();

        }

    }

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

// CESMRMeetingTimeValidator::StoreValuesToEntryL

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

//

void CESMRMeetingTimeValidator::StoreValuesToEntryL(

        MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    CCalEntry& entry( aEntry.Entry() );

    // Before writing start and end time to enty, let's

    // check is currently edited entry exception for series

    // If entry is an exception and start time is set after

    // repeat until date; the calinterim API will delete

    // the recurrence rules from entry, so the

    // solution to avoid this is to move the repeat until date

    // to match the new start and end time for this exception entry.

    if ( ERecurrenceNot == iRecurrenceValue &&

         aEntry.IsRecurrentEventL() &&

         MESMRCalEntry::EESMRThisOnly == aEntry.RecurrenceModRule() )

        {

        TCalRRule originalRRule;

        if ( iEntry->Entry().GetRRuleL( originalRRule ) )

            {

            TTime localUntilTime = originalRRule.Until().TimeLocalL();

            TTime endTime = EndDateTime();

            TDateTime datetimeendtime = endTime.DateTime();

            TDateTime datetimelocalUntil = localUntilTime.DateTime();

            if ( endTime > localUntilTime )

                {

                TCalRRule rRule;

                rRule.SetDtStart( originalRRule.DtStart() );

                rRule.SetType( originalRRule.Type() );

                TCalTime newUntil;

                newUntil.SetTimeLocalL( endTime );

                rRule.SetUntil( newUntil );

                rRule.SetInterval( originalRRule.Interval() );

                iEntry->Entry().SetRRuleL( rRule );

                }

            }

        }

    else if ( aEntry.IsRecurrentEventL() &&

              MESMRCalEntry::EESMRAllInSeries == aEntry.RecurrenceModRule() )

        {

        TTime orgStartTime = iEntry->Entry().StartTimeL().TimeLocalL();

        TTime orgEndTime = iEntry->Entry().EndTimeL().TimeLocalL();

        if ( orgStartTime != StartDateTime() ||