/*
* 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: This file implements class CESMRAgnRRuleImporter.
*
*/


#include "emailtrace.h"
#include "cesmragnrruleimporter.h"

//<cmail>

// Agenda includes.
#include <calrrule.h>              // For CCalRRule

// Versit includes.
#include "esmricalkeywords.h"          // for cesmricalkeywords
#include "cesmricalproperty.h"         // for cesmricalproperty
#include "cesmricalvalue.h"            // for cesmricalvalue
//</cmail>


#include "esmrcleanuppointerarray.h"   // For TCleanupPointerArray

// RRule Parser includes
#include "cesmragnparserruleyearly.h"  // For CESMRAgnParseRRuleYearly
#include "cesmragnparserrulemonthly.h" // For CESMRAgnParseRRuleMonthly
#include "cesmragnparserruleweekly.h"  // For CESMRAgnParseRRuleWeekly
#include "cesmragnparserruledaily.h"   // For CESMRAgnParseRRuleDaily

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

// ---------------------------------------------------------------------------
// CESMRAgnRRuleImporter::CESMRAgnRRuleImporter
// ---------------------------------------------------------------------------
//
CESMRAgnRRuleImporter::CESMRAgnRRuleImporter( MESMRAgnImpUtil& aAgnImpUtil ): iAgnImpUtil( aAgnImpUtil )
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRAgnRRuleImporter::~CESMRAgnRRuleImporter
// ---------------------------------------------------------------------------
//
CESMRAgnRRuleImporter::~CESMRAgnRRuleImporter()
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRAgnRRuleImporter::NewL
// ---------------------------------------------------------------------------
//
CESMRAgnRRuleImporter* CESMRAgnRRuleImporter::NewL( MESMRAgnImpUtil& aAgnImpUtil )
    {
    FUNC_LOG;
    CESMRAgnRRuleImporter *self = CESMRAgnRRuleImporter::NewLC( aAgnImpUtil );
    CleanupStack::Pop(self);

    return self;
    }

// ---------------------------------------------------------------------------
// CESMRAgnRRuleImporter::NewLC
// ---------------------------------------------------------------------------
//
CESMRAgnRRuleImporter* CESMRAgnRRuleImporter::NewLC( MESMRAgnImpUtil& aAgnImpUtil )
    {
    FUNC_LOG;

    CESMRAgnRRuleImporter *self = new (ELeave)CESMRAgnRRuleImporter( aAgnImpUtil );
    CleanupStack::PushL(self);
    self->ConstructL();

    return self;
    }

// ---------------------------------------------------------------------------
// CESMRAgnRRuleImporter::ConstructL
// ---------------------------------------------------------------------------
//
void CESMRAgnRRuleImporter::ConstructL()
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRAgnRRuleImporter::ImportL
// ---------------------------------------------------------------------------
//
TBool CESMRAgnRRuleImporter::ImportL( const CESMRICalProperty& aProperty, CCalEntry& aEntry, const TCalTime& aStartTime )
    {
    FUNC_LOG;

    //===============================
    //Frequency and recurrency rules
    //===============================
    const RPointerArray<CESMRICalValue>& rulevalues = aProperty.Values();

    // There should never be less than 1 value.
    if (rulevalues.Count() < 1)
        {
        // We can't continue so abort.
        iAgnImpUtil.ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalRRule, EFalse);
        }

    CESMRICalRuleSegment::TFreq freq = CESMRICalRuleSegment::EFreqDaily;
    RPointerArray<CESMRICalRuleSegment> recRules;
    CleanupPointerArrayPushL(recRules);

    // At this point we take ownership of the things which rules contains:
    rulevalues[0]->GetRecurrenceRuleL(recRules);

    // An RRule must have a frequency.
    TInt pos = iAgnImpUtil.FindRuleSegment(recRules, CESMRICalRuleSegment::ESegFreq);

    if (pos != KErrNotFound)
        {
        ASSERT(recRules.Count() >= pos + 1);
        freq = recRules[pos]->FreqL();
        }
    else
        {
        iAgnImpUtil.ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), rulevalues[0]->TextL());
        // On continue, EFreqDaily will be used.
        }

    //===================================
    // Create Parser and parse the rrule
    //===================================
    TBool parsed = EFalse;
    TCalRRule rule;

    //Create parser and parse the recurrency rule
    CESMRAgnParseRRule* parser = CreateParserLC( freq, rule );

    if( parser )
        {
        //if parser returns true the RRule was parsed successfully
        parsed = parser->ParseL( rule, recRules, aStartTime, aEntry.UidL(), rulevalues );
        CleanupStack::PopAndDestroy( parser );
        }
    else
        {
        parsed = EFalse;
        iAgnImpUtil.ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, aEntry.UidL(), rulevalues[0]->TextL());
        }

    //=================================
    // Update aEntry if parsed is true
    //=================================
    if ( parsed )
        {
        aEntry.SetRRuleL(rule);
        }

    CleanupStack::PopAndDestroy(&recRules);

    return parsed;
    }

// ---------------------------------------------------------------------------
// CESMRAgnRRuleImporter::CreateParserLC
// ---------------------------------------------------------------------------
//
/**
Factory method to create the RRule parser
@param aFreq The RRULE frequency
@param aRule rule to add the frequency to
@return returns NULL if parser for CESMRICalRuleSegment::TFreq type not found, otherwise parser
*/
CESMRAgnParseRRule* CESMRAgnRRuleImporter::CreateParserLC( const CESMRICalRuleSegment::TFreq aFreq, TCalRRule& aRule )
    {
    FUNC_LOG;

    CESMRAgnParseRRule* parser;

    switch ( aFreq )
        {
        //Daily
        case CESMRICalRuleSegment::EFreqDaily :
            {
            aRule.SetType(TCalRRule::EDaily);
            parser = CESMRAgnParseRRuleDaily::NewLC( iAgnImpUtil );
            break;
            }
        //Weekly
        case CESMRICalRuleSegment::EFreqWeekly :
            {
            aRule.SetType(TCalRRule::EWeekly);
            parser = CESMRAgnParseRRuleWeekly::NewLC( iAgnImpUtil );
            break;
            }
        //Monthly
        case CESMRICalRuleSegment::EFreqMonthly :
            {
            aRule.SetType(TCalRRule::EMonthly);
            parser = CESMRAgnParseRRuleMonthly::NewLC( iAgnImpUtil );
            break;
            }
        //Yearly
        case CESMRICalRuleSegment::EFreqYearly :
            {
            aRule.SetType(TCalRRule::EYearly);
            parser = CESMRAgnParseRRuleYearly::NewLC( iAgnImpUtil );
            break;
            }
        //Not supported
        case CESMRICalRuleSegment::EFreqSecondly :  // Not supported, fall through...
        case CESMRICalRuleSegment::EFreqMinutely :  // Not supported, fall through...
        case CESMRICalRuleSegment::EFreqHourly :    // Not supported, fall through...
        default :
            {
            parser = NULL;
            }

        }

    return parser;
    }