/*

* 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

*

*/

#include <set>

#include <algorithm>

#include "logger.h"

#include "javacommonutils.h"

#include "commsendpoint.h"

#include "comms.h"

#include "commsmessage.h"

#include "amc.h"

#include "coreinterface.h"

#include "applicationmanagementeventsinterface.h"

namespace java

{

namespace captain

{

Amc::Amc():mCore(0), mAmEventsDispatcher(0), mStopRequest(0)

{

    JELOG2(EJavaCaptain);

}

Amc::~Amc()

{

    JELOG2(EJavaCaptain);

    mCore = 0;

    mAmEventsDispatcher = 0;

    mStopRequest = 0;

}

bool Amc::start(CoreInterface* aCore,

                ApplicationManagementEventsInterface* aAmEventsDispatcher)

{

    JELOG2(EJavaCaptain);

    mCore = aCore;

    mAmEventsDispatcher = aAmEventsDispatcher;

    mCore->getComms()->registerListener(PLUGIN_ID_AMC_C, this);

    return true;

}

bool Amc::stop()

{

    JELOG2(EJavaCaptain);

    if (mCore)

    {

        mCore->getComms()->unregisterListener(PLUGIN_ID_AMC_C, this);

    }

    return true;

}

void Amc::arLaunched(const Uid&, const int&)

{   // Ignored

    JELOG2(EJavaCaptain);

}

void Amc::arTerminated(const Uid& aUID, const int& /*aExitCode*/)

{

    JELOG2(EJavaCaptain);

    // status is hard coded to be ok (=0) on purpose because

    // javainstaller only cares that application has exited

    if (mStopRequest && mStopRequest->updateStatus(aUID, 0))

    {

        delete mStopRequest;

        mStopRequest = 0;

    }

}

// CommsListener methods

void Amc::processMessage(CommsMessage& aMessage)

{

    JELOG2(EJavaCaptain);

    switch (aMessage.getMessageId())

    {

    case AMC_MSG_ID_REQUEST:

    {

        int operation = 0;

        int options = 0;

        getAmcRequestParams(aMessage, operation, options);

        LOG2(EJavaCaptain, EInfo, "Amc::Request %s, %s",

             amcRequestOperation2String(operation),

             amcRequestOptions2String(options));

        switch (operation)

        {

        case AMC_REQUEST_OPERATION_START:

            handleStart(aMessage);

            break;

        case AMC_REQUEST_OPERATION_STOP:

            handleStop(aMessage);

            break;

        case AMC_REQUEST_OPERATION_UPDATE:

            handleUpdate(aMessage);

            break;

        default:

            ELOG1(EJavaCaptain, "Unknown AMC operation %d", operation);

            break;

        }

    }

    break;

    default:

        ELOG1(EJavaCaptain, "Unknown message sent to AMC %d", aMessage.getMessageId());

        break;

    }

}

void Amc::handleStart(CommsMessage& aMessage)

{

    JELOG2(EJavaCaptain);

    int numOfUids = 0;

    aMessage >> numOfUids;

    if (numOfUids > 0)

    {

        Uid uid;

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

        {

            aMessage >> uid;

            LOG1WSTR(EJavaCaptain, EInfo, "handleStart() uid = %s", uid.toString());

            mCore->getRtc()->launch(uid);

        }

    }

}

void Amc::handleStop(CommsMessage& aMessage)

{

    JELOG2(EJavaCaptain);

    int numOfUids = 0;

    aMessage >> numOfUids;

    if (numOfUids == 0)

    {

        CommsMessage message;

        message.setReceiver(aMessage.getSender());

        message.setModuleId(aMessage.getModuleId());

        message.setMessageRef(aMessage.getMessageRef());

        setAmcResponseParamaters(message, 0);

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

    }

    else if (numOfUids > 0)

    {

        Uid* uids = new Uid[numOfUids];

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

        {

            aMessage >> uids[i];

            LOG1WSTR(EJavaCaptain, EInfo, "handleStop uid[] = %s", uids[i].toString());

        }

        StopRequest* request = new StopRequest(mCore,

                                               aMessage.getSender(),

                                               aMessage.getModuleId(),

                                               aMessage.getMessageRef(),

                                               numOfUids, &uids[0]);

        // Permission check should be done for STOP_APPLICATION permission.

        // More strict check is used until javainstaller gets required

        // permission in place

        bool allowed = aMessage.hasPermission(LAUNCH_APPLICATION);

        if (allowed)

        {

            if (request->stopUids())

            {

                delete request;

            }

            else

            {

                mStopRequest = request;

            }

        }

        else

        {

            WLOG(EJavaCaptain, "AMC STOP not allowed");

            request->sendStopNotAllowed(numOfUids, &uids[0]);

            delete request;

        }

        delete [] uids;

    }

}

void Amc::handleUpdate(CommsMessage& aMessage)

{

    JELOG2(EJavaCaptain);

    std::wstring uid;

    uids_t beforeUids;

    uids_t afterUids;

    int numOfUids = 0;

    int i = 0;

    aMessage >> numOfUids;

    for (i = 0 ; i < numOfUids ; i++)

    {

        aMessage >> uid;

        beforeUids.insert(Uid(uid));

        LOG2(EJavaCaptain, EInfo, "before uids[%d] = %s", i, std::string(uid.begin(), uid.end()).c_str());

    }

    aMessage >> numOfUids;

    for (i = 0 ; i < numOfUids ; i++)

    {

        aMessage >> uid;

        afterUids.insert(Uid(uid));

        LOG2(EJavaCaptain, EInfo, "after uids[%d] = %s", i, std::string(uid.begin(), uid.end()).c_str());

    }

    LOG1(EJavaCaptain, EInfo, "beforeUids.size() = %d", beforeUids.size());

    LOG1(EJavaCaptain, EInfo, "afterUids.size() = %d", afterUids.size());

    uids_t resultUids;

    // Enable all uids which were disabled at the beginning of the installation

    std::set_union(afterUids.begin(), afterUids.end(),

                   beforeUids.begin(), beforeUids.end(),

                   std::inserter(resultUids, resultUids.end()));

    if (resultUids.size() > 0)

    {

        for (uids_t::const_iterator iter = resultUids.begin();

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

        {

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

        }

        resultUids.clear();

    }

    // Added -- exists only in afterUids collection

    std::set_difference(afterUids.begin(), afterUids.end(),

                        beforeUids.begin(), beforeUids.end(),

                        std::inserter(resultUids, resultUids.end()));

    if (resultUids.size() > 0)

    {

        mAmEventsDispatcher->amAdded(resultUids);

        resultUids.clear();

    }

    // Updated -- exists in both collections

    std::set_intersection(beforeUids.begin(), beforeUids.end(),

                          afterUids.begin(), afterUids.end(),

                          std::inserter(resultUids, resultUids.end()));

    if (resultUids.size() > 0)

    {

        mAmEventsDispatcher->amUpdated(resultUids);

        resultUids.clear();

    }

    // Deleted -- exists only in beforeUids collection

    std::set_difference(beforeUids.begin(), beforeUids.end(),

                        afterUids.begin(), afterUids.end(),

                        std::inserter(resultUids, resultUids.end()));

    if (resultUids.size() > 0)

    {

        mAmEventsDispatcher->amDeleted(resultUids);

        resultUids.clear();

    }

}

} // namespace captain

} // namespace java