/*
* Copyright (c) 2002-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: provides functionality common to all server operations
*
*
*/


#include <EPos_Landmarks.h>
#include "EPos_CPosLmServerOperation.h"
#include "EPos_LandmarksServerPanics.h"
#include "EPos_MPosLmServerOperationObserver.h"
#include "EPos_PosLmServerCommon.h"
#include "EPos_LmServerGlobal.h"

const TInt KDrivePosition = 7;

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmServerOperation::CPosLmServerOperation(
    CPosLmServer& aServer,
    MPosLmServerOperationObserver* aObserver ) :
    CActive(EPriorityIdle),
    iServer( aServer ),
    iObserver(aObserver),
    iProgress(0),
    iStatusFlag(KPosLmOperationNotComplete)
    {
    CActiveScheduler::Add(this);
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::BaseConstructL(
    const TDesC& aUri)
    {
    iDb = CPosLmLocalDbAccess::NewL();
    User::LeaveIfError(iDb->OpenDatabaseL(aUri));

    iDiskUtilities = CPosLmDiskUtilities::NewL();

    iDbDrive = aUri[KDrivePosition];
    iDbUri = aUri.AllocL();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmServerOperation::~CPosLmServerOperation()
    {
    Cancel();
    if (iStatusFlag == KErrNone)
        {
        iStatusFlag = KErrServerTerminated;
        }
    CompleteAndRemoveMessagesFromSyncWaitList();
    CompleteAndRemoveMessagesFromAsyncWaitList();
    iSyncWaitList.Close();
    iAsyncWaitList.Close();
    delete iDiskUtilities;
    delete iDb;
    iClientSessions.Close();
    delete iDbUri;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CPosLmServerOperation::RunError( TInt aError )
    {
    iStatusFlag = aError;
    CompleteAndRemoveMessagesFromSyncWaitList();
    CompleteAndRemoveMessagesFromAsyncWaitList();
    iObserver->HandleOperationStatus(this, iStatusFlag);

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::DoCancel()
    {
    iStatusFlag = KErrCancel;
    CompleteAndRemoveMessagesFromSyncWaitList();
    CompleteAndRemoveMessagesFromAsyncWaitList();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::AddToSyncWaitListL(
    const RMessage2& aMessage,
    TAny* aSession)
    {
    User::LeaveIfError(iSyncWaitList.Append(Message(aMessage, aSession)));
    if (iClientSessions.Find(static_cast<TUint*>(aSession)) == KErrNotFound)
        {
        User::LeaveIfError(iClientSessions.Append(
                    static_cast<TUint*>(aSession)));
        }

    if ( iStatusFlag != KPosLmOperationNotComplete )
        {
        NotifyClients();
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::AddToAsyncWaitListL(
    const RMessage2& aMessage,
    TAny* aSession )
    {
    TPckgBuf<TReal32> progress;
    TInt desMaxLength = aMessage.GetDesMaxLength(KPosLmServerProgressArg);
    if (desMaxLength != progress.Length())
        {
        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);
        return;
        }
    User::LeaveIfError(iAsyncWaitList.Append(Message(aMessage, aSession)));
    if (iClientSessions.Find(static_cast<TUint*>(aSession)) == KErrNotFound)
        {
        User::LeaveIfError(iClientSessions.Append(
            static_cast<TUint*>(aSession)));
        }
    
    if ( iStatusFlag != KPosLmOperationNotComplete )
        {
        // this client should only be informed about operation
        // status (because it has not been yet) and removed from
        // operation's clients
        NotifyClients();
        RemoveSessionMessages( aSession );
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::RemoveFromAsyncWaitList(
    const RMessage2& aMessage,
    TAny* aSession)
    {
    RemoveFromWaitList(iAsyncWaitList, aSession);
    LmServerGlobal::Complete(aMessage, KErrNone);

    TInt position = iClientSessions.Find(static_cast<TUint*>(aSession));
    if (position != KErrNotFound)
        {
        iClientSessions.Remove(position);
        }
    iObserver->HandleOperationStatus( this, iStatusFlag );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::RemoveSessionMessages(
    TAny* aSession)
    {
    RemoveFromWaitList(iAsyncWaitList, aSession);
    RemoveFromWaitList(iSyncWaitList, aSession);

    TInt position = iClientSessions.Find(static_cast<TUint*>(aSession));
    if (position != KErrNotFound)
        {
        iClientSessions.Remove(position);
        }
    iObserver->HandleOperationStatus( this, iStatusFlag );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::CompleteAndRemoveMessagesFromAsyncWaitList()
    {
    for (TInt i = 0; i < iAsyncWaitList.Count(); i++)
        {
        Write(iAsyncWaitList[i].iMsg);
        LmServerGlobal::Complete(iAsyncWaitList[i].iMsg, iStatusFlag);
        }

    iAsyncWaitList.Reset();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::CompleteAndRemoveMessagesFromSyncWaitList()
    {
    for (TInt i = 0; i < iSyncWaitList.Count(); i++)
        {
        LmServerGlobal::Complete(iSyncWaitList[i].iMsg, iStatusFlag);
        }

    iSyncWaitList.Reset();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::Write(
    const RMessage2& aMessage)
    {
    // It is not necessary to return the error code, because the client will be
    // panicked if the write fails. Hence, the client won't receive the error
    // anyway.
    TPckgBuf<TInt> statusFlag(iStatusFlag);
    TInt err = LmServerGlobal::Write(aMessage, KPosLmServerStatusArg,
        statusFlag);

    if (err == KErrNone)
        {
        TPckgBuf<TReal32> progress(iProgress);
        err = LmServerGlobal::Write(aMessage, KPosLmServerProgressArg,
            progress);

        if (err == KErrNone && iStatusFlag == KErrNone)
            {
            // Reset init flag on client side
            TPckgBuf<TUint> initFlag(ENoInit);
            LmServerGlobal::Write(aMessage, KPosLmServerInitFlagArg, initFlag);
            }
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::NotifyClients()
    {
    // Check if there are any clients left listening for status
    if (iClientSessions.Count() == 0)
        {
        Cancel();
        iObserver->HandleOperationStatus(this, iStatusFlag);
        return;
        }

    CompleteAndRemoveMessagesFromAsyncWaitList();

    if ( iStatusFlag == KErrNone )
        {
        CompleteAndRemoveMessagesFromSyncWaitList();
        iObserver->HandleOperationStatus(this, iStatusFlag);
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::CompleteSelf()
    {
    TRequestStatus* status = &iStatus;
    User::RequestComplete(status, KErrNone);
    SetActive();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmServerOperation::RemoveFromWaitList(
    RArray<TPosMessage>& aWaitList,
    TAny* aSession)
    {
    for (TInt i = 0; i < aWaitList.Count(); i++)
        {
        if (aSession == aWaitList[i].iSession)
            {
            LmServerGlobal::Complete(aWaitList[i].iMsg, KErrCancel);
            aWaitList.Remove(i--);
            }
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmServerOperation::TPosMessage CPosLmServerOperation::Message(
    const RMessage2& aMessage,
    TAny* aSession)
    {
    TPosMessage msg;
    msg.iSession = aSession;
    msg.iMsg = aMessage;

    return msg;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CPosLmServerOperation::Status() const
    {
    return iStatusFlag;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CPosLmServerOperation::IsRegistered( TAny* aSession ) const
    {
    return iClientSessions.Find( static_cast<TUint*>( aSession ) ) != KErrNotFound;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CPosLmServerOperation::HasRequests( TAny* aSession ) const
    {
    for ( TInt i = 0; i < iAsyncWaitList.Count(); i++ )
        {
        if ( iAsyncWaitList[i].iSession == aSession )
            return ETrue;
        }
    for ( TInt i = 0; i < iSyncWaitList.Count(); i++ )
        {
        if ( iSyncWaitList[i].iSession == aSession )
            return ETrue;
        }
    return EFalse;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CPosLmServerOperation::HasClients() const
    {
    return iClientSessions.Count() > 0;;
    }