/*

* Copyright (c) 2002-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 CESMRICalValue.

*

*/

// Class include.

#include "emailtrace.h"

#include "cesmricalvalue.h" // CESMRICalValue

//debug

// User includes.

#include "esmricalkeywords.h"       // Literals

#include "cesmricalrulesegment.h"   // CESMRICalRuleSegment

// Constants.

namespace{

// Maximum number of characters to use for storing TInt.

// (The maximum number of characters for storing a decimal representation of

// KMaxTInt, KMinTInt or even KMaxTUint is 10 on current implementations.

// The maximum number of characters for storing a decimal representation of

// KMaxTUint64 is 20, so using this for future proofing.)

const TInt KICalTIntWidth = 20;

// Width of "HHMMSS"

const TInt KICalTimeWidth = 6;

// Width of "YYYYMMDD"

const TInt KICalDateWidth = 8;

// Width of "YYYYMMDDTHHMMSS" (note the 'T' in the middle)

const TInt KICalDateTimeWidth = KICalDateWidth + KICalTimeWidth + 1;

// Width of a duration.

const TInt KICalDurationWidth = 25;

// Width of a short format UTC offset.

const TInt KShortFormatUtcOffsetWidth = 5;  // The width of (e.g.) +1000.

// Width of a long format UTC offset.

const TInt KLongFormatUtcOffsetWidth = 7;   // The width of (e.g.) -013045.

// Time constants.

const TInt KICalSecondsPerMinute =     60;

const TInt KICalSecondsPerHour   =   3600; // That is:      60*60;

const TInt KICalSecondsPerDay    =  86400; // That is:   24*60*60;

const TInt KICalSecondsPerWeek   = 604800; // That is: 7*24*60*60;

// Time characters

const TUint KICalUtcChar('Z');      // UTC time.

const TUint KICalTimeChar('T');     // Date/time separator.

const TUint KICalPeriodChar('/');   // Period separator.

const TUint KICalMicroChar('.');    // Second/microsecond separator.

const TUint KICalDurationChar('P'); // Duration.

const TUint KICalWeekChar('W');     // Week.

const TUint KICalDayChar('D');      // Day.

const TUint KICalHourChar('H');     // Hour.

const TUint KICalMinuteChar('M');   // Minute.

const TUint KICalSecondChar('S');   // Second.

const TUint KICalPositiveChar('+'); // Positive values.

const TUint KICalNegativeChar('-'); // Negative values.

// Date format.

_LIT(KICalDateFormat, "%F%Y%M%D");

}//namespace

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

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

// CESMRICalValue::NewL

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

//

EXPORT_C CESMRICalValue* CESMRICalValue::NewL()

    {

    FUNC_LOG;

    CESMRICalValue* self  = CESMRICalValue::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// CESMRICalValue::NewLC

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

//

EXPORT_C CESMRICalValue* CESMRICalValue::NewLC()

    {

    FUNC_LOG;

    CESMRICalValue* self  = new (ELeave) CESMRICalValue;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CESMRICalValue::~CESMRICalValue

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

//

CESMRICalValue::~CESMRICalValue()

    {

    FUNC_LOG;

    delete iValue;

    }

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

// CESMRICalValue::BinaryLC

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

//

EXPORT_C HBufC8* CESMRICalValue::BinaryLC() const

    {

    FUNC_LOG;

    CheckNullValueL();

    HBufC8* buf = HBufC8::NewLC(iValue->Length());

    buf->Des().Copy(*iValue);

    return buf;

    }

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

// CESMRICalValue::SetBinaryL

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

//

EXPORT_C void CESMRICalValue::SetBinaryL(const TDesC8& aBuffer)

    {

    FUNC_LOG;

    PrepareValuePointer();

    iValue = HBufC::NewL(aBuffer.Length());

    iValue->Des().Copy(aBuffer);

    }

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

// CESMRICalValue::BooleanL

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

//

EXPORT_C TBool CESMRICalValue::BooleanL() const

    {

    FUNC_LOG;

    CheckNullValueL();

    if (iValue->Des() == KICalTrue)

        {

        return ETrue;

        }

    else if (iValue->Des() == KICalFalse)

        {

        return EFalse;

        }

    // Else...

    User::Leave(KErrCorrupt);

    return EFalse;  // Never reached.

    }

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

// CESMRICalValue::SetBooleanL

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

//

EXPORT_C void CESMRICalValue::SetBooleanL(TBool aBool)

    {

    FUNC_LOG;

    PrepareValuePointer();

    if (aBool) // ETrue

        {

        iValue = KICalTrue().AllocL();

        }

    else    // EFalse

        {

        iValue = KICalFalse().AllocL();

        }

    }

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

// CESMRICalValue::GetDateL

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

//

EXPORT_C void CESMRICalValue::GetDateL(TTime& aDate) const

    {

    FUNC_LOG;

    CheckNullValueL();

    GetDateFromValueL(aDate);

    }

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

// CESMRICalValue::SetDateL

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

//

EXPORT_C void CESMRICalValue::SetDateL(const TTime& aDate)

    {

    FUNC_LOG;

    PrepareValuePointer();

    iValue = HBufC::NewL(KICalDateWidth);

    AppendDateToValueL(aDate);

    }

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

// CESMRICalValue::GetTimeL

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

//

EXPORT_C void CESMRICalValue::GetTimeL(TTime& aTime, TTimeZoneType& aTzType) const

    {

    FUNC_LOG;

    CheckNullValueL();

    GetTimeFromValueL(aTime, aTzType);

    }

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

// CESMRICalValue::SetTimeL

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

//

EXPORT_C void CESMRICalValue::SetTimeL(const TTime& aTime, TTimeZoneType aTzType)

    {

    FUNC_LOG;

    PrepareValuePointer();

    if (aTzType == EUtcTime)

        {

        iValue = HBufC::NewL(KICalTimeWidth + 1);

        AppendTimeToValueL(aTime);

        iValue->Des().Append(KICalUtcChar); // Append a 'Z' to signify UTC.

        }

    else if (aTzType == ESpecifiedTimeZone || aTzType == EFloatingTime)

        {

        iValue = HBufC::NewL(KICalTimeWidth);

        AppendTimeToValueL(aTime);

        }

    }

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

// CESMRICalValue::GetDateTimeL

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

//

EXPORT_C void CESMRICalValue::GetDateTimeL(TTime& aDateTime, TTimeZoneType& aTzType, TInt aFirstCharacterNum) const

    {

    FUNC_LOG;

    CheckNullValueL();

    // The GetTimeFromValueL() function explicitly sets the TTime passed

    // in, so create a new TTime for the date and merge with the time later.

    TTime theDate;

    GetDateFromValueL(theDate, aFirstCharacterNum);

    // Only start looking for the time at character position KICalDateWidth

    // plus one for the 'T' separator.

    if (iValue->Length() > aFirstCharacterNum + KICalDateWidth + 1)

        {

        TTime theTime;

        if ((*iValue)[aFirstCharacterNum + KICalDateWidth] != KICalDateTimeSeparator)

            {

            User::Leave(KErrCorrupt);

            }

        GetTimeFromValueL(theTime, aTzType, aFirstCharacterNum + KICalDateWidth + 1);

        // Set the time component.

        TDateTime dateValues(theDate.DateTime());

        TDateTime combinedValues(theTime.DateTime());

        // Set the date component.

        combinedValues.SetYear(dateValues.Year());

        combinedValues.SetMonth(dateValues.Month());

        combinedValues.SetDay(dateValues.Day());

        // Set the value to return.

        aDateTime = TTime(combinedValues);

        }

    else

        {

        // There is no time component specified.  For compatibility with MS Outlook,

        // which can export RECURRENCE-ID fields with no time component, we use

        // a default time of '00:00'

        aDateTime = theDate;

        }

    }

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

// CESMRICalValue::SetDateTimeL

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

//

EXPORT_C void CESMRICalValue::SetDateTimeL(const TTime& aDateTime, TTimeZoneType aTzType)

    {

    FUNC_LOG;

    PrepareValuePointer();

    if (aTzType == EUtcTime)

        {

        iValue = HBufC::NewL(KICalDateTimeWidth + 1);

        AppendDateToValueL(aDateTime);

        iValue->Des().Append(KICalTimeChar);

        AppendTimeToValueL(aDateTime);

        iValue->Des().Append(KICalUtcChar); // For UTC Time.

        }

    else if (aTzType == ESpecifiedTimeZone || aTzType == EFloatingTime)

        {

        iValue = HBufC::NewL(KICalDateTimeWidth);

        AppendDateToValueL(aDateTime);

        iValue->Des().Append(KICalTimeChar);

        AppendTimeToValueL(aDateTime);

        }

    }

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

// CESMRICalValue::DurationL

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

//

EXPORT_C TTimeIntervalSeconds CESMRICalValue::DurationL() const

    {

    FUNC_LOG;

    CheckNullValueL();

    TTimeIntervalSeconds theTis;

    GetTimeIntervalFromValueL(theTis);

    return theTis;

    }

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

// CESMRICalValue::SetDurationL

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

//

EXPORT_C void CESMRICalValue::SetDurationL(TTimeIntervalSeconds aDuration)

    {

    FUNC_LOG;

    // e.g. P15DT5H0M20S

    PrepareValuePointer();

    iValue = HBufC::NewL(KICalDurationWidth);

    TInt durInt(aDuration.Int());

    if (durInt < 0)

        {

        // First character is a '-' for negative values

        iValue->Des().Append(KICalNegativeChar);

        // Now we've set the sign, change the durInt to +ve

        durInt =- durInt;

        }

    iValue->Des().Append(KICalDurationChar);

    // Add day portion.

    TInt numDays(durInt / KICalSecondsPerDay);

    durInt -= (numDays * KICalSecondsPerDay);

    iValue->Des().AppendNum(numDays);

    iValue->Des().Append(KICalDayChar);

    iValue->Des().Append(KICalTimeChar);

    // Add hour portion.

    TInt numHours(durInt / KICalSecondsPerHour);

    durInt -= (numHours * KICalSecondsPerHour);

    iValue->Des().AppendNum(numHours);

    iValue->Des().Append(KICalHourChar);

    // Add minute portion.

    TInt numMinutes(durInt / KICalSecondsPerMinute);

    durInt -= (numMinutes * KICalSecondsPerMinute);

    iValue->Des().AppendNum(numMinutes);

    iValue->Des().Append(KICalMinuteChar);

    // Add second portion.

    TInt numSeconds(durInt);

    iValue->Des().AppendNum(numSeconds);

    iValue->Des().Append(KICalSecondChar);

    }

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

// CESMRICalValue::GetFloatL

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

//

EXPORT_C void CESMRICalValue::GetFloatL(TReal& aFloat) const

    {

    FUNC_LOG;

    CheckNullValueL();

    TLex stringLex(iValue->Des());

    User::LeaveIfError(stringLex.Val(aFloat));

    }

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

// CESMRICalValue::SetFloatL

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

//

EXPORT_C void CESMRICalValue::SetFloatL(const TReal& aFloat)

    {

    FUNC_LOG;

    PrepareValuePointer();

    iValue = HBufC::NewL(KDefaultRealWidth);

    TRealFormat format;

    iValue->Des().Num(aFloat, format);

    }

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

// CESMRICalValue::IntegerL

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

//

EXPORT_C TInt CESMRICalValue::IntegerL() const

    {

    FUNC_LOG;

    CheckNullValueL();

    return ReadIntL(iValue->Des());

    }

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

// CESMRICalValue::SetIntegerL

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

//

EXPORT_C void CESMRICalValue::SetIntegerL(TInt aInt)

    {

    FUNC_LOG;

    PrepareValuePointer();

    iValue = HBufC::NewL(KICalTIntWidth);

    iValue->Des().Num(aInt);

    }

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

// CESMRICalValue::GetPeriodL

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

//

EXPORT_C void CESMRICalValue::GetPeriodL(

    TTime& aStartTime,

    TTimeZoneType& aStartTzType,

    TTime& aEndTime,

    TTimeZoneType& aEndTzType) const

    {

    FUNC_LOG;

    // Example :   19970101T180000Z/19970102T070000Z

    // that is : yyyymmddThhmmss[Z]/yyyymmddThhmmss[Z]

    // Example2:   19970101T180000Z/PT5H30M

    // that is2: yyyymmddThhmmss[Z]/[+/-]P[lots of stuff]

    // As the first part is always a date-time, get this out to start off with

    GetDateTimeL(aStartTime, aStartTzType, 0);

    // Next we need to get the position of the separator.

    TInt charNumber(iValue->Des().Locate(KICalPeriodChar));

    User::LeaveIfError(charNumber);

    // If the character after the separator is a 'P', '+' or '-' the second part is a duration.

    ++charNumber;

    if (charNumber >= iValue->Length())

        {

        User::Leave(KErrCorrupt);

        }

    TChar theChar(iValue->Des()[charNumber]);

    if ((theChar == KICalDurationChar) ||

        (theChar == KICalPositiveChar) ||

        (theChar == KICalNegativeChar))

        {

        // Call a function to change the duration into a TTime (date + time)

        TTimeIntervalSeconds interval;

        GetTimeIntervalFromValueL(interval, charNumber);

        // Convert from this TimeInterval to a TTime

        aEndTime = aStartTime;

        aEndTime += interval;

        // The timezone will be the same as the first.

        aEndTzType = aStartTzType;

        }

    else // Presume it's a date-time

        {

        GetDateTimeL(aEndTime, aEndTzType, charNumber);

        }

    }

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

// CESMRICalValue::SetPeriodL

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

//

EXPORT_C void CESMRICalValue::SetPeriodL(

    const TTime& aStartTime,

    TTimeZoneType aStartTzType,

    const TTime& aEndTime,

    TTimeZoneType aEndTzType)

    {

    FUNC_LOG;