/*
* 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 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"

//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;
        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(
        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( 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 );
        
        CleanupStack::PushL( field );
        AddFieldL( field, visible );
        CleanupStack::Pop( field );
        }
    
    }
        
// ---------------------------------------------------------------------------
// 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;
    }

// EOF