/*
* Copyright (c) 2005 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: class to handle event notification to subscribers.
*
*
*/


// INCLUDE FILES
#include "EPos_CPosLmEventHandler.h"
#include "EPos_LandmarksServerPanics.h"
#include "EPos_PosLmServerCommon.h"
#include "EPos_LmServerGlobal.h"

// CONSTANTS
const TInt KEventQueueMaxSize = 5;

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

// -----------------------------------------------------------------------------
// CPosLmEventHandler::CPosLmEventHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPosLmEventHandler::CPosLmEventHandler()
    {
    }

// Two-phased constructor.
CPosLmEventHandler* CPosLmEventHandler::NewL()
    {
    CPosLmEventHandler* self = new (ELeave) CPosLmEventHandler();
    return self;
    }

// Destructor
CPosLmEventHandler::~CPosLmEventHandler()
    {
    LmServerGlobal::Complete(iHoldingMessage, KErrCancel);
    iEventQueue.Close();
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::HandleRequestForEventL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmEventHandler::HandleRequestForEventL(
    const RMessagePtr2& aMessage)
    {
    TPckgBuf<TPosLmEvent> event;
    TInt desMaxLength = aMessage.GetDesMaxLength(KPosLmServerEventArg);
    if (desMaxLength != event.Length())
        {
        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);
        return;
        }

    if (iEventQueue.Count() > 0)
        {
        // Send the first event in the queue to the client.
        WriteEventAndComplete(aMessage, iEventQueue[0]);
        iEventQueue.Remove(0);
        }
    else
        {
        // No events in queue. Put the message on hold.
        if (!iHoldingMessage.IsNull())
            {
            PanicClient(aMessage,
                EPosEventNotifierAlreadyHasOutstandingRequest);
            }
        else
            {
            iHoldingMessage = aMessage;
            }
        }
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::HandleIncomingEventL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmEventHandler::HandleIncomingEventL(
    TPosLmEvent aEvent)
    {
    if (!iHoldingMessage.IsNull())
        {
        // There is a message on hold. Send response immediately.
        WriteEventAndComplete(iHoldingMessage, aEvent);
        }
    else
        {
        // Subscriber is not waiting. Add event to queue.
        AddToEventQueueL(aEvent);
        }
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::CompleteAnyOutStandingRequest
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmEventHandler::CompleteAnyOutStandingRequest(
    TInt aError)
    {
    LmServerGlobal::Complete(iHoldingMessage, aError);
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::WriteEventAndComplete
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmEventHandler::WriteEventAndComplete(
    const RMessagePtr2& aMessage,
    TPosLmEvent aEvent)
    {
    TPckgBuf<TPosLmEvent> event(aEvent);
    if (LmServerGlobal::Write(
        aMessage, KPosLmServerEventArg, event) == KErrNone)
        {
        LmServerGlobal::Complete(aMessage, KErrNone);
        }
    // Client will be panicked if write fails.
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::AddToEventQueueL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmEventHandler::AddToEventQueueL(
    TPosLmEvent aEvent)
    {
    if (aEvent.iEventType == EPosLmEventMediaRemoved)
        {
        // Media is removed. All other events are removed. They are unnecessary.
        iEventQueue.Reset();
        }
    else if (aEvent.iEventType == EPosLmEventNewDefaultDatabaseLocation)
        {
        // Remove all other equal events, if found.
        TInt queuePosition;
        RemoveEvents(ENewDefaultDbs, queuePosition);
        }
    else if (!MergeEventsIfPossibleL(aEvent))
        {
        // Incoming event should not be added to queue.
        return;
        }

    User::LeaveIfError(iEventQueue.Append(aEvent));
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::MergeEventsIfPossibleL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CPosLmEventHandler::MergeEventsIfPossibleL(
    TPosLmEvent aEvent)
    {
    TPosLmEventType incoming = aEvent.iEventType;
    TBool addEvent = ETrue;
    TInt noOfSpecificLms = 0;
    TInt noOfSpecificCats = 0;

    for (TInt i = 0; i < iEventQueue.Count(); i++)
        {
        TPosLmEventType eventInQueue = iEventQueue[i].iEventType;

        // EPosLmEventMediaRemoved and EPosLmEventNewDefaultDatabaseLocation
        // should not be removed from the queue, no matter what.
        // See also AddToEventQueue.
        if (eventInQueue != EPosLmEventMediaRemoved &&
            eventInQueue != EPosLmEventNewDefaultDatabaseLocation)
            {
            if (incoming == EPosLmEventUnknownChanges)
                {
                // Unknown changes. All old events are removed.
                iEventQueue.Remove(i--);
                }
            else if (incoming == EPosLmEventCategoryUnknownChanges)
                {
                // Unknown category changes.
                HandleUnknownEvent(eventInQueue,
                    IsSpecificCategory(eventInQueue) ||
                    eventInQueue == EPosLmEventCategoryUnknownChanges,
                    addEvent, i);
                }
            else if (incoming == EPosLmEventLandmarkUnknownChanges)
                {
                // Unknown landmark changes.
                HandleUnknownEvent(eventInQueue,
                    IsSpecificLandmark(eventInQueue) ||
                    eventInQueue == EPosLmEventLandmarkUnknownChanges,
                    addEvent, i);
                }
            else if (IsSpecificCategory(incoming))
                {
                // Specific category
                HandleSpecificEvent(eventInQueue,
                    EPosLmEventCategoryUnknownChanges,
                    addEvent, noOfSpecificCats, noOfSpecificLms);
                }
            else
                {
                // Specific landmark
                HandleSpecificEvent(eventInQueue,
                    EPosLmEventLandmarkUnknownChanges,
                    addEvent, noOfSpecificCats, noOfSpecificLms);
                }
            }
        }

    // If adding a specific landmark or category and queue is full,
    // either specific landmarks or categories are merged into a
    // corresponding EPosLmEventLandmarkUnknownChanges or
    // EPosLmEventCategoryUnknownChanges.
    if ((noOfSpecificLms > 0 || noOfSpecificCats > 0) &&
        iEventQueue.Count() == KEventQueueMaxSize)
        {
        TPosLmEvent event;
        event.iLandmarkItemId = KPosLmNullItemId;
        TInt queuePositionOfFirstSpecific;

        if (noOfSpecificCats > noOfSpecificLms)
            {
            RemoveEvents(ESpecificCategories, queuePositionOfFirstSpecific);
            event.iEventType = EPosLmEventCategoryUnknownChanges;
            addEvent = IsSpecificLandmark(incoming);
            }
        else
            {
            RemoveEvents(ESpecificLandmarks, queuePositionOfFirstSpecific);
            event.iEventType = EPosLmEventLandmarkUnknownChanges;
            addEvent = IsSpecificCategory(incoming);
            }

        // This should not happen, because when calling RemoveEvents above,
        // there will always be either categories or landmarks in the queue
        // (see if-statement above).
        __ASSERT_DEBUG(queuePositionOfFirstSpecific != KErrNotFound,
            PanicServer(KErrGeneral));

        User::LeaveIfError(iEventQueue.Insert(event,
            queuePositionOfFirstSpecific));
        }

    return addEvent;
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::HandleUnknownEvent
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmEventHandler::HandleUnknownEvent(
    TPosLmEventType aEventInQueue,
    TBool aExpression,
    TBool& aAddEvent,
    TInt& aIndex)
    {
    if (aEventInQueue == EPosLmEventUnknownChanges)
        {
        // Unknown changes found in queue. Incoming event should not
        // be added to queue.
        aAddEvent = EFalse;
        }
    else if (aExpression)
        {
        // Remove any specific events or
        // EPosLmEventCategoryUnknownChanges/EPosLmEventLandmarkUnknownChanges.
        iEventQueue.Remove(aIndex--);
        }
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::HandleSpecificEvent
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmEventHandler::HandleSpecificEvent(
    TPosLmEventType aEventInQueue,
    TPosLmEventType aCompareEventType,
    TBool& aAddEvent,
    TInt& aNoOfSpecificCats,
    TInt& aNoOfSpecificLms)
    {
    if (aEventInQueue == EPosLmEventUnknownChanges ||
        aEventInQueue == aCompareEventType)
        {
        // Unknown (category) changes found in queue. Incoming event
        // should not be added to queue.
        aAddEvent = EFalse;
        }
    else if (IsSpecificCategory(aEventInQueue))
        {
        aNoOfSpecificCats++;
        }
    else if (IsSpecificLandmark(aEventInQueue))
        {
        aNoOfSpecificLms++;
        }
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::IsSpecificLandmark
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CPosLmEventHandler::IsSpecificLandmark(
    TPosLmEventType aEventType)
    {
    return aEventType > EPosLmEventLandmarkUnknownChanges &&
        aEventType < EPosLmEventCategoryUnknownChanges;
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::IsSpecificCategory
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CPosLmEventHandler::IsSpecificCategory(
    TPosLmEventType aEventType)
    {
    return aEventType > EPosLmEventCategoryUnknownChanges;
    }

// -----------------------------------------------------------------------------
// CPosLmEventHandler::RemoveEvents
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmEventHandler::RemoveEvents(
    TRemoveEventType aRemoveType,
    TInt& aQueuePosition)
    {
    aQueuePosition = KErrNotFound;

    for (TInt i = 0; i < iEventQueue.Count(); i++)
        {
        TPosLmEventType eventInQueue = iEventQueue[i].iEventType;

        if (aRemoveType == ESpecificLandmarks &&
                IsSpecificLandmark(eventInQueue) ||
            aRemoveType == ESpecificCategories &&
                IsSpecificCategory(eventInQueue) ||
            aRemoveType == ENewDefaultDbs &&
                eventInQueue == EPosLmEventNewDefaultDatabaseLocation)
            {
            if (aQueuePosition == KErrNotFound)
                {
                aQueuePosition = i;
                }
            iEventQueue.Remove(i--);
            }
        }
    }

// End of File