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


#include "logger.h"
#include "javacommonutils.h"

#include "commsendpoint.h"
#include "commsclientendpoint.h"
#include "commsmessage.h"

#include "rtcbaseplugin.h"
#include "rtcmessages.h"
#include "coremessages.h"

#include "coreinterface.h"
#include "timerserverinterface.h"
#include "pmcinterface.h"

namespace java
{
namespace captain
{

const int EXIT_TIMER_TIMEOUT    = 5;
const int LAUNCH_TIMER_TIMEOUT  = 5;
const int LAUNCH_TIMER_TIMEOUT_PREWARM  = 60;

RtcBasePlugin::RtcBasePlugin(const Uid& aUID,
                             CoreInterface* aCore)
        :mUID(aUID),
        mCore(aCore),
        mState(APPLICATION_STATE_IDLE_C),
        mRuntimeAddress(0),
        mPid(-1),
        mTimerId(0),
        mPendingOperation(PENDING_OPERATION_NONE_C)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);
}

RtcBasePlugin::~RtcBasePlugin()
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    runtime_init();

    mCore = 0;
}
// Already routed on upper level using pid
void RtcBasePlugin::pmcTerminated(const int& /*aPid*/, const int& /*exitCode*/)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    mPid = -1;
    mRuntimeAddress = 0;

    switchState(APPLICATION_STATE_IDLE_C);
}

// TimerServerEventsInterface methods
void RtcBasePlugin::timerTimeout(const int& aTimerId)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    LOG1WSTR(EJavaCaptain, EError, "RtcBasePlugin::timerTimeout(%s)", mUID.toString());
    LOG1(EJavaCaptain, EInfo, "runtime in state: %s", E2S_state(mState));

    if (aTimerId == mTimerId)
    {
        mTimerId = 0;
        runtime_init();
    }
    else
    {
        ELOG2(EJavaCaptain, "Wrong timerId! ok:%d FAIL:%d", mTimerId, aTimerId);
    }
}

bool RtcBasePlugin::launch(const rtcLaunchInfo& aLaunchInfo)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);
    LOG1WSTR(EJavaCaptain, EInfoHeavyLoad, "RtcBasePlugin::launch(%s)", mUID.toString());
    if (mUID == PREWARM_UID)
    {
        mUID = aLaunchInfo.mUID;
    }
    else if (mUID != aLaunchInfo.mUID)
    {
        ELOG(EJavaCaptain, "launch() called for a wrong instance");
        return false; // not launched
    }

    mRuntimeArguments = aLaunchInfo.mRuntimeArguments;
    mApplicationArguments = aLaunchInfo.mApplicationArguments;

    bool launchSuccess = false;

    switch (mState)
    {
    case APPLICATION_STATE_IDLE_C:
        if (runtime_launch(aLaunchInfo.mLaunchType))
        {
            launchSuccess = true;
            switchState(APPLICATION_STATE_LAUNCHED_C);
        }
        break;

    case APPLICATION_STATE_LAUNCHED_C:
    case APPLICATION_STATE_EXITING_C:
        launchSuccess = true;
        setPendingLaunch(aLaunchInfo.mLaunchType);
        break; // Just be happy

    case APPLICATION_STATE_RUNNING_C:
        launchSuccess = true;
        if (!runtime_relaunch(aLaunchInfo.mLaunchType))   // if fails
        {
            runtime_init(); // ????
            // Launch a new instance
            if (runtime_launch(aLaunchInfo.mLaunchType))
            {
                switchState(APPLICATION_STATE_LAUNCHED_C);
            }
            else
            {
                ELOG(EJavaCaptain, "Application launch failed!");
                runtime_init();
                switchState(APPLICATION_STATE_IDLE_C);
                launchSuccess = false;
            }
        }
        break;

    default:
        ELOG1(EJavaCaptain, "Invalid state -> %s", E2S_state(mState));
        break;
    }

    return launchSuccess;
}

bool RtcBasePlugin::terminate(const rtcTerminateInfo& aTerminateInfo)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);
    LOG1WSTR(EJavaCaptain, EInfoHeavyLoad, "terminate(%s)", mUID.toString());

    if (mUID != aTerminateInfo.mUID)
    {
        ELOG(EJavaCaptain, "terminate() called for a wrong instance");
        return true; // already terminated
    }

    bool isAlreadyTerminated = false;

    switch (mState)
    {
    case APPLICATION_STATE_IDLE_C:
        isAlreadyTerminated = true;
        break;

    case APPLICATION_STATE_LAUNCHED_C:
        setPendingTerminate();
        break;

    case APPLICATION_STATE_RUNNING_C:
        if (runtime_terminate())   // terminate requested
        {
            switchState(APPLICATION_STATE_EXITING_C);
        }
        else // request failed, application probably already dead/zombie
        {
            runtime_init();
            switchState(APPLICATION_STATE_IDLE_C);
            isAlreadyTerminated = true;
        }
        break;

    case APPLICATION_STATE_EXITING_C:
        break;

    default:
        ELOG1(EJavaCaptain, "Illegal state %d", mState);
        break;
    }

    return isAlreadyTerminated;
}

void RtcBasePlugin::switchState(const ApplicationState& newState)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);
    LOG1WSTR(EJavaCaptain, EInfo, "switchState() and mUID is %s", mUID.toString());
    LOG2(EJavaCaptain, EInfo, "switchState %s -> %s", E2S_state(mState), E2S_state(newState));

    mState = newState;

    switch (newState)
    {
    case  APPLICATION_STATE_IDLE_C:
        stopTimer();
        if (mPid > 0 && mCore)
        {
            mCore->getPmc()->kill(mPid);
        }
        handlePendingOperations();
        break;

    case APPLICATION_STATE_LAUNCHED_C:
        if (mUID == PREWARM_UID)
        {
            startTimer(LAUNCH_TIMER_TIMEOUT_PREWARM);
        }
        else
        {
            startTimer(LAUNCH_TIMER_TIMEOUT);
        }
        break;

    case APPLICATION_STATE_RUNNING_C:
        stopTimer();
        handlePendingOperations();
        break;

    case APPLICATION_STATE_EXITING_C:
        startTimer(EXIT_TIMER_TIMEOUT);
        break;

    default:
        ELOG1(EJavaCaptain, "Invalid new state requested %s", E2S_state(newState));
        break;
    }
}

void RtcBasePlugin::runningInd(const int& aRuntimeAddress, const int& /*aStatus*/)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    // Assumes that sender address is always latest and valid.
    mRuntimeAddress = aRuntimeAddress;

    switch (mState)
    {
        // Only handled once after launch othervise igoned
    case APPLICATION_STATE_LAUNCHED_C:
        switchState(APPLICATION_STATE_RUNNING_C);
        break;

        // Waking up a little bit too late, give another chance to do the right thing
    case APPLICATION_STATE_EXITING_C:
        runtime_terminate();
        startTimer(EXIT_TIMER_TIMEOUT);
        break;

    default:
        break;
    }
}

void RtcBasePlugin::terminatedInd(const int& /*aStatus*/)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    // Only handled if not already in EXITING state,
    // othervise ignored and deemed as an extra terminated_ind
    if (mState != APPLICATION_STATE_EXITING_C)
    {
        switchState(APPLICATION_STATE_EXITING_C);
    }
}

void RtcBasePlugin::processMessage(CommsMessage& message)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    switch (message.getMessageId())
    {
    case CORE_MSG_ID_DO_THREAD_DUMP:
        LOG(EJavaCaptain, EInfo, "sending DO_THREAD_DUMP message to runtime");
        sendMessageToRuntime(message.getModuleId(), message);
        break;

    case RTC_MSG_ID_GET_EXTRA_ARGUMENTS:
        if (message.getSender() == mRuntimeAddress && isRunning())
        {
            CommsMessage reply;
            reply.replyTo(message);
            setGetExtraArgumentsAck(reply, mRuntimeArguments, mApplicationArguments);
            LOG2(EJavaCaptain, EInfo, "reply to get runtime attributes: mUid=%S mRuntimeArguments=%S",
                 mUID.toString().c_str(), mRuntimeArguments.c_str());
            sendMessageToRuntime(message.getModuleId(), reply);
        }
        break;

    default:
        ELOG1(EJavaCaptain, "Unknown message forwarded to rtcplugin %d", message.getMessageId());
        break;
    }
}

int RtcBasePlugin::sendMessageToRuntime(const int& moduleId, CommsMessage& message)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    message.setReceiver(mRuntimeAddress);
    message.setModuleId(moduleId);

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

bool RtcBasePlugin::isRunning() const
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return mState == APPLICATION_STATE_RUNNING_C;
}

void RtcBasePlugin::runtime_init()
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    if (mPid > 0 && mCore)
    {
        LOG1(EJavaCaptain, EInfo, "Killing process with uid %S",
             mUID.toString().c_str());
        mCore->getPmc()->kill(mPid);
    }
}

bool RtcBasePlugin::runtime_launch(const int& aLaunchType)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    std::vector<std::string> params;
    mPid = mCore->getPmc()->launch(generateCommandLine(aLaunchType, params), 0);
    return mPid > 0;
}

bool RtcBasePlugin::runtime_relaunch(const int& aLaunchType)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    int status = 0;
    CommsMessage msg;

    switch (aLaunchType)
    {
    case RTC_LAUNCH_TYPE_PUSH_C:
        setUpdatePushReqParams(msg, mUID);
        status = sendMessageToRuntime(PLUGIN_ID_RTC_PUSH_C, msg);
        LOG1(EJavaCaptain, EInfo, "sendUpdatePushMessageToRuntime() returns %d", status);
        break;

    case RTC_LAUNCH_TYPE_PREWARM_C: // do nothing
        break;

    default:
        setLaunchApplicationReqParams(msg, mUID, aLaunchType,
                                      RTC_LAUNCH_OPTIONS_NONE_C, RTC_LAUNCH_RUNTIME_MIDP_C, mApplicationArguments);
        status = sendMessageToRuntime(PLUGIN_ID_RTC_C, msg);
        LOG1(EJavaCaptain, EInfo,
             "RtcBasePlugin::runtime_relaunch: sendMessageToRuntime() returns %d", status);
        break;
    }

    return status == 0;
}

bool RtcBasePlugin::runtime_terminate()
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    CommsMessage terminateMsg;
    setTerminateApplicationReqParams(terminateMsg, mUID, 0);
    int status = sendMessageToRuntime(PLUGIN_ID_RTC_C, terminateMsg);
    LOG1(EJavaCaptain, EInfo, "sendMessageToRuntime() returns %d", status);
    return status == 0;
}

void RtcBasePlugin::startTimer(const int& aTimeout)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    // Only cancel if already started
    if (0 != mTimerId)
    {
        mCore->getTimerServer()->timerCancel(mTimerId);
        mTimerId = 0;
    }
    mTimerId = mCore->getTimerServer()->timerCreateSeconds(aTimeout, this);
}
void RtcBasePlugin::stopTimer()
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    if (0 != mTimerId)
    {
        mCore->getTimerServer()->timerCancel(mTimerId);
        mTimerId = 0;
    }
}

void RtcBasePlugin::setPendingLaunch(const int& aType)
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);
    switch (aType)
    {
    case RTC_LAUNCH_TYPE_NORMAL_C:
        mPendingOperation = PENDING_OPERATION_LAUNCH_NORMAL_C;
        break;

    case RTC_LAUNCH_TYPE_PUSH_C:
        mPendingOperation = PENDING_OPERATION_LAUNCH_PUSH_C;
        break;

    case RTC_LAUNCH_TYPE_AUTO_INVOCATION_C:
        mPendingOperation = PENDING_OPERATION_LAUNCH_AUTO_INVOCATION_C;
        break;

    case RTC_LAUNCH_TYPE_BACKGROUND_C:
        mPendingOperation = PENDING_OPERATION_LAUNCH_BACKGROUND_C;
        break;

    case RTC_LAUNCH_TYPE_DEBUG_C:
        mPendingOperation = PENDING_OPERATION_LAUNCH_DEBUG_C;
        break;

    default:
        ELOG1(EJavaCaptain, "Unknown pending launch type! (%d)", aType);
        mPendingOperation = PENDING_OPERATION_NONE_C;
        break;
    }
}

void RtcBasePlugin::setPendingTerminate()
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);
    mPendingOperation = PENDING_OPERATION_TERMINATE_C;
}

void RtcBasePlugin::handlePendingOperations()
{
    JELOG4(EJavaCaptain, EInfoHeavyLoad);
    switch (mPendingOperation)
    {
    case PENDING_OPERATION_LAUNCH_NORMAL_C:
        mPendingOperation = PENDING_OPERATION_NONE_C;
        launch(rtcLaunchInfo(mUID, RTC_LAUNCH_TYPE_NORMAL_C));
        break;
    case PENDING_OPERATION_LAUNCH_PUSH_C:
        mPendingOperation = PENDING_OPERATION_NONE_C;
        launch(rtcLaunchInfo(mUID, RTC_LAUNCH_TYPE_PUSH_C));
        break;
    case PENDING_OPERATION_LAUNCH_AUTO_INVOCATION_C:
        mPendingOperation = PENDING_OPERATION_NONE_C;
        launch(rtcLaunchInfo(mUID, RTC_LAUNCH_TYPE_AUTO_INVOCATION_C));
        break;
    case PENDING_OPERATION_LAUNCH_BACKGROUND_C:
        mPendingOperation = PENDING_OPERATION_NONE_C;
        launch(rtcLaunchInfo(mUID, RTC_LAUNCH_TYPE_BACKGROUND_C));
        break;
    case PENDING_OPERATION_LAUNCH_DEBUG_C:
        mPendingOperation = PENDING_OPERATION_NONE_C;
        launch(rtcLaunchInfo(mUID, RTC_LAUNCH_TYPE_DEBUG_C));
        break;
    case PENDING_OPERATION_TERMINATE_C:
        mPendingOperation = PENDING_OPERATION_NONE_C;
        terminate(rtcTerminateInfo(mUID));
        break;
    case PENDING_OPERATION_NONE_C:
    default:
        mPendingOperation = PENDING_OPERATION_NONE_C;
        break;
    }
}

} // namespace captain
} // namespace java