/*

* 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 <calalarm.h>

#include <e32std.h>

#include "cesmrtodotimevalidator.h"

#include "cesmrglobalnote.h"

#include "mesmrfieldstorage.h"

#include "mesmrcalentry.h"

// Unnamed namespace for local definitions

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 zero

const TInt KZero( 0 );

// Definition for half day

const TInt KNoon( 12 );

// Definition for max hours in day

const TInt KMaxHours(23);

// Definition for max minutes in day

const TInt KMaxMinutes(59);

// Definition for max seconsds in day

const TInt KMaxSeconds(00);

#ifdef _DEBUG

// Literal for panics

_LIT( KESMRAnnivTimeValidator, "ESMRAnnivTimeValidator" );

/** Panic code definitions */

enum TESMRAnnivTimeValidator

    {

    /** Start date field not set */

    EESMRAnnivValidatorNullStartDate,

    /** Start date field not set */

    EESMRAnnivValidatorNullAlarmTime,

    /** Start date field not set */

    EESMRAnnivValidatorNullAlarmDate,

    /** Relative alarm called for non-relative alarm event */

    EESMRAnnivValidatorRelativeAlarm

    };

/**

 * Raises system panic.

 * @param aPanic Panic code

 * @see TESMRRecurrentEditValidatorPanic

 */

void Panic( TESMRAnnivTimeValidator aPanic )

    {

    User::Panic( KESMRAnnivTimeValidator, aPanic );

    }

#endif // _DEBUG

/**

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

        }

    }

/**

 * Returns the default alarm time for all day event

 * @param allday event start time

 * @return alarm time

 */

TTime DefaultToDoAlarmL( TTime& aTodoDueDate )

    {

    TDateTime alarmTime = aTodoDueDate.DateTime();

    alarmTime.SetHour( KNoon );

    alarmTime.SetMinute( KZero );

    alarmTime.SetSecond( KZero );

    TTime defaultAlarmTime = alarmTime;

    if ( defaultAlarmTime < KMinTTime )

        {

        defaultAlarmTime = KMinTTime;

        }

    return defaultAlarmTime;

    }

}

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

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

// CESMRTodoTimeValidator::CESMRAnnivTimeValidator()

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

//

inline CESMRTodoTimeValidator::CESMRTodoTimeValidator()

:   iCurrentDueDate( Time::NullTTime() ),

    iCurrentAlarmTime( Time::NullTTime() ),

    iAlarmOnOff( EFalse )

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRTodoTimeValidator::~CESMRTodoTimeValidator

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

//

CESMRTodoTimeValidator::~CESMRTodoTimeValidator( )

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRTodoTimeValidator::NewL

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

//

CESMRTodoTimeValidator* CESMRTodoTimeValidator::NewL()

    {

    FUNC_LOG;

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

    return self;

    }

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

// CESMRTodoTimeValidator::ValidateL

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

//

MESMRFieldValidator::TESMRFieldValidatorError

        CESMRTodoTimeValidator::ValidateL( TBool aCorrectAutomatically )

    {

    FUNC_LOG;

    const MESMRFieldValidator::TESMRFieldValidatorError KErrorNone(

            MESMRFieldValidator::EErrorNone );

    MESMRFieldValidator::TESMRFieldValidatorError error( KErrorNone );

    if ( aCorrectAutomatically )

        {

        ForceValuesL();

        }

    else

        {

        if ( iAlarmOnOff )

            {

            TTime currentTime; currentTime.HomeTime();

            TTime start = DueDateTimeL();

            TTime alarm = AlarmDateTimeL();

            if ( currentTime > alarm )

                {

                error = MESMRFieldValidator::EErrorAlarmInPast;

                }

            if ( start < alarm )

                {

                SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );

                SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );

                error = MESMRFieldValidator::EErrorAlarmLaterThanStart;

                }

            }

        }

    return error;

    }

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

// CESMRTodoTimeValidator::ReadValuesFromEntryL

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

//

void CESMRTodoTimeValidator::ReadValuesFromEntryL(

        MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    if ( MESMRCalEntry::EESMRCalEntryTodo == aEntry.Type() )

        {

        __ASSERT_DEBUG( iDueDate, Panic(EESMRAnnivValidatorNullStartDate) );

        __ASSERT_DEBUG( iAlarmTime, Panic(EESMRAnnivValidatorNullAlarmTime) );

        __ASSERT_DEBUG( iAlarmDate, Panic(EESMRAnnivValidatorNullAlarmDate) );

        iEntry = &aEntry;

        CCalEntry& entry( aEntry.Entry() );

        TCalTime dueDate = entry.EndTimeL();

        iCurrentDueDate = dueDate.TimeLocalL();

        SetDateToEditor( *iDueDate, iCurrentDueDate );

        TDateTime dueDt = iCurrentDueDate.DateTime();

        CCalAlarm* alarm = entry.AlarmL();

        CleanupStack::PushL( alarm );

        if  ( alarm )

            {

            iCurrentAlarmTime = iCurrentDueDate - alarm->TimeOffset();

            iAlarmOnOff = ETrue;

            SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );

            SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );

            }

        CleanupStack::PopAndDestroy( alarm );

        alarm = NULL;

        DrawEditorsDeferred();

        }

    }

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

// CESMRTodoTimeValidator::StoreValuesToEntryL

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

//

void CESMRTodoTimeValidator::StoreValuesToEntryL(

        MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    if ( MESMRCalEntry::EESMRCalEntryTodo == aEntry.Type() )

        {

        PreValidateEditorContent();

        CCalEntry& entry( aEntry.Entry() );

        TTime toEditorDueDate = DueDateTimeL();

        TCalTime todoDueDate;

        // The default mode for To-do is EFloating,

        // But some 3rd party application might have saved a different type

        // for one reason or another. In that case we are using

        // the existing value.

        if ( aEntry.IsStoredL() )

            {

            TCalTime::TTimeMode timeMode =

                            aEntry.Entry().StartTimeL().TimeMode();

            switch ( timeMode )

                {

                case TCalTime::EFixedUtc:

                	{

                    todoDueDate.SetTimeUtcL( toEditorDueDate );

                    break;

                	}

                case TCalTime::EFixedTimeZone:

                	{

                    todoDueDate.SetTimeLocalL( toEditorDueDate );

                    break;

                	}

                case TCalTime::EFloating: // Fall through

                default:

                	{

                    todoDueDate.SetTimeLocalFloatingL( toEditorDueDate );

                    break;

                	}

                }

            }

        else

            {

            todoDueDate.SetTimeLocalFloatingL( toEditorDueDate );

            }

        entry.SetStartAndEndTimeL( todoDueDate, todoDueDate );

        if ( iAlarmOnOff )

            {

            TTimeIntervalMinutes diff;

            TTime alarm = AlarmDateTimeL();

            toEditorDueDate.MinutesFrom( alarm, diff );

            CCalAlarm* alarmObject = entry.AlarmL();

            if ( !alarmObject )

                {

                alarmObject = CCalAlarm::NewL();

                }

            CleanupStack::PushL( alarmObject );

            alarmObject->SetTimeOffset( diff );

            entry.SetAlarmL( alarmObject );

            CleanupStack::PopAndDestroy( alarmObject );

            alarmObject = NULL;

            }

        else

            {

            entry.SetAlarmL( NULL );

            }

        }

    }

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

// CESMRTodoTimeValidator::SetStartTimeFieldL

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

//

void CESMRTodoTimeValidator::SetStartTimeFieldL(

        CEikTimeEditor& /*aStartTime*/ )

    {

    FUNC_LOG;

    // No implementation for memo

    }

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

// CESMRTodoTimeValidator::SetEndTimeFieldL

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

//

void CESMRTodoTimeValidator::SetEndTimeFieldL(

        CEikTimeEditor& /*aEndTime*/ )

    {

    FUNC_LOG;

    // No implementation for to-do

    }

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

// CESMRTodoTimeValidator::SetStartDateFieldL

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

//

void CESMRTodoTimeValidator::SetStartDateFieldL(

        CEikDateEditor& /*aStartDate*/ )

    {

    FUNC_LOG;

    // No implementation for to-do

    }

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

// CESMRTodoTimeValidator::SetEndDateFieldL

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

//

void CESMRTodoTimeValidator::SetEndDateFieldL(

        CEikDateEditor& aEndDate )

    {

    FUNC_LOG;

    iDueDate = &aEndDate;

    }

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

// CESMRTodoTimeValidator::SetAlarmTimeFieldL

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

//

void CESMRTodoTimeValidator::SetAlarmTimeFieldL(

        CEikTimeEditor& aAlarmTime )

    {

    FUNC_LOG;

    iAlarmTime = &aAlarmTime;

    }

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

// CESMRTodoTimeValidator::SetAlarmDateFieldL

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

//

void CESMRTodoTimeValidator::SetAlarmDateFieldL(

        CEikDateEditor& aAlarmDate )

    {

    FUNC_LOG;

    iAlarmDate = &aAlarmDate;

    }

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

// CESMRTodoTimeValidator::SetRecurrenceUntilDateFieldL

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

//

void CESMRTodoTimeValidator::SetRecurrenceUntilDateFieldL(

            CEikDateEditor& /*aRecurrenceUntil*/ )

    {

    FUNC_LOG;

    // No implementation for to-do

    }

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

// CESMRTodoTimeValidator::StartTimeChangedL

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

//

void CESMRTodoTimeValidator::StartTimeChangedL()

    {

    FUNC_LOG;

    StartDateChandedL();

    }

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

// CESMRTodoTimeValidator::EndTimeChangedL

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

//

void CESMRTodoTimeValidator::EndTimeChangedL()

    {

    FUNC_LOG;

    // No implementation for to-do

    }

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

// CESMRTodoTimeValidator::StartDateChandedL

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

//

void CESMRTodoTimeValidator::StartDateChandedL()

    {

    FUNC_LOG;

    // No implementation for to-do

    }

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

// CESMRTodoTimeValidator::EndDateChangedL

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

//

void CESMRTodoTimeValidator::EndDateChangedL()

    {

    FUNC_LOG;

    PreValidateEditorContent();

    TTime due = DueDateTimeL();

    TTimeIntervalDays diff =  due.DaysFrom( iCurrentDueDate );

    iCurrentDueDate = due;

    SetDateToEditor( *iDueDate, iCurrentDueDate );

    if ( iAlarmOnOff )

        {

        TTime alarm = AlarmDateTimeL();

        alarm += diff;

        iCurrentAlarmTime = alarm;

        SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );

        SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );

        }

    DrawEditorsDeferred();

    }

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

// CESMRTodoTimeValidator::AlarmTimeChangedL

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

//

void CESMRTodoTimeValidator::AlarmTimeChangedL()

    {

    FUNC_LOG;

    AlarmDateChangedL();

    }

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

// CESMRTodoTimeValidator::AlarmDateChangedL

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

//

void CESMRTodoTimeValidator::AlarmDateChangedL()

    {

    FUNC_LOG;

    TInt err( KErrNone );

    PreValidateEditorContent();

    TTime due = DueDateTimeL();

    TTime alarm = AlarmDateTimeL();

    if ( alarm > due )

        {

        err = KErrArgument;

        }

    else

        {

        iCurrentAlarmTime = alarm;

        }

    SetTimeToEditor( *iAlarmTime, iCurrentAlarmTime );

    SetDateToEditor( *iAlarmDate, iCurrentAlarmTime );