/*

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

*

*/

#include <string>

#include <iostream>

#include <algorithm>

#ifdef __SYMBIAN32__

#include "e32std.h"

#else

#include <sys/types.h>

#include <sys/wait.h>

#include "signalhandlermessages.h"

#endif /* __SYMBIAN32__ */

#include "logger.h"

#include "comms.h"

#include "commsmessage.h"

#include "libraryloaderexception.h"

#include "javacommonutils.h"

#include "monitor.h"

#include "core.h"

#include "coremessages.h"

#include "extensionplugininterface.h"

#include "extensionplugindata.h"

#include "booteventprovider.h"

#include "mmceventprovider.h"

#include "timerdata.h"

#include "tickerprovider.h"

using namespace java::comms;

namespace java

{

namespace captain

{

//using java::util::ScopedLock;

Core::Core(java::util::Monitor* aMonitor)

        :mTicker(NULL),

        mMonitor(aMonitor)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

}

Core::~Core()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    mMonitor = 0;

    mTicker = 0;

}

bool Core::start()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    registerDefaultListener(this);

    CommsServerEndpoint::start(IPC_ADDRESS_JAVA_CAPTAIN_C);

    return true;

}

int Core::stop()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    unregisterDefaultListener(this);

    return CommsServerEndpoint::stop();

}

void Core::onStart()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    mTicker = new TickerProvider(this);

    mPmc.start(this, this);

    mAmc.start(this, this);

    mRtc.start(this, this);

    loadConfigExtensionPlugin();

}

void Core::onExit()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    unloadExtensionPlugins();

    mRtc.stop();

    mAmc.stop();

    mPmc.stop();

    delete mTicker;

    for (timersIterator iter = mTimers.begin() ; iter != mTimers.end() ; ++iter)

    {

        delete(*iter);

    }

    mTimers.clear();

    mMonitor->notify();

}

RtcInterface* Core::getRtc()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return &mRtc;

}

PmcInterface* Core::getPmc()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return &mPmc;

}

AmcInterface* Core::getAmc()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return &mAmc;

}

TimerServerInterface* Core::getTimerServer()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return this;

}

CommsEndpoint* Core::getComms()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return this;

}

ExtensionPluginInterface* Core::loadExtensionPlugin(const std::string& aPluginName)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    LOG1(EJavaCaptain, EInfo, "Core::loadExtensionPlugin(%s)", aPluginName.c_str());

    extensionPluginsIterator iter = mExtensionPlugins.begin();

    for (; iter != mExtensionPlugins.end() ; ++iter)

    {

        if ((*iter)->getName() == aPluginName)

        {

            break;

        }

    }

    if (iter != mExtensionPlugins.end())

    {

        (*iter)->addLoadCount();

        return (*iter)->mExtensionPlugin;

    }

    ExtensionPluginInterface* interface = NULL;

    if (aPluginName == "boot")

    {

        interface = new BootEventProvider();

        mExtensionPlugins.push_back(new ExtensionPluginData(interface, aPluginName));

        // needs to be pushed in to the collection before starting due to dependencies

        interface->startPlugin(this);

    }

    else if (aPluginName == "mmc")

    {

        interface = new MmcEventProvider();

        mExtensionPlugins.push_back(new ExtensionPluginData(interface, aPluginName));

        // needs to be pushed in to the collection before starting due to dependencies

        interface->startPlugin(this);

    }

    else

    {

        try

        {

            std::string libraryName = "javacaptain_ext_" +  aPluginName;

            std::auto_ptr<java::util::DynamicLibLoader>

            loader(new java::util::DynamicLibLoader(libraryName.c_str()));

            java::captain::ExtensionPluginInterface*(*GetExtensionPluginFunc)() =

                (java::captain::ExtensionPluginInterface*(*)())

                loader->getFunction("getExtensionPlugin");

            if (GetExtensionPluginFunc)

            {

                interface = GetExtensionPluginFunc();

                mExtensionPlugins.push_back(new ExtensionPluginDataDynamic(interface, loader, aPluginName));

                // needs to be pushed in to the collection before starting due to dependencies

                interface->startPlugin(this);

            }

        }

        catch (java::util::LibraryLoaderException& ex)

        {

            ELOG2(EJavaCaptain, "Core::loadExtensionPlugin(%s) failed due: %s",

                  aPluginName.c_str(), ex.toString().c_str());

        }

    }

    return interface;

}

void Core::unloadExtensionPlugin(const std::string& aPluginName)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    LOG1(EJavaCaptain, EInfo, "Core::unloadExtensionPlugin(%s)", aPluginName.c_str());

    extensionPluginsIterator iter = mExtensionPlugins.begin();

    for (; iter != mExtensionPlugins.end() ; ++iter)

    {

        if ((*iter)->getName() == aPluginName)

        {

            break;

        }

    }

    if (iter != mExtensionPlugins.end())

    {

        if (0 == (*iter)->decLoadCount())

        {

            // Stopped via destructor while still in the collection

            delete(*iter);

            mExtensionPlugins.erase(iter);

        }

    }

}

EventConsumerInterface* Core::getEventDispatcher()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return this;

}

// TimerServerInterface methods

int Core::timerCreateSeconds(const unsigned int& aTimeoutInSeconds,

                             TimerServerEventsInterface* aTimerEvents)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    int timerId = timerCreateJavaTime(JavaTime(mTicker->getCurrentJavaTime() +

                                      aTimeoutInSeconds * 1000LL),

                                      aTimerEvents);

    LOG2(EJavaCaptain, EInfoHeavyLoad, "timerCreateSeconds(%d) -> timerId %d",

         aTimeoutInSeconds, timerId);

    return timerId;

}

bool compareTimerDatas(TimerData*& a, TimerData*& b)

{

    return a->getTimeout().getTime() < b->getTimeout().getTime();

}

int Core::timerCreateJavaTime(const JavaTime& aJavaTime,

                              TimerServerEventsInterface* aTimerEvents)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    TimerData* td = new TimerData(aJavaTime, aTimerEvents);

    mTimers.push_back(td);

    mTimers.sort(compareTimerDatas);

    triggerTicker();

    LOG1(EJavaCaptain, EInfo, "timerCreateJavaTime(%#x)", td);

    return (int)td;

}

void Core::timerCancel(const int& aTimerId)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    LOG1(EJavaCaptain, EInfo, "timerCancel(%#x)", aTimerId);

    for (timersIterator iter = mTimers.begin() ;

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

    {

        if ((int)(*iter) == aTimerId)

        {

            delete(*iter);

            mTimers.erase(iter);

            break;

        }

    }

    triggerTicker();

}

JavaTime& Core::getCurrentJavaTime(JavaTime& aJt) const

{

    aJt.setTime(mTicker->getCurrentJavaTime());

    return aJt;

}

bool Core::hasExpired(const JavaTime& aJt, const long long& aAccuracyInMs) const

{

    JavaTime currentTime;

    // Within aAccuracyTime is considered expired to due OS limitations

    return isMore(getCurrentJavaTime(currentTime) + aAccuracyInMs, aJt);

}

bool Core::isLess(const JavaTime& a, const JavaTime& b) const

{

    return a.getTime() < b.getTime();

}

bool Core::isEqual(const JavaTime& a, const JavaTime& b) const

{

    return a.getTime() == b.getTime();

}

bool Core::isMore(const JavaTime& a, const JavaTime& b) const

{

    return !isLess(a, b);

}

void Core::triggerTicker()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    if (mTimers.size() > 0)

    {

        long long nextTickAt = mTicker->getNextTickAt();

        if (!nextTickAt || isMore(JavaTime(nextTickAt), (*mTimers.begin())->getTimeout()))

        {

            mTicker->nextTickAt((*mTimers.begin())->getTimeout().getTime());

        }

    }

    else

    {

        mTicker->cancel();

    }

}

// TickerEventsInterface methods

void Core::tick()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    JavaTime currentTime = JavaTime(mTicker->getCurrentJavaTime());

    for (timersIterator iter = mTimers.begin() ;

            iter != mTimers.end() ; /*iter++*/)

    {

        if (hasExpired((*iter)->getTimeout()))

        {

            (*iter)->timeoutReached();

            delete(*iter);

            iter = mTimers.erase(iter);

        }

        else

        {

            ++iter;

        }

    }

    triggerTicker();

}

// Helper macro, a template would be better but I prefer macros for 'clarity'

#define DISTR_EVENTS(A, B) \

    for(extensionPluginsIterator iter = mExtensionPlugins.begin(); \

        iter != mExtensionPlugins.end(); ++iter) { \

        A##EventsInterface* listener = \

        (*iter)->mExtensionPlugin->get##A##Listener(); \

        if(listener) listener->B; }

// ApplicationRuntimeEventsInterface methods

void Core::arLaunched(const Uid& aUID, const int& aRuntimeCommsAddress)

{

    mAmc.arLaunched(aUID, aRuntimeCommsAddress);

    DISTR_EVENTS(ApplicationRuntime, arLaunched(aUID, aRuntimeCommsAddress))

}

void Core::arTerminated(const Uid& aUID, const int& aExitCode)

{

    mAmc.arTerminated(aUID, aExitCode);

    DISTR_EVENTS(ApplicationRuntime, arTerminated(aUID, aExitCode))

}

// ApplicationManagementEventsInterface methods

void Core::amAdded(const uids_t& aUIDs)

{

    mRtc.amAdded(aUIDs);

    LOG1(EJavaCaptain, EInfo, "amAdded event dispatcher %d uids", aUIDs.size());

    DISTR_EVENTS(ApplicationManagement, amAdded(aUIDs))

}

void Core::amUpdated(const uids_t& aUIDs)

{

    mRtc.amUpdated(aUIDs);

    LOG1(EJavaCaptain, EInfo, "amUpdated event dispatcher %d uids", aUIDs.size());

    DISTR_EVENTS(ApplicationManagement, amUpdated(aUIDs))

}

void Core::amDeleted(const uids_t& aUIDs)

{

    mRtc.amDeleted(aUIDs);

    LOG1(EJavaCaptain, EInfo, "amDeleted event dispatcher %d uids", aUIDs.size());

    DISTR_EVENTS(ApplicationManagement, amDeleted(aUIDs))

}

// ProcessManagementEventsInterface methods

void Core::pmcTerminated(const int& pid, const int& exitCode)

{

    LOG2(EJavaCaptain, EInfo, "pmcTerminated event dispatcher pid=%d, exitCode=%d", pid, exitCode);

    mRtc.pmcTerminated(pid, exitCode);

    DISTR_EVENTS(ProcessManagement, pmcTerminated(pid, exitCode))

}

// EventConsumerInterface methods

void Core::event(const std::string& eventProvider,

                 java::comms::CommsMessage& aMsg)

{

    for (extensionPluginsIterator iter = mExtensionPlugins.begin();

            iter != mExtensionPlugins.end();

            ++iter)

    {

        EventConsumerInterface* consumer = (*iter)->mExtensionPlugin->getEventConsumer();

        if (consumer)

        {

            consumer->event(eventProvider, aMsg);

            aMsg.begin();

        }

    }

    // Rtc needs to listen boot events because of prewarm

    mRtc.event(eventProvider, aMsg);

    aMsg.begin();

}

// Default messsage handler, means that the receiver module was not loaded yet

void Core::processMessage(CommsMessage& aMessage)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    switch (aMessage.getModuleId())

    {

    case PLUGIN_ID_JAVACAPTAIN_CORE_C:

        switch (aMessage.getMessageId())

        {

        case CORE_MSG_ID_STOP_JAVACAPTAIN:

            if (aMessage.hasPermission(STOP_APPLICATION))

            {

                WLOG(EJavaCaptain, "STOP message received");

                mRtc.terminateRtcRuntimes();

                mMonitor->notify();

            }

            break;

        case CORE_MSG_ID_DO_THREAD_DUMP:

            if (aMessage.hasPermission(LAUNCH_APPLICATION))

            {

                LOG(EJavaCaptain, EInfo, "DO_THREAD_DUMP message reveived");

                mRtc.routeMessageToAll(aMessage);

            }

            break;

        case CORE_MSG_ID_START_PREWARM:

            if (aMessage.hasPermission(LAUNCH_APPLICATION))

            {

                WLOG(EJavaCaptain, "START prewarm message received");

                mRtc.launchPrewarm();

            }

            break;

        case CORE_MSG_ID_STOP_PREWARM:

            if (aMessage.hasPermission(STOP_APPLICATION))

            {

                WLOG(EJavaCaptain, "STOP prewarm message received");

                mRtc.stopPrewarm();

            }

            break;

        default:

            break;

        }

        break;

#ifndef __SYMBIAN32__

    case PLUGIN_ID_SIGNAL_C:

        LOG(EJavaCaptain, EInfo, "SIGNAL message received");

        switch (aMessage.getMessageId())

        {

        case SIG_MSG_ID_SIGCHLD:

        {

            int pid = 0;

            int status = 0;

            getSignalChildMessage(aMessage, pid, status);

            pmcTerminated(pid, status);

        }

        break;

        case SIG_MSG_ID_SIGALRM:

            tick();

            break;

        case SIG_MSG_ID_SIGINT:

            LOG(EJavaCaptain, EInfo, "STOP (SIGINT)message received");

            mRtc.terminateRtcRuntimes();

            mMonitor->notify();

            break;

        }

        break;

#endif /* __SYMBIAN32__ */

    default:

    {

        std::string extensionPluginName = "ondemand_" + java::util::JavaCommonUtils::intToString(aMessage.getModuleId());

        ExtensionPluginInterface* interface = loadExtensionPlugin(extensionPluginName.c_str());

        if (interface)

        {

            java::comms::CommsListener* commsListener =  interface->getCommsListener();

            if (commsListener)

            {

                commsListener->processMessage(aMessage);

            }

        }

        else

        {

            WLOG1(EJavaCaptain, "JavaCaptain::ProcessMessage, sender    = %d\n", aMessage.getSender());

            WLOG1(EJavaCaptain, "JavaCaptain::ProcessMessage, messageId = %d\n", aMessage.getMessageId());

            WLOG1(EJavaCaptain, "JavaCaptain::ProcessMessage, moduleId  = %d\n", aMessage.getModuleId());

        }

    }

    }

}