/*

* 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:  Implementation of the class CESMRMixedFieldStorage

*

*/

#include "emailtrace.h"

#include "cesmrmixedfieldstorage.h"

//<cmail>

#include "cesmrpolicy.h"

#include "esmrdef.h"

//</cmail>

#include "cesmrmeetingtimevalidator.h"

#include "tesmrentryfield.h"

#include "mesmrresponseobserver.h"

#include "mesmrcalentry.h"

#include "cesmrvalidatorfactory.h"

#include "cesmrglobalnote.h"

#include "cesmrfield.h"

#include "cesmrfieldeventqueue.h"

// Unnamed namespace for local definitions

namespace { // codescanner::namespace

/**

 * Tests, if entry has valid recurrence for editing.

 * @param aEntry Reference to entry.

 * @param aRecurrenceValue On return contains entrys recurrence

 * @return ETrue, if entry has valid recurrence for editing.

 *         EFalse, if entry hasn't valid recurrence for editing.

 */

TBool HasValidRecurrenceForEditingL(

        const MESMRCalEntry& aEntry,

        TESMRRecurrenceValue& aRecurrenceValue )

    {

    TBool retValue( ETrue );

    if ( aEntry.IsRecurrentEventL() )

        {

        TTime until;

        aEntry.GetRecurrenceL( aRecurrenceValue, until );

        if ( ERecurrenceNot == aRecurrenceValue ||

             ERecurrenceUnknown == aRecurrenceValue )

            {

            // Entry has unrecognized recurrende type

            // --> Cannot be edited.

            retValue = EFalse;

            }

        }

    return retValue;

    }

void ShowValidationErrorL(

        const MESMRFieldValidator::TESMRFieldValidatorError& aError,

        TESMREntryFieldId& aUpdatedFocus )

    {

    FUNC_LOG;

    TInt err( KErrArgument );

    switch ( aError )

        {

        case MESMRFieldValidator::EErrorEndEarlierThanStart:

            {

            aUpdatedFocus = EESMRFieldMeetingTime;

            CESMRGlobalNote::ExecuteL(

                    CESMRGlobalNote::EESMREntryEndEarlierThanItStart );

            }

            break;

        case MESMRFieldValidator::EErrorRecDifferetStartAndEnd:

            {

            aUpdatedFocus = EESMRFieldStopDate;

            CESMRGlobalNote::ExecuteL(

                    CESMRGlobalNote::EESMRRepeatDifferentStartAndEndDate );

            }

            break;

        case MESMRFieldValidator::EErrorRecUntilEarlierThanStart:

            {

            aUpdatedFocus = EESMRFieldRecurrenceDate;

            CESMRGlobalNote::ExecuteL(

                    CESMRGlobalNote::EESMRRepeatEndEarlierThanItStart );

            }

            break;

        case MESMRFieldValidator::EErrorAlarmLaterThanStart:

            {

            aUpdatedFocus = EESMRFieldAlarmDate;

            CESMRGlobalNote::ExecuteL(

                    CESMRGlobalNote::EESMRCalenLaterDate );

            }

            break;

        case MESMRFieldValidator::EErrorAlarmInPast:

            {

            aUpdatedFocus = EESMRFieldAlarmDate;

            CESMRGlobalNote::ExecuteL(

                    CESMRGlobalNote::EESMRAlarmAlreadyPassed );

            }

            break;

        case MESMRFieldValidator::EErrorRescheduleInstance:

            {

            CESMRGlobalNote::ExecuteL(

                                CESMRGlobalNote::EESMRRepeatReSchedule );

            }

            break;

        case MESMRFieldValidator::EErrorInstanceOverlapsExistingOne:

            {

            CESMRGlobalNote::ExecuteL(

                                CESMRGlobalNote::EESMROverlapsExistingInstance );

            }

            break;

        case MESMRFieldValidator::EErrorInstanceAlreadyExistsOnThisDay:

            {

            CESMRGlobalNote::ExecuteL(

                                CESMRGlobalNote::EESMRInstanceAlreadyExistsOnThisDay );

            }

            break;

        case MESMRFieldValidator::EErrorInstanceOutOfSequence:

            {

            CESMRGlobalNote::ExecuteL(

                                CESMRGlobalNote::EESMRInstanceOutOfSequence );

            }

            break;

        default:

            err = KErrNone;

            break;

        }

    User::LeaveIfError( err );

    }

} // namespace

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

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

// CESMRMixedFieldStorage::CESMRMixedFieldStorage

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

//

CESMRMixedFieldStorage::CESMRMixedFieldStorage(

        MESMRFieldEventObserver& aEventObserver,

        MESMRResponseObserver* aResponseObserver ) :

    CESMRFieldStorage( aEventObserver),

    iResponseObserver(aResponseObserver)

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRMixedFieldStorage::~CESMRMixedFieldStorage

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

//

CESMRMixedFieldStorage::~CESMRMixedFieldStorage( )

    {

    FUNC_LOG;

    delete iValidator;

    }

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

// CESMRMixedFieldStorage::NewL

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

//

CESMRMixedFieldStorage* CESMRMixedFieldStorage::NewL(

        MESMRFieldEventObserver& aEventObserver,

        const CESMRPolicy& aPolicy,

        MESMRResponseObserver* aResponseObserver,

        MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    CESMRMixedFieldStorage* self =

            new (ELeave) CESMRMixedFieldStorage(

                    aEventObserver,

                    aResponseObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aPolicy, aEntry );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRMixedFieldStorage::ConstructL

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

//

void CESMRMixedFieldStorage::ConstructL(

        const CESMRPolicy& aPolicy,

        MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    CESMRFieldStorage::BaseConstructL();

    DoChangePolicyL( aPolicy, aEntry );

    }

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

// CESMRMixedFieldStorage::ExternalizeL

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

//

void CESMRMixedFieldStorage::ExternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    CESMRFieldStorage::ExternalizeL ( aEntry );

    if ( iValidator )

        {

        iValidator->StoreValuesToEntryL( aEntry );

        }

    }

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

// CESMRMixedFieldStorage::InternalizeL

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

//

void CESMRMixedFieldStorage::InternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    CESMRFieldStorage::InternalizeL ( aEntry );

    if ( iValidator )

        {

        iValidator->ReadValuesFromEntryL( aEntry );

        }

    }

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

// CESMRMixedFieldStorage::Validate

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

//

TInt CESMRMixedFieldStorage::Validate(

        TESMREntryFieldId& aUpdatedFocus, TBool aForceValidation )

    {

    FUNC_LOG;

    TInt err( KErrNone );

    if ( iValidator )

        {

        MESMRFieldValidator::TESMRFieldValidatorError error;

        TRAP( err, error = iValidator->ValidateL( aForceValidation ) );

        if ( !aForceValidation )

            {

            // If error note does not success, there is much we can do.

            TRAP( err, ShowValidationErrorL( error, aUpdatedFocus ) );

            }

        else

            {

            // Force exit is used.

            err = KErrNone;

            }

        }

    return err;

    }

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

// CESMRMixedFieldStorage::ChangePolicyL

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

//

void CESMRMixedFieldStorage::ChangePolicyL(

        const CESMRPolicy& aNewPolicy,

        MESMRCalEntry& aEntry )

    {

    // Delegate to non-virtual

    DoChangePolicyL( aNewPolicy, aEntry );

    }

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

// CESMRMixedFieldStorage::ConstructForwardEventL

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

//

void CESMRMixedFieldStorage::ConstructForwardEventL(

        const CESMRPolicy& aPolicy,

        MESMRFieldValidator* aValidator )

    {

    FUNC_LOG;

    iValidator = aValidator;

    RArray< TESMREntryField > array = aPolicy.Fields();

    TInt fieldCount( array.Count() );

    for (TInt i(0); i < fieldCount; i++ )

        {

        CESMRField* field =  NULL;

        TBool visible = ( array[i].iFieldViewMode == EESMRFieldTypeDefault );

        switch ( array[i].iFieldId )

            {            

            case EESMRFieldAttendee: //Fall through 

            case EESMRFieldOptAttendee: //Fall through

            case EESMRFieldDescription:

                {

                field = CreateEditorFieldL( iValidator, array[i] );

                }

                break;

            default:

                {

                field =  

					CreateViewerFieldL( iResponseObserver, array[i], visible );

                field->LockL();

                }

                break;

            }

        if( field->FieldViewMode() != EESMRFieldTypeDisabled )

            {

            CleanupStack::PushL( field );

            AddFieldL( field, visible );

            CleanupStack::Pop( field );

            }

        else

            {

            delete field;

            field = NULL;

            }

        }

    }

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

// CESMRMixedFieldStorage::ConstructRecurrentEventL

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

//

void CESMRMixedFieldStorage::ConstructRecurrentEventL(

        const CESMRPolicy& aPolicy,

        MESMRFieldValidator* aValidator )

    {

    FUNC_LOG;

    iValidator = aValidator;

    iValidator->SetFieldEventQueue( &EventQueueL() );

    const RArray<TESMREntryField>& array = aPolicy.Fields();

    TInt fieldCount( array.Count() );

    for (TInt i(0); i < fieldCount; ++i )

        {

        CESMRField* field = NULL;

        TBool visible = array[i].iFieldViewMode == EESMRFieldTypeDefault;

        switch ( array[i].iFieldId )

            {

            case EESMRFieldRecurrence: //Fall through

            case EESMRFieldRecurrenceDate:

            default:

                field =  CreateEditorFieldL( iValidator, array[i] );

                break;

            }

        if ( field )

            {

            CleanupStack::PushL( field );

            AddFieldL(field, visible );

            CleanupStack::Pop( field );

            }

        }

    }

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

// CESMRMixedFieldStorage::ConstructEditSeriesEventL

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

//

void CESMRMixedFieldStorage::ConstructEditSeriesEventL(

        const CESMRPolicy& aPolicy,

        MESMRFieldValidator* aValidator )

    {

    FUNC_LOG;

    TESMRRecurrenceValue recurrenceType;

    TBool validRecurrence(

            HasValidRecurrenceForEditingL(

                    *iEntry,

                    recurrenceType ) );

    iValidator = aValidator;

    iValidator->SetFieldEventQueue( &EventQueueL() );

    const RArray<TESMREntryField>& array = aPolicy.Fields();

    CESMRField* field =  NULL;

    TInt fieldCount(  array.Count() );

    for (TInt i(0); i < fieldCount; i++ )

        {

        const TESMREntryField& tfield = array[i];

        TBool visible = tfield.iFieldViewMode == EESMRFieldTypeDefault;

        switch ( tfield.iFieldId )

            {

            // Flowthrough

            case EESMRFieldRecurrence:

            case EESMRFieldRecurrenceDate:

                {

                if ( validRecurrence )

                    {

                    field = CreateEditorFieldL( iValidator, tfield );

                    }

                else

                    {

                    // Entry has unrecognized recurrende type

                    // --> Cannot be edited.

                    field = CreateViewerFieldL( 

								iResponseObserver, tfield, visible );

                    field->LockL();

                    }

                }

                break;

            default:

                {

                field = CreateEditorFieldL( iValidator, tfield );

                }

                break;

            }

        if( field->FieldViewMode() != EESMRFieldTypeDisabled )

            {

            CleanupStack::PushL( field );

            AddFieldL( field, visible );

            CleanupStack::Pop( field );

            }

        else

            {

            delete field;

            field = NULL;

            }

        }

    }

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

// CESMRMixedFieldStorage::ConstructEditSeriesEventL

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

//

void CESMRMixedFieldStorage::Reset()

    {

    CESMRFieldStorage::Reset();

    delete iValidator;

    iValidator = NULL;

    }

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

// CESMRMixedFieldStorage::DoChangePolicyL

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

//

void CESMRMixedFieldStorage::DoChangePolicyL(

        const CESMRPolicy& aNewPolicy,

        MESMRCalEntry& aEntry )

    {

    Reset();

    iEntry = &aEntry;

    // FORWARD allows only attendee fields and description to be edited.

    // EDIT RECURRENT EVENT allows only start-end time and start date

    // to be edited.

    MESMRCalEntry::TESMRRecurrenceModifyingRule rule(

            iEntry->RecurrenceModRule() );

    if ( iEntry->IsRecurrentEventL() &&

         rule == MESMRCalEntry::EESMRAllInSeries  &&

         EESMREditMR == aNewPolicy.ViewMode())

        {

        // Contruct edit series

        // validator ownership is transferred

        MESMRFieldValidator* validator =

        CESMRValidatorFactory::CreateValidatorL (

                aNewPolicy.EventType() );

        ConstructEditSeriesEventL(

                aNewPolicy,

                validator );

        iEventType = EMixedFieldStorageEditSeriesEvent;

        }

    else if ( aNewPolicy.ViewMode() != EESMRForwardMR )

        {

        MESMRFieldValidator* validator =

                CESMRValidatorFactory::CreateValidatorL (

                        aNewPolicy.EventType() );

        ConstructRecurrentEventL ( aNewPolicy,

                validator );

        iEventType = EMixedFieldStorageRecurrentEvent;

        }

    else

        {

        // No validator is needed because forwarding does not

        // affecto to any time fields.

        MESMRFieldValidator* validator = NULL;

        ConstructForwardEventL (

                aNewPolicy,

                validator );

        iEventType = EMixedFieldStorageForward;

        }

    }

// EOF