/*

* Copyright (c) 2008 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:  Base class for PIM Event item adapters

 *

*/

// CLASS HEADER

#include "cpimagneventadapter.h"

// INTERNAL INCLUDES

#include "pimcommon.h"

#include "agneventsupport.h"

#include "cpimrepeatrule.h"

#include "pimrepeatruleconverter.h"

#include "mpimitemdata.h"

#include "mpimeventitem.h"

#include "pimpanics.h"

#include "logger.h"

// EXTERNAL INCLUDES

#include <calentryview.h>

#include <calalarm.h>

#include <calrrule.h>

// UNNAMED LOCAL NAMESPACE

namespace

{

const TInt KPIMSecondsInMinute = 60;

// Alarm offset for TTime in seconds from the start of the date. This is

// the default alarm value which is set to the item if the user defined

// alarm value is too small (meaning that it has been passed to the next

// day when start of the event occurs

const TInt KPIMDefaultAlarmInterval = 43200;

}

// LOCAL FUNCTION PROTOTYPES

void CopyExceptionDatesToAgnL(const MPIMRepeatRuleData& aPimRepeatRuleData,

                              CCalEntry& aAgnEntry);

void CopyExceptionDatesToPimL(const CCalEntry& aAgnEntry,

                              MPIMRepeatRuleData& aPimRepeatRuleData);

// ============================= LOCAL FUNCTIONS ===============================

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

// CopyExceptionDatesToAgnL

// Copies PIM API exception dates to an Agenda entry.

// Returns: void

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

//

void CopyExceptionDatesToAgnL(const MPIMRepeatRuleData& aPimRepeatRuleData,

                              CCalEntry& aAgnEntry)

{

    JELOG2(EPim);

    RArray<TCalTime> agnExceptionDates;

    CleanupClosePushL(agnExceptionDates);

    const CArrayFix<TPIMDate>& pimExceptionDates =

        aPimRepeatRuleData.GetExceptDatesL();

    const TInt numExceptDates = pimExceptionDates.Count();

    TCalTime agnExceptionDate;

    for (TInt i = 0; i < numExceptDates; i++)

    {

        agnExceptionDate.SetTimeUtcL(pimExceptionDates[i]);

        User::LeaveIfError(agnExceptionDates.Append(agnExceptionDate));

    }

    aAgnEntry.SetExceptionDatesL(agnExceptionDates);

    CleanupStack::PopAndDestroy(); // pimExceptionDates close

}

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

// CopyExceptionDatesToPimL

// Copies Agenda exception dates to a PIM API repeat rule.

// Returns: void

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

//

void CopyExceptionDatesToPimL(const CCalEntry& aAgnEntry,

                              MPIMRepeatRuleData& aPimRepeatRuleData)

{

    JELOG2(EPim);

    RArray<TCalTime> agnExceptionDates;

    aAgnEntry.GetExceptionDatesL(agnExceptionDates);

    CleanupClosePushL(agnExceptionDates);

    const TInt numExceptions = agnExceptionDates.Count();

    for (TInt i = 0; i < numExceptions; i++)

    {

        TCalTime agnExceptionDate = agnExceptionDates[i];

        TTime pimExceptionDate = agnExceptionDate.TimeUtcL();

        aPimRepeatRuleData.AddExceptDateL(pimExceptionDate);

    }

    CleanupStack::PopAndDestroy(); // agnExceptionDates close

}

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

// destructor

CPIMAgnEventAdapter::~CPIMAgnEventAdapter()

{

}

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

// CPIMAgnEventAdapter::CPIMAgnEventAdapter

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CPIMAgnEventAdapter::CPIMAgnEventAdapter(

    java::util::FunctionServer* aFuncServer) :

        CPIMAgnItemAdapter(aFuncServer)

{

    JELOG2(EPim);

}

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

// CPIMAgnEventAdapter::ReadFieldsFromAgnL

// Reads Agenda entry's fields and converts them into PIM Item fields.

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

//

void CPIMAgnEventAdapter::ReadFieldsFromAgnL(MPIMEventItem& aItem,

        CCalEntry& aEntry, const TPIMField aSupportedFields[], // supported field types

        TInt aSize) // size of the array

{

    JELOG2(EPim);

    for (int i = 0; i < aSize; i++)

    {

        switch (aSupportedFields[i])

        {

        case EPIMEventSummary:

        {

            ReadSummaryFromAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventLocation:

        {

            ReadLocationFromAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventNote:

        {

            ReadNoteFromAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventAlarm:

        {

            ReadAlarmFromAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventStart:

        {

            ReadStartFromAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventEnd:

        {

            ReadEndFromAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventClass:

        {

            ReadClassFromAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventRevision: // fallthrough

        case EPIMEventUid:

        {

            // nothing

            break;

        }

        default:

        {

            User::Leave(KErrArgument);

        }

        }

    }

}

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

// CPIMAgnEventAdapter::ConvertFieldsToAgnL

// Reads PIM Item fields and converts them into Agenda entry's fields.

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

//

void CPIMAgnEventAdapter::ConvertFieldsToAgnL(const MPIMEventItem& aItem,

        CCalEntry& aEntry)

{

    JELOG2(EPim);

    CArrayFix<TPIMField>* fields = aItem.ItemData().FieldsLC();

    TInt amount = fields->Count();

    for (int i = 0; i < amount; i++)

    {

        TPIMEventField field = static_cast<TPIMEventField>(fields->At(i));

        switch (field)

        {

        case EPIMEventSummary: // Fallthrough

        case EPIMEventLocation: // Fallthrough

        case EPIMEventNote:

        {

            ConvertStringFieldToAgnL(aItem, aEntry, field);

            break;

        }

        case EPIMEventAlarm:

        {

            ConvertAlarmToAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventStart: // Fallthrough

        case EPIMEventEnd:

        {

            ConvertDateFieldToAgnL(aItem, aEntry, field);

            break;

        }

        case EPIMEventClass:

        {

            ConvertClassToAgnL(aItem, aEntry);

            break;

        }

        case EPIMEventRevision: // fallthrough

        case EPIMEventUid:

        {

            // nothing

            break;

        }

        default:

        {

            User::Leave(KErrArgument);

        }

        }

    }

    CleanupStack::PopAndDestroy(fields);

}

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

// CPIMAgnEventAdapter::ClearPIMFieldsL

// Clears the fields supported by PIM API from this Agenda Model entry.

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

//

void CPIMAgnEventAdapter::ClearPIMFieldsL(CCalEntry& aEntry,

        const TPIMField aSupportedFields[], // Array of supported field types

        TInt aSize) // Size of the array of supported fields

{

    JELOG2(EPim);

    for (int i = 0; i < aSize; i++)

    {

        switch (aSupportedFields[i])

        {

        case EPIMEventSummary:

        {

            aEntry.SetSummaryL(KNullDesC);

            break;

        }

        case EPIMEventLocation:

        {

            aEntry.SetLocationL(KNullDesC);

            break;

        }

        case EPIMEventNote:

        {

            aEntry.SetDescriptionL(KNullDesC);

            break;

        }

        case EPIMEventAlarm:

        {

            aEntry.SetAlarmL(NULL);

            break;

        }

        case EPIMEventStart: // Fallthrough

        case EPIMEventEnd: // Fallthrough

        case EPIMEventUid: // Fallthrough

        case EPIMEventClass: // Fallthrough

        case EPIMEventRevision:

        {

            break; // For these fields there is no need to do anything

        }

        default:

        {

            User::Leave(KErrArgument);

        }

        }

    }

}

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

// CPIMAgnEventAdapter::ReadSummaryFromAgnL

// Reads Agenda entry's summary field and converts it into PIM Item field.

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

//

void CPIMAgnEventAdapter::ReadSummaryFromAgnL(MPIMEventItem& aItem,

        CCalEntry& aEntry)

{

    JELOG2(EPim);

    const TDesC& agnSummary = aEntry.SummaryL();

    if (agnSummary != KNullDesC)

    {

        TPIMFieldData fieldData(EPIMEventSummary, KPIMAttrNone,

                                agnSummary.AllocLC());

        aItem.ItemData().AddValueL(fieldData);

        CleanupStack::Pop(); // agnSummary.AllocLC()

    }

}

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

// CPIMAgnEventAdapter::ReadLocationFromAgnL

// Reads Agenda entry's location field and converts it into PIM Item field.

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

//

void CPIMAgnEventAdapter::ReadLocationFromAgnL(MPIMEventItem& aItem,

        CCalEntry& aEntry)

{

    JELOG2(EPim);

    const TDesC& agnLocation = aEntry.LocationL();

    if (agnLocation != KNullDesC)

    {

        TPIMFieldData fieldData(EPIMEventLocation, KPIMAttrNone,

                                agnLocation.AllocLC());

        aItem.ItemData().AddValueL(fieldData);

        CleanupStack::Pop(); // agnLocation.AllocLC()

    }

}

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

// CPIMAgnEventAdapter::ReadNoteFromAgnL

// Reads Agenda entry's notes field and converts it into PIM Item field.

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

//

void CPIMAgnEventAdapter::ReadNoteFromAgnL(MPIMEventItem& aItem,

        CCalEntry& aEntry)

{

    JELOG2(EPim);

    const TDesC& note = aEntry.DescriptionL();

    if (note != KNullDesC)

    {

        TPIMFieldData fieldData(EPIMEventNote, KPIMAttrNone, note.AllocLC());

        aItem.ItemData().AddValueL(fieldData);

        CleanupStack::Pop(); // notes.AllocLC( )

    }

}

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

// CPIMAgnEventAdapter::ConvertStringFieldToAgnL

// Makes string conversion from framework PIM item data field to Appt item field

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

//

void CPIMAgnEventAdapter::ConvertStringFieldToAgnL(const MPIMEventItem& aItem,

        CCalEntry& aEntry, const TPIMEventField aField) const

{

    JELOG2(EPim);

    const MPIMItemData& itemData = aItem.ItemData();

    TInt amount = itemData.CountValues(aField);

    for (TInt i = 0; i < amount; i++)

    {

        const TPIMFieldData fieldData = itemData.ValueL(aField, i);

        const TDesC& stringValue = fieldData.StringValue();

        EnsureValidStringValueL(stringValue);

        // Add correct data to the field

        switch (aField)

        {

        case EPIMEventNote:

        {

            aEntry.SetDescriptionL(stringValue);

            break;

        }

        case EPIMEventSummary:

        {

            aEntry.SetSummaryL(stringValue);

            break;

        }

        case EPIMEventLocation:

        {

            aEntry.SetLocationL(stringValue);

            break;

        }

        default:

        {

            __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory,

                                               EPIMPanicUnsupportedStringField));

            break;

        }

        }

    }

}

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

// CPIMAgnEventAdapter::ConvertDateFieldToAgnL

// Converts a PIM date field to native Calendar entry

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

//

void CPIMAgnEventAdapter::ConvertDateFieldToAgnL(const MPIMEventItem& aItem,

        CCalEntry& aEntry, const TPIMEventField aField)

{

    JELOG2(EPim);

    __ASSERT_DEBUG(aField == EPIMEventStart || aField == EPIMEventEnd,

                   User::Panic(KPIMPanicCategory, EPIMPanicUnsupportedDateField));

    TCalTime end;

    TCalTime start;

    // Get date from the Java item

    const MPIMItemData& itemData = aItem.ItemData();

    // Get date from index 0 since native entries support only one value

    const TPIMFieldData fieldData = itemData.ValueL(aField, 0);

    const TPIMDate date = fieldData.DateValue();

    // Check that the date is inside the valid range

    __ASSERT_ALWAYS(IsDateInValidAgendaRange(date), User::Leave(KErrAbort));

    // By default, set both end and start to the same time and check if there

    // is the other part of the date field present in the item

    start.SetTimeUtcL(date);

    end.SetTimeUtcL(date);

    if (aField == EPIMEventStart && itemData.CountValues(EPIMEventEnd) > 0

            && itemData.ValueL(EPIMEventEnd, 0).DateValue() >= date)

    {

        const TPIMFieldData endData = itemData.ValueL(EPIMEventEnd, 0);

        const TPIMDate endDate = endData.DateValue();

        // Check that the date is inside the valid range

        __ASSERT_ALWAYS(IsDateInValidAgendaRange(endDate), User::Leave(

                            KErrAbort));

        // Set end date to the calendar date in UTC since

        // PIM API does not support local time format

        end.SetTimeUtcL(endDate);

    }

    else if (aField == EPIMEventEnd && itemData.CountValues(EPIMEventStart) > 0

             && itemData.ValueL(EPIMEventStart, 0).DateValue() <= date)

    {

        const TPIMFieldData startData = itemData.ValueL(EPIMEventStart, 0);

        const TPIMDate startDate = startData.DateValue();

        // Check that the date is inside the valid range

        __ASSERT_ALWAYS(IsDateInValidAgendaRange(startDate), User::Leave(

                            KErrAbort));

        // Set end date to the calendar date in UTC since

        // PIM API does not support local time format

        start.SetTimeUtcL(startDate);

    }

    // Set values to the native calendar entry

    aEntry.SetStartAndEndTimeL(start, end);

}

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

// CPIMAgnEventAdapter::ReadAlarmFromAgnL

// Reads alarm offset from the native Calendar entry. In case of Anniversary,

// the offset is calculated from the midnight since native Calendar supports

// only dates in these types of entries

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

//

void CPIMAgnEventAdapter::ReadAlarmFromAgnL(MPIMEventItem& aItem,

        CCalEntry& aEntry)

{

    JELOG2(EPim);

    CCalAlarm* calAlarm = aEntry.AlarmL();

    // The previous function call returns NULL if there is no alarm

    // set in the item. The ownership is transferred to the caller

    // if the alarm values has been added to the item.

    if (calAlarm)

    {

        TTimeIntervalMinutes nativeValue = calAlarm->TimeOffset();

        // The alarm is not needed anymore so it can be deleted

        delete calAlarm;

        calAlarm = NULL;

        //            nativeValue.Int() );

        // Convert the alarm value based on the start time of the entry

        CCalEntry::TType entryType = aEntry.EntryTypeL();

        // Events (memos) and anniversaries do not have time in the native

        // side, therefore alarm field in those entries need to be calculated

        // from the end of the day

        if (entryType == CCalEntry::EAnniv)

        {

            TTime start(aEntry.StartTimeL().TimeLocalL());

            // Change the time to the end of the start date

            TTime startOfDayLocal(start);

            startOfDayLocal = StartOfDay(startOfDayLocal);

            // Calculate the difference from end of day and start time including

            // the original alarm offset which was previously read

            TTimeIntervalMinutes temp(0);

            User::LeaveIfError(startOfDayLocal.MinutesFrom(start, temp));

            // Since it is not possible to substract TTimeIntervalMinutes

            // from TTime (probably a Symbian error), the difference has

            // to be calculated using the following way...

            nativeValue = nativeValue.Int() + temp.Int();

        }

        TInt alarmValue = nativeValue.Int() * KPIMSecondsInMinute;

        //            alarmValue );

        // Add alarm value to the item

        TPIMFieldData fieldData(EPIMEventAlarm, EPIMFieldInt, KPIMAttrNone,

                                alarmValue);

        aItem.ItemData().AddValueL(fieldData);

    }

}

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

// CPIMAgnEventAdapter::ConvertAlarmToAgnL

// Converts alarm from PIM item to a native entry. The alarm is calculated

// from the start date of the event and if it is not present, the alarm field

// is ignored because there is no possibility to calculate it

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

//

void CPIMAgnEventAdapter::ConvertAlarmToAgnL(const MPIMEventItem& aItem,

        CCalEntry& aEntry)

{

    JELOG2(EPim);

    const MPIMItemData& itemData = aItem.ItemData();

    // Note that start time must be set before alarm can be calculated

    // Add start to the item so alarm can be properly converted. The

    // native entry does not accept alarm value if start is not present

    if (itemData.CountValues(EPIMEventStart) == 0)

    {

        User::Leave(KErrArgument);

    }

    else

    {

        ConvertDateFieldToAgnL(aItem, aEntry, EPIMEventStart);

    }