/*

* 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:  Amc

*

*/

#ifndef AMC_H

#define AMC_H

#include <list>

#include <map>

#include "logger.h"

#include "scopedlocks.h"

#include "javauid.h"

#include "commslistener.h"

#include "commsmessage.h"

#include "applicationruntimeeventsinterface.h"

#include "coreinterface.h"

#include "rtcinterface.h"

#include "amcinterface.h"

#include "amcmessages.h"

using namespace java::comms;

using java::util::Uid;

namespace java

{

namespace captain

{

class ApplicationManagementEventsInterface;

using java::util::ScopedLock;

class Amc : public AmcInterface,

        public ApplicationRuntimeEventsInterface,

        public CommsListener

{

public:

    Amc();

    virtual ~Amc();

    bool start(CoreInterface* aCore,

               ApplicationManagementEventsInterface* aAmEventsDispatcher);

    bool stop();

    // ApplicationRuntimeEventsInterface

    virtual void arLaunched(const Uid& aUID, const int& aRuntimeCommsAddress);

    virtual void arTerminated(const Uid& aUID, const int& aExitCode);

    // CommsListener methods

    virtual void processMessage(CommsMessage& aMessage);

private:

    // Helper functions for request handling

    void handleStart(CommsMessage&);

    void handleStop(CommsMessage&);

    void handleUpdate(CommsMessage&);

    class StopRequest

    {

    public:

        StopRequest(CoreInterface* aCore, const int& aAddress, const int& aModuleId, const int& aMsgRef,

                    const int& aNumOfUIDS, Uid* aUIDS)

                :mCore(aCore), mAddress(aAddress), mModuleId(aModuleId), mMsgRef(aMsgRef)

        {

            JELOG2(EJavaCaptain);

            java::util::ScopedLock lock(mUidsCollectionsMutex);

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

            {

                mUidsToBeStopped.push_back(aUIDS[i]);

            }

        }

        bool stopUids()

        {

            JELOG2(EJavaCaptain);

            ScopedLock lock(mUidsCollectionsMutex);

            uids_t::iterator iter = mUidsToBeStopped.begin();

            while (iter != mUidsToBeStopped.end())

            {

                mCore->getRtc()->disable(*iter);

                if (mCore->getRtc()->terminate(*iter))

                {

                    // Was not running in the first place can be directly put to stopped list

                    mUidStatuses.insert(std::make_pair(*iter, 0));

                    iter = mUidsToBeStopped.erase(iter);

                }

                else

                {

                    ++iter;

                }

            }

            // Was the request fulfilled.

            if (!mUidsToBeStopped.size())

            {

                notifyRequester();

                return true;

            }

            return false; // Nope some requests are still pending.

        }

        bool updateStatus(const Uid& aUID, const int& status)

        {

            JELOG2(EJavaCaptain);

            ScopedLock lock(mUidsCollectionsMutex);

            for (uids_t::iterator iter = mUidsToBeStopped.begin() ;

                    iter != mUidsToBeStopped.end() ; ++iter)

            {

                if (*iter == aUID)

                {

                    mUidStatuses.insert(std::make_pair(aUID, status));

                    mUidsToBeStopped.erase(iter);

                    break;

                }

            }

            // Was this the last one ie. the request has been fulfilled.

            if (!mUidsToBeStopped.size())

            {

                notifyRequester();

                return true;

            }

            return false; // Nope some requests are still pending.

        }

        void notifyRequester()

        {

            JELOG2(EJavaCaptain);

            CommsMessage message;

            message.setReceiver(mAddress);

            message.setModuleId(mModuleId);

            message.setMessageRef(mMsgRef);

            setAmcResponseParamaters(message, mUidStatuses.size());

            for (uidStatuses_t::iterator iter = mUidStatuses.begin() ;

                    iter != mUidStatuses.end() ; ++iter)

            {

                message << iter->first << iter->second;

            }

            mCore->getComms()->send(message);

        }

        void sendStopNotAllowed(const int& aNumOfUIDS, Uid* aUIDS)

        {

            JELOG2(EJavaCaptain);

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

            {

                updateStatus(aUIDS[i], -1);

            }

        }

    private:

        typedef std::list<Uid>  uids_t;

        uids_t                  mUidsToBeStopped;

        typedef std::map<Uid, int> uidStatuses_t;

        uidStatuses_t           mUidStatuses;

        java::util::ScopedMutex mUidsCollectionsMutex;

        CoreInterface*          mCore;

        const int               mAddress;

        const int               mModuleId;

        const int               mMsgRef;

    };

    CoreInterface*                          mCore;

    ApplicationManagementEventsInterface*   mAmEventsDispatcher;

    StopRequest*                            mStopRequest; // only one at a time

};

} // namespace captain

} // namespace java

#endif // AMC_H