/*

* Copyright (c) 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 "mmrabsolutealarmcontroller.h"

#include "cesmrgenericfieldevent.h"

#include "cesmrrecurrenceinfohandler.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;

        }

    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;

        }

    aEditor.SetDate( aDate );

    }

/**

 * Compares two times and returns ETrue if they have same date components

 * @param aLhs Left hand side component

 * @param aRhs Right hand side component

 */

TBool IsSameDay(

        const TDateTime& aLhs,

        const TDateTime& aRhs )

    {

    TBool retValue(EFalse);

    if ( aLhs.Day() == aRhs.Day() &&

         aLhs.Month() == aRhs.Month() &&

         aLhs.Year() == aRhs.Year()   )

        {

        retValue = ETrue;

        }

    return retValue;

    }

} // 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->AnyInstancesBetweenTimePeriodL(

                        		   startTime, 

                        		   endTime ) );

                if ( instanceAlreadyOnThisDay )

                    {

                    error = MESMRFieldValidator::EErrorRescheduleInstance;

                    }

                }

            }

        if (  KErrorNone == error &&  

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

            {

            // Check that is modified entry 

            if ( iEntry->IsRecurrentEventL() &&

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

                {

                TBool instanceAlreadyOnThisDay( 

                           iEntry->AnyInstancesBetweenTimePeriodL(

                        		   startTime, 

                        		   endTime ) );

                if ( instanceAlreadyOnThisDay )

                    {

                    error = MESMRFieldValidator::EErrorRescheduleInstance;

                    }

                }

            }  

        if (  KErrorNone == error &&  

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

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

            {

            // Check that is modified entry 

            if ( iEntry->IsRecurrentEventL() &&

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

                {

                error = ValidateEditedInstanceTimeL();

                }

            }

        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 &&

             iRecurrenceValue != ERecurrenceUnknown )

            {

            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::ValidateEditedInstanceTimeL

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

//

MESMRFieldValidator::TESMRFieldValidatorError CESMRMeetingTimeValidator::ValidateEditedInstanceTimeL()

    { 

    CESMRRecurrenceInfoHandler* recurrenceHandler =

                CESMRRecurrenceInfoHandler::NewLC( iEntry->Entry(), &iEntry->GetDBMgr() );

    TCalTime preStartTime;

    TCalTime preEndTime;

    TCalTime nextStartTime;

    TCalTime nextEndTime;

    CCalInstance* instance = iEntry->InstanceL();

    CleanupStack::PushL( instance );

    TTime instanceDateTime = instance->StartTimeL().TimeLocalL();

    CleanupStack::PopAndDestroy( instance );

    recurrenceHandler->GetPreviousInstanceTimeL( preStartTime, preEndTime, instanceDateTime );

    recurrenceHandler->GetNextInstanceTimeL( nextStartTime, nextEndTime, instanceDateTime );

    CleanupStack::PopAndDestroy( recurrenceHandler );

    const TTime editedStartDateTime( StartDateTime() );

    const TTime editedEndDateTime( EndDateTime() );  

    if( preStartTime.TimeLocalL() != Time::NullTTime() )

        {

        // Does the exception end on/after prevEnd?

        if( editedStartDateTime < preEndTime.TimeLocalL() )

            {

            // Does the exception start after prevStart?

            if( editedStartDateTime > preStartTime.TimeLocalL() )

                {

                return EErrorInstanceOverlapsExistingOne;

                }

            else

                {

                // Does the exception finish after prevStart?

                if( editedEndDateTime > preStartTime.TimeLocalL() )

                    {

                    return EErrorInstanceOverlapsExistingOne;

                    }

                else

                    {

                    return EErrorInstanceOutOfSequence;

                    }

                }

            }

        // Does the exception start on the same day as prevStart?

        if( IsSameDay( StartDateTime(), preStartTime.TimeLocalL().DateTime() ) )

            {

            return EErrorInstanceAlreadyExistsOnThisDay;

            }

        }

    if( nextStartTime.TimeLocalL() != Time::NullTTime() )

        {

        // Does the exception finish on/before nextStart?