/*
* 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 Field storage for editor dialog
*
*/

#include "emailtrace.h"
#include "cesmreditorfieldstorage.h"

//<cmail>
#include "cesmrpolicy.h"
#include "esmrdef.h"
//</cmail>

#include "mesmrfieldvalidator.h"
#include "tesmrentryfield.h"
#include "cesmrvalidatorfactory.h"
#include "cesmrglobalnote.h"
#include "cesmrfield.h"
#include "cesmrfieldeventqueue.h"

#include <ct/rcpointerarray.h>

//logging
//performance profiling
// <cmail> Removed profiling. </cmail>

// Unnamed namespace for local definitions
namespace { // codescanner::namespace

#ifdef _DEBUG

// Definition for panic literal
_LIT( KESMREditorFieldStorage, "ESMREditorFieldStorage" );

/** CESMREditorFieldStorage panic codes */
enum TSMREditorFieldStoragePanic
    {
    /** No validator defined */
    EESMREditorFieldStorageNoValidator = 0
    };

void Panic( TSMREditorFieldStoragePanic aPanic )
    {

    User::Panic( KESMREditorFieldStorage, aPanic );
    }

#endif // _DEBUG

/**
 * Shows validation error.
 * @param aError Defines the validation error
 * @param aUpdatedFocus On return contains the id of the field,
 *                      which should be focused.
 */
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::EErrorAlarmTooMuchInPast:
            {
            aUpdatedFocus = EESMRFieldAlarmDate;
            CESMRGlobalNote::ExecuteL(
                    CESMRGlobalNote::EESMRDiffMoreThanMonth );
            break;
            }

        case MESMRFieldValidator::EErrorRelativeAlarmInPast:
            {
            aUpdatedFocus = EESMRFieldAlarm;
            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 ========

// ---------------------------------------------------------------------------
// CESMREditorFieldStorage::CESMREditorFieldStorage
// ---------------------------------------------------------------------------
//
CESMREditorFieldStorage::CESMREditorFieldStorage(
        MESMRFieldEventObserver& aEventObserver )
:   CESMRFieldStorage( aEventObserver )
    {
    FUNC_LOG;
    // Do nothing
    }

// ---------------------------------------------------------------------------
// CESMREditorFieldStorage::~CESMREditorFieldStorage
// ---------------------------------------------------------------------------
//
CESMREditorFieldStorage::~CESMREditorFieldStorage( )
    {
    FUNC_LOG;
    delete iValidator;
    }

// ---------------------------------------------------------------------------
// CESMREditorFieldStorage::NewL
// ---------------------------------------------------------------------------
//
CESMREditorFieldStorage* CESMREditorFieldStorage::NewL(
        const CESMRPolicy& aPolicy,
        MESMRFieldEventObserver& aEventObserver )
    {
    FUNC_LOG;
    CESMREditorFieldStorage* self =
            new (ELeave) CESMREditorFieldStorage( aEventObserver );
    CleanupStack::PushL ( self );
    self->ConstructL ( aPolicy );
    CleanupStack::Pop ( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CESMREditorFieldStorage::ConstructL
// ---------------------------------------------------------------------------
//
void CESMREditorFieldStorage::ConstructL( const CESMRPolicy& aPolicy )
    {
    FUNC_LOG;
    CESMRFieldStorage::BaseConstructL();
    iValidator =
            CESMRValidatorFactory::CreateValidatorL( aPolicy.EventType() );
    
    __ASSERT_DEBUG( iValidator, Panic( EESMREditorFieldStorageNoValidator) );

    iValidator->SetFieldEventQueue( &EventQueueL() );
    
    RArray<TESMREntryField> fields = aPolicy.Fields();
    const TInt count(fields.Count());
    
    for (TInt i(0); i < count; i++ )
        {
        TESMREntryField entryField = fields[i];
        TBool visible( entryField.iFieldViewMode == EESMRFieldTypeDefault );
        CESMRField* field = CreateEditorFieldL( iValidator, entryField );
        
        if( field->FieldViewMode() != EESMRFieldTypeDisabled )
            {
            CleanupStack::PushL( field );
            AddFieldL( field, visible );
            CleanupStack::Pop( field );
            }
        else
            {
            delete field;
            field = NULL;
            }
        }
    }
        
// ---------------------------------------------------------------------------
// CESMREditorFieldStorage::ExternalizeL
// ---------------------------------------------------------------------------
//
void CESMREditorFieldStorage::ExternalizeL( MESMRCalEntry& aEntry )
    {
    FUNC_LOG;
    CESMRFieldStorage::ExternalizeL ( aEntry );
    iValidator->StoreValuesToEntryL( aEntry );
    }

// ---------------------------------------------------------------------------
// CESMREditorFieldStorage::InternalizeL
// ---------------------------------------------------------------------------
//
void CESMREditorFieldStorage::InternalizeL( MESMRCalEntry& aEntry )
    {
    FUNC_LOG;
    CESMRFieldStorage::InternalizeL ( aEntry );
    iValidator->ReadValuesFromEntryL( aEntry );
    }

// ---------------------------------------------------------------------------
// CESMREditorFieldStorage::Validate
// ---------------------------------------------------------------------------
//
TInt CESMREditorFieldStorage::Validate(
        TESMREntryFieldId& aUpdatedFocus, TBool aForceValidation )
    {
    FUNC_LOG;
    MESMRFieldValidator::TESMRFieldValidatorError error;
    TRAPD( 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;
    }

// ---------------------------------------------------------------------------
// CESMREditorFieldStorage::ChangePolicyL
// ---------------------------------------------------------------------------
//
void CESMREditorFieldStorage::ChangePolicyL(
        const CESMRPolicy& aNewPolicy,
        MESMRCalEntry& /*aEntry*/ )
    {
    MESMRFieldValidator* validator =
        CESMRValidatorFactory::CreateValidatorL( aNewPolicy.EventType() );
        
    __ASSERT_DEBUG( validator, Panic( EESMREditorFieldStorageNoValidator) );
    CleanupDeletePushL( validator );
    
    validator->SetFieldEventQueue( &EventQueueL() );
    
    // Iterate through policy and create fields into tmp array
    RArray<TESMREntryField> fields = aNewPolicy.Fields();
    
    TInt count( fields.Count() );
        
    RCPointerArray< CESMRField > fieldArray;
    CleanupClosePushL( fieldArray );
    
    fieldArray.ReserveL( count );    

    CESMRField* field = NULL;
    
    // Append new fields to array
    for (TInt i(0); i < count; ++i )
        {
        field = CreateEditorFieldL( validator, fields[i] );
        // Append field
        if( field->FieldViewMode() != EESMRFieldTypeDisabled )
            {
            fieldArray.AppendL( field );
            }
        else
            {
            delete field;
            field = NULL;
            }
        }
    
    // Reseting field array from storage, so that it can be
    // reused
    Reset();
    
    count = fieldArray.Count();

    // Reserve space in strorage for all required fields
    ReserveL( count );
    
    // Insert fields from fieldArray into storage
    for ( TInt i = 0; i < count; ++i )
        {
        AddFieldL( fieldArray[ i ] );
        
        TBool visible( fields[ i ].iFieldViewMode == EESMRFieldTypeDefault );
        Field( i )->MakeVisible( visible );
        }
    
    // Remove items from field array
    for ( TInt i = 0; i < count; ++i )
        {
        fieldArray.Remove( 0 );
        }

    // Assign new validator
    delete iValidator;
    iValidator = validator;
    CleanupStack::PopAndDestroy( &fieldArray );
    CleanupStack::Pop( validator );
    }

// EOF