/*
* 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:  ExtensionPluginTester
*
*/

#include <unistd.h>

#include "comms.h"
#include "commsendpoint.h"
#include "commsmessage.h"
#include "logger.h"

#include "rtcinterface.h"
#include "pmcinterface.h"
#include "coreinterface.h"

#include "testmessages.h"
#include "testuids.h"

#include "extensionplugintester.h"

#ifdef __SYMBIAN32__
java::captain::ExtensionPluginInterface* getExtensionPlugin()
{
#else
extern "C" java::captain::ExtensionPluginInterface* getExtensionPlugin()
{
#endif
    return new java::captain::ExtensionPluginTester();
}

using namespace java::util;

namespace java
{
namespace captain
{

ExtensionPluginTester::ExtensionPluginTester()
        :mCore(0), mPush1Installed(false), mEventTimerId(0)
{
    JELOG2(EJavaCaptain);
}

ExtensionPluginTester::~ExtensionPluginTester()
{
    JELOG2(EJavaCaptain);
    mTimeoutRequesters.clear();
}

void ExtensionPluginTester::startPlugin(CoreInterface* core)
{
    JELOG2(EJavaCaptain);
    core->getComms()->registerListener(java::comms::PLUGIN_ID_JAVACAPTAIN_TESTER_C, this);
    mCore = core;
//    mEventTimerId = mCore->getTimerServer()->timerCreateSeconds(1, this);
}

void ExtensionPluginTester::stopPlugin()
{
    JELOG2(EJavaCaptain);
    mCore->getComms()->unregisterListener(java::comms::PLUGIN_ID_JAVACAPTAIN_TESTER_C, this);
    mCore->getTimerServer()->timerCancel(mEventTimerId);
    mCore = 0;
}

EventConsumerInterface* ExtensionPluginTester::getEventConsumer()
{
    JELOG2(EJavaCaptain);
    return this;
}

void ExtensionPluginTester::timerTimeout(const int& aTimerId)
{
    JELOG2(EJavaCaptain);
    LOG1(EJavaCaptain, EInfo, "timerTimeout(0x%x)", aTimerId);
    if (aTimerId == mEventTimerId)
    {
        CommsMessage msg;
        mCore->getEventDispatcher()->event("ExtensionPluginTester", msg);
    }
    else
    {
        timeoutRequesters::iterator iter = mTimeoutRequesters.find(aTimerId);
        if (iter != mTimeoutRequesters.end())
        {
            CommsMessage msg;
            setTimeoutParameters(msg, aTimerId);
            msg.setReceiver(iter->second);
            int rc = mCore->getComms()->send(msg);
            LOG1(EJavaCaptain, EInfo, "send(timeout_msg) returns %d", rc);
            mTimeoutRequesters.erase(iter);
        }
    }

    return;
}

void ExtensionPluginTester::event(const std::string& eventProvider,
                                  java::comms::CommsMessage& /*aMsg*/)
{
    JELOG2(EJavaCaptain);
    LOG1(EJavaCaptain, EInfo, "ExtensionPluginTester::event() from %s", eventProvider.c_str());
    if (eventProvider == "ExtensionPluginTester")
    {
        mEventTimerId = mCore->getTimerServer()->timerCreateSeconds(1, this);
    }
}

ApplicationManagementEventsInterface* ExtensionPluginTester::getApplicationManagementListener()
{
    JELOG2(EJavaCaptain);
    return this;
}

void ExtensionPluginTester::amAdded(const uids_t& uids)
{
    JELOG2(EJavaCaptain);
    uids_t::const_iterator iter = uids.begin();
    while (iter != uids.end())
    {
        if ((*iter) == uid_push1)
        {
            mPush1Installed = true;
            mCore->getRtc()->launch(rtcLaunchInfo(uid_push1, RTC_LAUNCH_TYPE_PUSH_C, "test1"));
        }

        LOG1WSTR(EJavaCaptain, EInfo, "amAdded(%s)", iter->toString());
        iter++;
    }
}

void ExtensionPluginTester::amUpdated(const uids_t& uids)
{
    JELOG2(EJavaCaptain);
    uids_t::const_iterator iter = uids.begin();
    while (iter != uids.end())
    {
        if ((*iter) == uid_push1)
        {
            mCore->getRtc()->launch(rtcLaunchInfo(uid_push1, RTC_LAUNCH_TYPE_PUSH_C, "test1"));
        }

        LOG1WSTR(EJavaCaptain, EInfo, "amUpdated(%s)", iter->toString());
        iter++;
    }
}

void ExtensionPluginTester::amDeleted(const uids_t& uids)
{
    JELOG2(EJavaCaptain);
    uids_t::const_iterator iter = uids.begin();
    while (iter != uids.end())
    {
        if ((*iter) == uid_push1)
        {
            mPush1Installed = false;
            mCore->getRtc()->terminate(rtcTerminateInfo(uid_push1));
        }

        LOG1WSTR(EJavaCaptain, EInfo, "amDeleted(%s)", iter->toString());
        iter++;
    }
}

ApplicationRuntimeEventsInterface* ExtensionPluginTester::getApplicationRuntimeListener()
{
    JELOG2(EJavaCaptain);
    return this;
}

void ExtensionPluginTester::arLaunched(const Uid& /*aUID*/, const int& /*aRuntimeCommsAddress*/)
{
    JELOG2(EJavaCaptain);
}

void ExtensionPluginTester::arTerminated(const Uid& aUID, const int& /*aExitCode*/)
{
    JELOG2(EJavaCaptain);

    if (aUID == uid_push1 && mPush1Installed)
    {
        mCore->getRtc()->launch(rtcLaunchInfo(uid_push1, RTC_LAUNCH_TYPE_PUSH_C, "test1"));
    }
}

java::comms::CommsListener* ExtensionPluginTester::getCommsListener()
{
    JELOG2(EJavaCaptain);
    return this;
}

void ExtensionPluginTester::processMessage(CommsMessage& message)
{
    JELOG2(EJavaCaptain);

    int statusInt = 0;
    CommsMessage reply;
    reply.setModuleId(message.getModuleId());
    reply.setReceiver(message.getSender());
    reply.setMessageRef(message.getMessageRef());

    switch (message.getMessageId())
    {
    case IPC_MESSAGE_TEST_EXTENSIONPLUGIN_LOAD_REQ:
    {
        std::string pluginName;
        getLoadExtensionPluginReqParameters(message, pluginName);
        ExtensionPluginInterface* interface = mCore->loadExtensionPlugin(pluginName);
        statusInt = interface ? 0 : 1;
    }
    break;

    case IPC_MESSAGE_TEST_EXTENSIONPLUGIN_UNLOAD_REQ:
    {
        std::string pluginName;
        getUnloadExtensionPluginReqParameters(message, pluginName);
        mCore->unloadExtensionPlugin(pluginName);
    }
    break;

    case IPC_MESSAGE_TEST_LAUNCH_APP_REQ:
    {
        Uid uidi;
        int type = RTC_LAUNCH_TYPE_NORMAL_C;
        std::string rtc = "midp";
        getLaunchAppParameters(message, uidi, type, rtc);
        statusInt = (mCore->getRtc()->launch(rtcLaunchInfo(uidi, type, rtc)) ? 0 : 1);
    }
    break;

    case IPC_MESSAGE_TEST_TERMINATE_APP_REQ:
    {
        Uid uidi;
        getTerminateAppParameters(message, uidi);
        statusInt = (mCore->getRtc()->terminate(rtcTerminateInfo(uidi)) ? 0 : 1);
    }
    break;

    case IPC_MESSAGE_TEST_ENABLE_APP_REQ:
    {
        Uid uidi;
        getEnableAppParameters(message, uidi);
        mCore->getRtc()->enable(uidi);
    }
    break;

    case IPC_MESSAGE_TEST_DISABLE_APP_REQ:
    {
        Uid uidi;
        getDisableAppParameters(message, uidi);
        mCore->getRtc()->disable(uidi);
    }
    break;

    case IPC_MESSAGE_TEST_PROCESS_START:
    {
        std::string exe, params;
        getProcessStartParameters(message, exe, params);
        cmdLine_t cmdLine;
        cmdLine.push_back(exe);
        cmdLine.push_back(params);
        statusInt = mCore->getPmc()->launch(cmdLine, 0);
    }
    break;

    case IPC_MESSAGE_TEST_PROCESS_KILL:
    {
        int pidi = 0;
        getProcessKillParameters(message, pidi);
        statusInt = mCore->getPmc()->kill(pidi);
    }
    break;

    case IPC_MESSAGE_TEST_PROCESS_TERMINATE:
    {
        int pidi = 0;
        getProcessTerminateParameters(message, pidi);
        statusInt = mCore->getPmc()->terminate(pidi);
    }
    break;

    case IPC_MESSAGE_TEST_START_SECONDS_TIMER:
    {
        int timeout;
        getTimerStartSecondsParameters(message, timeout);
        int timerId = mCore->getTimerServer()->timerCreateSeconds(timeout, this);
        mTimeoutRequesters.insert(std::make_pair(timerId, message.getSender()));
        LOG2(EJavaCaptain, EInfo, "timerCreateSeconds(%d) returns %#x", timeout, timerId);
        setTimerAckParameters(reply, timerId);
        mCore->getComms()->send(reply);
    }
    return;

    case IPC_MESSAGE_TEST_START_JAVATIME_TIMER:
    {
        long long timeout;
        getTimerStartJavaTimeParameters(message, timeout);
        int timerId = mCore->getTimerServer()->timerCreateJavaTime(JavaTime(timeout), this);
        mTimeoutRequesters.insert(std::make_pair(timerId, message.getSender()));
        LOG2(EJavaCaptain, EInfo, "timerCreateJavaTime(%u) returns %#x", timeout, timerId);
        setTimerAckParameters(reply, timerId);
        mCore->getComms()->send(reply);
    }
    return;

    case IPC_MESSAGE_TEST_STOP_TIMER:
    {
        int timerId;
        getTimerStopParameters(message, timerId);
        mCore->getTimerServer()->timerCancel(timerId);
        timeoutRequesters::iterator iter = mTimeoutRequesters.find(timerId);
        if (iter != mTimeoutRequesters.end())
        {
            mTimeoutRequesters.erase(iter);
        }
        LOG1(EJavaCaptain, EInfo, "timerCancel(%#x) called", timerId);
        setTimerAckParameters(reply, timerId);
        mCore->getComms()->send(reply);
    }
    return;
    }

    setAckParameters(reply, statusInt);
    mCore->getComms()->send(reply);
}

} // namespace captain
} // namespace java