/*
* Copyright (c) 2006-2006 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:
*
*/


#include <hal.h>

#include <e32def.h>
#include <e32const.h>

#include "eventserverglobals.h"
#include "CJavaEventServer.h"
#include "com_nokia_mj_impl_rt_legacy_MemoryUtil.h"
#include "com_nokia_mj_impl_rt_legacy_EventProcessor.h"

RArray<TInt>& EventServerHandles(); //Must be consistent with implementation
//in MIDEventServer.cpp in jniutils


const TInt KQueueGranularity = 100; // Define iQueue default granularity
const TInt KCompressThreshold = 100; // Define number of processed events


void InitEventServer()
{
    TRAPD(err, CEventQueue::InitL());
    if (err != KErrNone)
    {
        User::Panic(_L("EventServer::can't initialize event queue"), err);
    }
}

// Cleanup the event server; called from Java event dispatch thread
void CleanupEventServer()
{
    CJavaEventServer::Cleanup(EventServerHandles());
}

// Dispatch event to Java, called from Java event dispatch thread
void RunJavaEventServer(JNIEnv* aJni, TInt aServer)
{
    CJavaEventBase* ev = (CJavaEventBase*) aServer;
    if (aServer != KErrServerTerminated)
    {
        ev->Run(*aJni);
    }
}


JNIEXPORT jlong JNICALL Java_com_nokia_mj_impl_rt_legacy_MemoryUtil__1getFreeRAMInKB(JNIEnv*, jclass)
{
    TInt mem = 0;
    TInt err = HAL::Get(HALData::EMemoryRAMFree, mem);
    if (err == KErrNone)
    {
        return mem / 1024;
    }
    else
    {
        return err;
    }
}

JNIEXPORT void JNICALL Java_com_nokia_mj_impl_rt_legacy_EventProcessor__1dispatchCallbacks(JNIEnv* aJni, jclass /*aClass*/, jint aThread)
{
    TInt eventServer;
    // Loop for event dispatching
    InitEventServer();
    while ((eventServer = CEventQueue::GetQueue(aThread)->GetNext()) != 0)
    {
        RunJavaEventServer(aJni, eventServer);
    }
}

JNIEXPORT void JNICALL Java_com_nokia_mj_impl_rt_legacy_EventProcessor__1exitThreads(JNIEnv*, jclass)
{
    CEventQueue::OnCloseThreads();
}
// class CIntQueue
CIntQueue::CIntQueue() : iQueue(KQueueGranularity), iCompressCounter(0)
{
}

CIntQueue* CIntQueue::NewL()
{
    CIntQueue* self = NewLC();
    CleanupStack::Pop(self);
    return self;
}

CIntQueue* CIntQueue::NewLC()
{
    CIntQueue* self = new(ELeave) CIntQueue();
    CleanupStack::PushL(self);
    self->ConstructL();

    return self;
}

void CIntQueue::ConstructL()
{
    iMutex.CreateLocal();
    iFull.CreateLocal(0);
}

CIntQueue::~CIntQueue()
{
    iMutex.Close();
    iFull.Close();
    iQueue.Close();
}

// Add integer to the end of the queue
void CIntQueue::Enqueue(TInt aValue)
{
    iMutex.Wait();             // enter critical region
    PutItem(aValue);           // put new item to the buffer
    iMutex.Signal();           // leave critical region
    iFull.Signal();            // inform dispatcher about new event
}

// Return integer from the beginning of the queue
TInt CIntQueue::Dequeue()
{
    iFull.Wait();              // decrement count of full slots
    iMutex.Wait();             // enter critical region
    TInt ret = RemoveItem();   // take item from the buffer
    iMutex.Signal();           // leave critical region

    return ret;
}

void CIntQueue::PutItem(TInt aValue)
{
    TInt err = iQueue.Append(aValue); // put new item to the buffer
    __ASSERT_ALWAYS((err == KErrNone), User::Invariant());
}

TInt CIntQueue::RemoveItem()
{
    TInt ret = iQueue[0];      // take item from the buffer
    iQueue.Remove(0);

    iCompressCounter++;
    if (iCompressCounter == KCompressThreshold)
    {
        iQueue.GranularCompress();
        iCompressCounter = 0;
    }

    return ret;
}

TBool CIntQueue::IsEmpty()
{
    return (iQueue.Count() == 0);
}

/* ******************************************** */

CEventQueue* CEventQueue::GetQueue(TInt aThread)
{
    return getEsStaticData()->mLocks[aThread];
}

CEventQueue::CEventQueue()
{
}

void CEventQueue::ConstructL()
{
    iEventQueue = CIntQueue::NewL();
}

CEventQueue::~CEventQueue()
{
    while (!iEventQueue->IsEmpty())
    {
        TInt event = GetNext();
        if (event != KErrServerTerminated)
        {
            CJavaEventBase* ev = reinterpret_cast<CJavaEventBase*>(event);
            CJavaEventSourceBase& source = ev->Object();

            if (ev->IsDisposable())
            {
                delete ev;
            }
            source.OnVmClose();
        }
    }
    delete iEventQueue;
}

// Notify that new event has been posted. Called from the native code.
// aEventServer is C++ pointer to event server object and aThreadNumber indicates the event type
// and therefore which dispatcher thread should handle it

void CEventQueue::NotifyServer(TInt aEventServer, TInt aThreadNumber)
{
    ASSERT(aThreadNumber < KDispatchThreads);

    // Add event server of an event to the queue
    GetQueue(aThreadNumber)->iEventQueue->Enqueue(aEventServer);

}

// Get the next event server from the queue; wait if there are no events to be dispatched
TInt CEventQueue::GetNext()
{
    return iEventQueue->Dequeue();
}

void CEventQueue::OnCloseThreads()
{
    //sends fake zero events to exit from native loop back to java
    for (int i = 0; i < KDispatchThreads; i++)
    {
        GetQueue(i)->NewEvent(0);
    }
}

// Add event server of an event to the queue
void CEventQueue::NewEvent(TInt aEventServer)
{
    iEventQueue->Enqueue(aEventServer);
}


void CEventQueue::Cleanup()
{
    EventServerGlobals* esd = getEsStaticData();
    for (int i = 0; i < KDispatchThreads; i++)
    {
        delete esd->mLocks[i];
        esd->mLocks[i] = 0;
    }
}

void CEventQueue::InitL()
{
    EventServerGlobals* esd = getEsStaticData();
    for (int i = 0; i < KDispatchThreads; i++)
    {
        if (esd->mLocks[i] == 0)
        {
            CEventQueue* self = new(ELeave) CEventQueue();
            CleanupStack::PushL(self);
            self->ConstructL();
            CleanupStack::Pop();
            esd->mLocks[i] = self;
        }
    }
}