/*
* 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:  An event occurrence matcher.
 *
*/


// INCLUDE FILES
#include  "cpimeventmatcher.h"
#include  "cpimeventitem.h"
#include  "cpimrepeatrule.h"
#include  "pimpanics.h"
#include "logger.h"

CPIMEventMatcher::CPIMEventMatcher(const TPIMEventSearchType aSearchType,
                                   const TPIMDate& aStartDate, const TPIMDate& aEndDate,
                                   TBool aInitialEventOnly) :
        iSearchType(aSearchType), iStartDate(aStartDate), iEndDate(aEndDate),
        iInitialEventOnly(aInitialEventOnly)
{
    JELOG2(EPim);
}

CPIMEventMatcher::~CPIMEventMatcher()
{
    JELOG2(EPim);
}

TBool CPIMEventMatcher::SaneOptions()
{
    JELOG2(EPim);
    if (iSearchType != EPIMEventSearchStarting && iSearchType
            != EPIMEventSearchEnding && iSearchType != EPIMEventSearchOccurring)
    {
        return EFalse;
    }

    if (iStartDate > iEndDate)
    {
        return EFalse;
    }

    return ETrue;
}

TBool CPIMEventMatcher::MatchL(const CPIMEventItem& aTestedEvent,
                               TPIMDate& aOccurrenceStart) const
{
    JELOG2(EPim);
    TBool eventMatches = EFalse;

    switch (iSearchType)
    {
    case EPIMEventSearchStarting:
    {
        eventMatches = MatchStartingL(aTestedEvent, aOccurrenceStart);
        break;
    }
    case EPIMEventSearchEnding:
    {
        eventMatches = MatchEndingL(aTestedEvent, aOccurrenceStart);
        break;
    }
    case EPIMEventSearchOccurring:
    {
        eventMatches = MatchOccurringL(aTestedEvent, aOccurrenceStart);
        break;
    }
    default:
    {
        // Error
        User::Panic(KPIMPanicCategory, EPIMPanicEventItemsSearchType);
        break;
    }
    }

    return eventMatches;
}

TBool CPIMEventMatcher::MatchStartingL(const CPIMEventItem& aTestedEvent,
                                       TPIMDate& aOccurrenceStart) const
{
    JELOG2(EPim);
    // If the Event, regardless of repeating, starts between the given
    // range (inclusive), it matches. If we didn't get direct match,
    // we'll check if any of the repeating occurrences of the item
    // starts between the given range (if repeating occurrences are
    // taken into account and the Event is repeating).

    TPIMDate eventStart(0); // For matching and occurrence start
    TPIMDate dummyEnd(0); // Not used
    TBool match = EFalse;

    if (ExtractStartAndEndDateL(aTestedEvent, eventStart, dummyEnd) == KErrNone)
    {
        if (eventStart >= iStartDate && eventStart <= iEndDate)
        {
            aOccurrenceStart = eventStart;
            match = ETrue;
        }
        else if (!iInitialEventOnly && aTestedEvent.IsRepeating())
        {
            match = MatchStartingRepeatingL(eventStart, aTestedEvent,
                                            aOccurrenceStart);
        }
    }

    return match;
}

TBool CPIMEventMatcher::MatchStartingRepeatingL(const TPIMDate& aEventStart,
        const CPIMEventItem& aTestedEvent, TPIMDate& aOccurrenceStart) const
{
    JELOG2(EPim);
    TBool match = EFalse;

    const CPIMRepeatRule* repeatRule =
        static_cast<const CPIMRepeatRule*>(aTestedEvent.GetRepeat());

    CArrayFixFlat<TPIMDate>* occurrences = repeatRule->DatesL(aEventStart,
                                           iStartDate, iEndDate);

    const TInt numOccs = occurrences->Count();
    for (TInt occIndex = 0; occIndex < numOccs; occIndex++)
    {
        // Occurrence start date
        TPIMDate occ = occurrences->At(occIndex);

        if ((occ >= iStartDate) && (occ <= iEndDate))
        {
            aOccurrenceStart = occ;
            match = ETrue;
            break;
        }
    }

    delete occurrences;
    return match;
}

TBool CPIMEventMatcher::MatchEndingL(const CPIMEventItem& aTestedEvent,
                                     TPIMDate& aOccurrenceStart) const
{
    JELOG2(EPim);
    // If the Event, regardless of repeating, ends between the given
    // range (inclusive), it matches.  If we didn't get direct match,
    // we'll check if any of the repeating occurrences of the item
    // ends between the given range (if repeating occurrences are
    // taken into account and the Event is repeating).

    TPIMDate eventStart(0); // For occurrence start
    TPIMDate eventEnd(0); // For matching
    TBool match = EFalse;

    if (ExtractStartAndEndDateL(aTestedEvent, eventStart, eventEnd) == KErrNone)
    {
        if (eventEnd >= iStartDate && eventEnd <= iEndDate)
        {
            aOccurrenceStart = eventStart;
            match = ETrue;
        }
        else if (!iInitialEventOnly && aTestedEvent.IsRepeating())
        {
            match = MatchEndingRepeatingL(eventEnd, aTestedEvent,
                                          aOccurrenceStart);
        }
    }

    return match;
}

TBool CPIMEventMatcher::MatchEndingRepeatingL(const TPIMDate& aEventEnd,
        const CPIMEventItem& aTestedEvent, TPIMDate& aOccurrenceStart) const
{
    JELOG2(EPim);
    TBool match = EFalse;

    // We need the start date for getting the repeating
    // occurrences of the event. Skip if not present.
    TPIMDate eventStart(0);
    if (aTestedEvent.CountValuesL(EPIMEventStart) != 0)
    {
        // And again we just use the first start value
        eventStart = aTestedEvent.GetDateL(EPIMEventStart, 0);

        const CPIMRepeatRule* repeatRule =
            static_cast<const CPIMRepeatRule*>(aTestedEvent.GetRepeat());

        TTimeIntervalMicroSeconds eventLen = aEventEnd.MicroSecondsFrom(
                                                 eventStart);

        // We expand the subset of retrieved occurrences a bit
        // from the start so that the first possible end date is
        // included.
        CArrayFixFlat<TPIMDate>* occurrences = repeatRule->DatesL(eventStart,
                                               iStartDate - eventLen, iEndDate);

        const TInt numOccs = occurrences->Count();
        for (TInt occIndex = 0; occIndex < numOccs; occIndex++)
        {
            // Occurrence start date
            TPIMDate occ = occurrences->At(occIndex);

            if (((occ + eventLen) >= iStartDate) && ((occ + eventLen)
                    <= iEndDate))
            {
                aOccurrenceStart = occ;
                match = ETrue;
                break;
            }
        }

        delete occurrences;
    }

    return match;
}

TBool CPIMEventMatcher::MatchOccurringL(const CPIMEventItem& aTestedEvent,
                                        TPIMDate& aOccurrenceStart) const
{
    JELOG2(EPim);
    // If the Event, regardless of repeating, either starts or ends
    // between the given range (inclusive) or the start date is before
    // range start and the end date is after range end, it matches.
    // If we didn't get direct match, we'll check the same for any
    // possible repeating occurrences of the item.

    TPIMDate eventStart(0); // For matching and occurrence start
    TPIMDate eventEnd(0); // For matching
    TBool match = EFalse;

    if (ExtractStartAndEndDateL(aTestedEvent, eventStart, eventEnd) == KErrNone)
    {
        if (eventStart <= iEndDate && eventEnd >= iStartDate)
        {
            aOccurrenceStart = eventStart;
            match = ETrue;
        }
        else if (!iInitialEventOnly && aTestedEvent.IsRepeating())
        {
            match = MatchOccurringRepeatingL(eventStart, eventEnd,
                                             aTestedEvent, aOccurrenceStart);
        }
    }

    return match;
}

TBool CPIMEventMatcher::MatchOccurringRepeatingL(const TPIMDate& aEventStart,
        const TPIMDate& aEventEnd, const CPIMEventItem& aTestedEvent,
        TPIMDate& aOccurrenceStart) const
{
    JELOG2(EPim);
    TBool match = EFalse;

    const CPIMRepeatRule* repeatRule =
        static_cast<const CPIMRepeatRule*>(aTestedEvent.GetRepeat());

    TTimeIntervalMicroSeconds eventLen =
        aEventEnd.MicroSecondsFrom(aEventStart);

    // We expand the subset of retrieved occurrences a bit from the start
    // so that the first possible end date is included and a matching
    // event may start before the given range.
    CArrayFixFlat<TPIMDate>* occurrences = repeatRule->DatesL(aEventStart,
                                           iStartDate - eventLen, iEndDate);

    const TInt numOccs = occurrences->Count();
    for (TInt occIndex = 0; occIndex < numOccs; occIndex++)
    {
        // Occurrence start date
        TPIMDate occ = occurrences->At(occIndex);

        if (occ <= iEndDate && occ + eventLen >= iStartDate)
        {
            aOccurrenceStart = occ;
            match = ETrue;
            break;
        }
    }

    delete occurrences;
    return match;
}

TInt CPIMEventMatcher::ExtractStartAndEndDateL(const CPIMEventItem& aEvent,
        TPIMDate& aEventStart, TPIMDate& aEventEnd) const
{
    JELOG2(EPim);
    TInt retVal = KErrNone;

    if (aEvent.CountValuesL(EPIMEventStart) != 0)
    {
        // Start date is present.
        aEventStart = aEvent.GetDateL(EPIMEventStart, 0);
        if (aEvent.CountValuesL(EPIMEventEnd) != 0)
        {
            // End date is also present.
            aEventEnd = aEvent.GetDateL(EPIMEventEnd, 0);
        }
        else
        {
            // End date is not present - use start date also as end date.
            aEventEnd = aEventStart;
        }
    }
    else if (aEvent.CountValuesL(EPIMEventEnd) != 0)
    {
        // Start date is not present, but end date is present.
        // Use end date also as start date.
        aEventEnd = aEvent.GetDateL(EPIMEventEnd, 0);
        aEventStart = aEventEnd;
    }
    else
    {
        // Neither start or end date is present.
        retVal = KErrNotFound;
    }

    return retVal;
}

//  End of File