/*

* Copyright (c) 2007-2010 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:  Storage class for day and week views.

*

*/

//  INCLUDES

#include "calendayinfo.h"

#include "calenagendautils.h"

#include "calenconstants.h"

#include "calendateutils.h"

namespace

{

const int KUntimedDefaultSlot(16);

}

/*!

 \brief CalenDayInfo::CalenDayInfo

*/

CalenDayInfo::CalenDayInfo(TSlotsInHour aSlotsInHour) :

    iFirstUntimedSlot(KUntimedDefaultSlot), iSlotsInHour(aSlotsInHour)

{

    iSelectedSlot = KFSCalStartingHour * iSlotsInHour;

    iSelectedRegion = KErrNotFound;

    iSelectedColumn = 0;

    iSelectedAlldayEvent = KErrNotFound;

    iEarliestEndSlot = KErrNotFound;

    iLastStartSlot = KErrNotFound;

}

/*!

 \brief Destructor

*/

CalenDayInfo::~CalenDayInfo()

{

    for (int i = 0; i < iRegionList.count(); i++) {

        iRegionList[i].Close();

    }

    iRegionList.clear();

}

/*!

 \brief CalenDayInfo::Reset

*/

void CalenDayInfo::Reset()

{

    for (int i = 0; i < iRegionList.count(); i++) {

        iRegionList[i].Close();

    }

    iUntimedSlotCount = 0;

    iFirstUntimedSlot = KFSCalStartingHour * iSlotsInHour;

    iSelectedSlot = KFSCalStartingHour * iSlotsInHour;

    iSelectedRegion = KErrNotFound;

    iSelectedColumn = 0;

    iSelectedAlldayEvent = KErrNotFound;

    iEarliestEndSlot = KErrNotFound;

    iLastStartSlot = KErrNotFound;

}

/*!

 \brief CalenDayInfo::InsertTimedEvent

*/

void CalenDayInfo::InsertTimedEvent(const SCalenApptInfo& aItemInfo)

{

    int startIndex = SlotIndexForStartTime(aItemInfo.iStartTime);

    int endIndex = SlotIndexForEndTime(aItemInfo.iEndTime);

    }

    if (iRegionList.count() > 0) {

        // the timed events must be added in order

        ASSERT( startIndex >= iLastStartSlot );

    }

    CalenTimedEventInfo info;

    info.iStartSlot = startIndex;

    info.iEndSlot = endIndex;

    info.iId = aItemInfo.iId;

    info.iStatus = aItemInfo.iStatus;

    //    info.iReplicationStatus = aItemInfo.iReplicationStatus;

    iLastStartSlot = startIndex;

    if (iEarliestEndSlot == KErrNotFound || endIndex < iEarliestEndSlot) {

        iEarliestEndSlot = endIndex;

    }

    bool added(false);

    if (iRegionList.count() > 0) {

        // Since events are added in order, the event either overlaps the

        // last region or doesn't overlap any region at all

        CalenTimeRegion& region = iRegionList[iRegionList.count() - 1];

        if (region.Overlaps(info)) {

            region.AddEvent(info);

            added = true;

        }

    }

    if (!added) {

        // If it didn't overlap the last region, add a new region for this event.

        iRegionList.append(CalenTimeRegion());

        CalenTimeRegion& region = iRegionList[iRegionList.count() - 1];

        region.AddEvent(info);

        // Do rounding of the region ends

        if (iRegionList.count() >= 2) {

            // Check if the previous region end time can be rounded down

            CalenTimeRegion& prevRegion = iRegionList[iRegionList.count() - 2];

            int end = RoundHourDown(prevRegion.iEndSlot);

            if (end <= region.iStartSlot) {

                prevRegion.iEndSlot = end;

            }

            // Check if the start time of the new region can be rounded up

            int start = RoundHourUp(region.iStartSlot);

            if (start >= prevRegion.iEndSlot) {

                region.iStartSlot = start;

            }

        }

        else {

            // No previous region, round the start time up

            region.iStartSlot = RoundHourUp(region.iStartSlot);

        }

    }

}

/*!

 \brief CalenDayInfo::InsertAlldayEvent

*/

void CalenDayInfo::InsertAlldayEvent(const SCalenApptInfo& aItemInfo)

{

    CalenTimedEventInfo info;

    info.iStartSlot = 0;

    info.iEndSlot = iSlotsInHour * KCalenHoursInDay + iUntimedSlotCount;

    info.iId = aItemInfo.iId;

    info.iStatus = aItemInfo.iStatus;

    //    info.iReplicationStatus = aItemInfo.iReplicationStatus;

    iAlldayEvents.append(info);

}

/*!

 \brief CalenDayInfo::IsAllDayEvent

*/

bool CalenDayInfo::IsAlldayEvent(QDateTime aStart, QDateTime aEnd)

{

    bool isAllDay(false);

    if (!CalenDateUtils::onSameDay(aStart, aEnd)) {

        QDateTime startMidnight = CalenDateUtils::beginningOfDay(aStart);

        QDateTime endMidnight = CalenDateUtils::beginningOfDay(aEnd);

        if ((aStart == startMidnight) && (aEnd == endMidnight)) {

            isAllDay = true;

        }

    }

    return isAllDay;

}

/*!

 \brief CalenDayInfo::IsAllDayEvent

 Allday event is an event starting and ending at midnight,

 with a duration of n*24h.

*/

/*

bool CalenDayInfo::IsAlldayEvent(const CCalInstance& aInstance)

{

    bool isAllDay(false);

    // If getting the start or end time fails, return false.

    QDateTime start;

    QDateTime end;

    TRAPD( error,

        {

            start = aInstance.StartTimeL().TimeLocalL();

            end = aInstance.EndTimeL().TimeLocalL();

        });

    if (error == KErrNone && !CalenDateUtils::onSameDay(start, end)) {

        QDateTime startMidnight = CalenDateUtils::beginningOfDay(start);

        QDateTime endMidnight = CalenDateUtils::beginningOfDay(end);

        if ((start == startMidnight) && (end == endMidnight)) {

            isAllDay = true;

        }

    }

    if (error != KErrNone) {

        CEikonEnv::Static()->HandleError(error);//codescanner::eikonenvstatic

    }

    return isAllDay;

}

*/

/*!

 \brief CalenDayInfo::AlldayCount

*/

int CalenDayInfo::AlldayCount()

{

    return iAlldayEvents.count();

}

/*!

 \brief CalenDayInfo::TodoCount

*/

int CalenDayInfo::TodoCount()

{

    return iTodoEvents.count();

}

/*!

 \brief CalenDayInfo::GetLocation

*/

void CalenDayInfo::GetLocation(

    const SCalenApptInfo& aItemInfo,

    int& aStartSlot,

    int& aEndSlot,

    int& aColumnIndex,

    int& aColumns)

{

    int startIndex = SlotIndexForStartTime(aItemInfo.iStartTime);

    int endIndex = SlotIndexForEndTime(aItemInfo.iEndTime);

    if (endIndex == startIndex) {

        endIndex++;

    }

    aStartSlot = startIndex;

    aEndSlot = endIndex;

    CalenSlotInterval interval;

    interval.iStartSlot = startIndex;

    interval.iEndSlot = endIndex;

    bool found(false);

    // Scan through all allday events and see if it matches any of them

    for (int i = 0; i < iAlldayEvents.count() && !found; i++) {

        if (aItemInfo.iId == iAlldayEvents[i].iId) {

            aColumns = iAlldayEvents.count();

            aColumnIndex = i;

            found = true;

        }

    }

    // Scan through all regions and see if the event overlaps any region.

    // If it overlaps a region, the event must be in that region.

    for (int i = 0; i < iRegionList.count() && !found; i++) {

        CalenTimeRegion& region = iRegionList[i];

        if (region.Overlaps(interval)) {

            // Scan through all columns and look for the event

            aColumns = region.iColumns.count();

            for (int j = 0; j < aColumns && !found; j++) {

                if (region.iColumns[j].ContainsEvent(aItemInfo.iId)) {

                    aColumnIndex = j;

                    found = true;

                }

            }

            // the event should be in this region if it overlaps the region

            ASSERT( found );

        }

    }

    // the event should have been found somewhere

    ASSERT( found );

}

/*!

 \brief CalenDayInfo::GetSelectedSlot

*/

void CalenDayInfo::GetSelectedSlot(int& aSlot, int& aRegion, int& aColumnIndex, int& aColumns)

{

    aSlot = iSelectedSlot;

    aColumnIndex = iSelectedColumn;

    if (iSelectedRegion >= 0) {

        aColumns = iRegionList[iSelectedRegion].iColumns.count();

        aRegion = iSelectedRegion;

    }

    else {

        aColumns = 0;

        aRegion = KErrNotFound;

    }

}

/*!

 \brief CalenDayInfo::FindRegion

*/

int CalenDayInfo::FindRegion(const CalenSlotInterval& aInterval, int aDirection)

{

    // Setup the start and end region indices for iterating

    int start, end;

    if (aDirection > 0) {

        start = 0;

        end = iRegionList.count();

    }

    else {

        start = iRegionList.count() - 1;

        end = -1;

    }

    int region = KErrNotFound;

    // Iterate over the regions, in the order given, looking for a region

    // overlapping this interval

    for (int i = start; i != end && region < 0; i += aDirection) {

        if (iRegionList[i].Overlaps(aInterval)) {

            region = i;

        }

    }

    return region;

}

/*!

 \brief Find an event within the given interval of the current column,

 searching in the given direction.

*/

int CalenDayInfo::FindEvent(const CalenSlotInterval& aInterval, int aDirection)

{

    ASSERT( iSelectedRegion >= 0 && iSelectedRegion < iRegionList.count() );

    CalenTimeRegion& region = iRegionList[iSelectedRegion];

    int index = KErrNotFound;

    if (iSelectedColumn < region.iColumns.count()) {

        CalenTimeColumn& column = region.iColumns[iSelectedColumn];

        int start, end;

        if (aDirection > 0) {

            start = 0;

            end = column.iEventArray.count();

        }

        else {

            start = column.iEventArray.count() - 1;

            end = -1;

        }

        // Iterate over the events in the chosen column in the order given,

        // looking for an event overlapping this interval

        for (int i = start; i != end && index < 0; i += aDirection) {

            if (column.iEventArray[i].Overlaps(aInterval)) {

                index = i;

            }

        }

    }

    return index;

}

/*!

 \brief CalenDayInfo::IsEventSelected

*/

bool CalenDayInfo::IsEventSelected() const

{

    bool selected(false);

    if (iSelectedAlldayEvent >= 0) {

        selected = true;

    }

    else

        if (iSelectedRegion >= 0 && iSelectedColumn < iRegionList[iSelectedRegion].iColumns.count()

            && iSelectedColumnEventIndex >= 0) {

            selected = true;

        }

        else

            if (IsExtraSlot(iSelectedSlot) && iSelectedSlot - iFirstUntimedSlot

                >= iEmptyUntimedSlots) {

                selected = true;

            }

            else {

                // if no event is selected, the selection slot must be a hour starting slot or an extra slot

                ASSERT( IsHourStartSlot( iSelectedSlot ) || IsExtraSlot( iSelectedSlot ) );

                selected = false;

            }

    return selected;

}

/*!

 \brief CalenDayInfo::IsMultipleEventsSelected

*/

bool CalenDayInfo::IsMultipleEventsSelected() const

{

    bool isMultiple(false);

    if (iSelectedAlldayEvent >= 0) {

        // If an allday event is selected, disregard the value of

        // iSelectedSlot

        isMultiple = false;

    }

    else

        if (IsExtraSlot(iSelectedSlot)) {

            int index = iSelectedSlot - iFirstUntimedSlot - iEmptyUntimedSlots;

            isMultiple = (index == 0) && iTodoEvents.count() > 1;

        }

    return isMultiple;

}

/*!

 \brief CalenDayInfo::IsAlldayEventSelected

*/

bool CalenDayInfo::IsAlldayEventSelected() const

{

    bool selected(false);

    if (iSelectedAlldayEvent >= 0) {

        ASSERT( iSelectedAlldayEvent < iAlldayEvents.count() );

        selected = true;

    }

    return selected;

}

/*!

 \brief CalenDayInfo::UntimedEvent

*/

TCalenInstanceId CalenDayInfo::UntimedEvent(int aIndex)

{

    TCalenInstanceId id;

    if (iTodoEvents.count() > 0 && aIndex == 0) {

        id = iTodoEvents[0];

    }

    else {

        // If we have one or more todo items, the first slot is used for them

        // (but not more than one slot)

        if (iTodoEvents.count() > 0) {

            aIndex--;

        }

        if (aIndex >= 0 && aIndex < iUntimedEvents.count()) {

            id = iUntimedEvents[aIndex];

        }

        else {

            // should not happen

            User::Invariant();

        }

    }

    return id;

}

/*!

 \brief CalenDayInfo::AlldayEvent

*/

const CalenTimedEventInfo& CalenDayInfo::AlldayEvent(int aIndex)

{

    ASSERT( aIndex >= 0 && aIndex < iAlldayEvents.count() );

    return iAlldayEvents[aIndex];

}

/*!

 \brief CalenDayInfo::SelectedEvent

*/

TCalenInstanceId CalenDayInfo::SelectedEvent()

{

    TCalenInstanceId id;

    if (iSelectedAlldayEvent >= 0) {

        ASSERT( iSelectedAlldayEvent < iAlldayEvents.count() );

        id = iAlldayEvents[iSelectedAlldayEvent].iId;

    }

    else

        if (iSelectedRegion >= 0) {

            ASSERT( iSelectedRegion < iRegionList.count() );

            CalenTimeRegion& region = iRegionList[iSelectedRegion];

            if (iSelectedColumn < region.iColumns.count()) {

                CalenTimeColumn& column = region.iColumns[iSelectedColumn];

                if (iSelectedColumnEventIndex >= 0 && iSelectedColumnEventIndex

                    < column.iEventArray.count()) {

                    CalenTimedEventInfo& info = column.iEventArray[iSelectedColumnEventIndex];

                    id = info.iId;

                }

                else {

                    // should not happen, no event selected in the column

                    User::Invariant();

                }

            }

            else {

                // should not happen, the empty column was selected

                User::Invariant();

            }

        }

        else

            if (IsExtraSlot(iSelectedSlot)) {

                int index = iSelectedSlot - iFirstUntimedSlot - iEmptyUntimedSlots;

                id = UntimedEvent(index);

            }

            else {

                // should not happen

                User::Invariant();

            }

    return id;

}

/*!

 \brief CalenDayInfo::SelectEvent

 Return KErrNotFound if not found, otherwise KErrNone

*/

int CalenDayInfo::SelectEvent(const TCalenInstanceId& aId)

{

    // Id can be of allday event, untimed event or other events

    // Look for this event id in all event data structures and set

    // the state accordingly if it was found

    for (int i(0); i < iAlldayEvents.count(); i++) {