/*

* Copyright (c) 2007-2007 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 contains implementation of iCal parser 

*                which parses for RRULE prperrty to create create 

*                corresponging TCalRRule.

*

*/

#include "AgnRRuleImporter.h"

#include "calendarengines_debug.h"

// Agenda includes.

#include <calrrule.h>			   // For CCalRRule

// Versit includes.

#include "ICalKeyWords.h"		   // For CICalKeyWords

#include "ICalProperty.h"		   // For CICalProperty

#include "ICalValue.h"			   // For CICalValue

#include "CleanupPointerArray.h"   // For TCleanupPointerArray

// RRule Parser includes

#include "AgnParseRRuleYearly.h"  // For CAgnParseRRuleYearly

#include "AgnParseRRuleMonthly.h" // For CAgnParseRRuleMonthly

#include "AgnParseRRuleWeekly.h"  // For CAgnParseRRuleWeekly

#include "AgnParseRRuleDaily.h"   // For CAgnParseRRuleDaily

/**

Constructor

@param aAgnImpUtil AgnVersit2Importer utility functions

*/

CAgnRRuleImporter::CAgnRRuleImporter( MAgnImpUtil& aAgnImpUtil ): iAgnImpUtil( aAgnImpUtil )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

//Destructor

CAgnRRuleImporter::~CAgnRRuleImporter()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

/**

Constructs a new CAgnRRuleImporter and returns it. 

@param aAgnImpUtil AgnVersit2Importer utility functions

@return a new CAgnParseRRuleYearly.

*/

CAgnRRuleImporter* CAgnRRuleImporter::NewL( MAgnImpUtil& aAgnImpUtil )

    {

    TRACE_ENTRY_POINT;

    CAgnRRuleImporter *self = CAgnRRuleImporter::NewLC( aAgnImpUtil );

    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;

    return self;     

    }

/**

Constructs a new CAgnRRuleImporter and returns it. 

The object is left on the cleanup stack.

@param aAgnImpUtil AgnVersit2Importer utility functions

@return a new CAgnParseRRuleYearly.

*/

CAgnRRuleImporter* CAgnRRuleImporter::NewLC( MAgnImpUtil& aAgnImpUtil )

    {

    TRACE_ENTRY_POINT;

    CAgnRRuleImporter *self = new (ELeave)CAgnRRuleImporter( aAgnImpUtil );

    CleanupStack::PushL(self);

    self->ConstructL();

    TRACE_EXIT_POINT;

    return self;     

    }

//Two phase constructor

void CAgnRRuleImporter::ConstructL()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

/**

A function to translate an RRULE property into a TCalRRule for Agenda.

@param aProperty The RRULE property to translate.

@param aEntry The entry to add the rules to.

@param aStartTime The DTSTART of the parent component.

@return ETrue if the rule is imported, else EFalse.

*/

TBool CAgnRRuleImporter::ImportL( const CICalProperty& aProperty, CCalEntry& aEntry, const TCalTime& aStartTime )

    {

    TRACE_ENTRY_POINT;

    //===============================

    //Frequency and recurrency rules

    //===============================

    const RPointerArray<CICalValue>& rulevalues = aProperty.Values();

	// There should never be less than 1 value.

	if (rulevalues.Count() < 1)

		{

		// We can't continue so abort.

		iAgnImpUtil.ReportErrorL(MAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalRRule, EFalse);

		}

    CICalRuleSegment::TFreq freq = CICalRuleSegment::EFreqDaily;

	RPointerArray<CICalRuleSegment> 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, CICalRuleSegment::ESegFreq);

	if (pos != KErrNotFound)

		{

		ASSERT(recRules.Count() >= pos + 1);

		freq = recRules[pos]->FreqL();

		}

	else

		{

		iAgnImpUtil.ReportErrorL(MAgnImportObserver::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

    CAgnParseRRule* 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(MAgnImportObserver::EImpErrorNotSupported, aEntry.UidL(), rulevalues[0]->TextL());

		}

   	//=================================

    // Update aEntry if parsed is true

    //=================================

    if ( parsed )

		{

		aEntry.SetRRuleL(rule);

		}

    CleanupStack::PopAndDestroy(&recRules);

    TRACE_EXIT_POINT;

	return parsed;

    }

/**

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 CICalRuleSegment::TFreq type not found, otherwise parser

*/

CAgnParseRRule* CAgnRRuleImporter::CreateParserLC( const CICalRuleSegment::TFreq aFreq, TCalRRule& aRule )

    {

    TRACE_ENTRY_POINT;

    CAgnParseRRule* parser; 

    switch ( aFreq )

		{

		//Daily

		case CICalRuleSegment::EFreqDaily :

		    {

		    aRule.SetType(TCalRRule::EDaily);

		    parser = CAgnParseRRuleDaily::NewLC( iAgnImpUtil );

			break;

		    }

		//Weekly

		case CICalRuleSegment::EFreqWeekly :

			{

			aRule.SetType(TCalRRule::EWeekly);

			parser = CAgnParseRRuleWeekly::NewLC( iAgnImpUtil );

			break;

			}

        //Monthly			

		case CICalRuleSegment::EFreqMonthly :

		    {

		    aRule.SetType(TCalRRule::EMonthly);

		    parser = CAgnParseRRuleMonthly::NewLC( iAgnImpUtil );

			break;

		    }

		//Yearly

		case CICalRuleSegment::EFreqYearly :

		    {

		    aRule.SetType(TCalRRule::EYearly);

		    parser = CAgnParseRRuleYearly::NewLC( iAgnImpUtil );

			break;

		    }

		//Not supported

		case CICalRuleSegment::EFreqSecondly :	// Not supported, fall through...

		case CICalRuleSegment::EFreqMinutely :	// Not supported, fall through...

		case CICalRuleSegment::EFreqHourly :	// Not supported, fall through...

		default :

		    {

		   	parser = NULL;

			}

		}

	TRACE_EXIT_POINT;

	return parser;

    }