#pragma once

#include "common/RhoStd.h"
#include "logging/RhoLog.h"
#include "rhodes/JNIRhodes.h"
#include "MethodExecutorJni.h"
#include "MethodResultJni.h"


namespace rho {

using rho::apiGenerator::MethodResultJni;
using rho::apiGenerator::MethodExecutorJni;

class CNotificationBase : public MethodExecutorJni
{
protected:
    DEFINE_LOGCLASS;

    static const char* const FACTORY_SINGLETON_CLASS;
    static jclass s_clsFactorySingleton;
    static jmethodID s_midFactorySetInstance;
    static jmethodID s_midFactoryGetInstance;

    //INotificationFactory staff
    static const char* const IFACTORY_CLASS;
    static jclass s_clsIFactory;
    static jmethodID s_midGetApiSingleton;
    static jmethodID s_midGetApiObject;

    //NotificationSingletonBase staff
    static const char* const SINGLETON_BASE_CLASS;
    static jclass s_clsSingletonBase;

    //NotificationBase staff
    static const char* const OBJECT_BASE_CLASS;
    static jclass s_clsObjectBase;

    //Method tasks

    static const char* const SHOWPOPUP_TASK_CLASS;
    static jclass s_clsshowPopupTask;
    static jmethodID s_midshowPopupTask;
    static const char* const HIDEPOPUP_TASK_CLASS;
    static jclass s_clshidePopupTask;
    static jmethodID s_midhidePopupTask;
    static const char* const SHOWSTATUS_TASK_CLASS;
    static jclass s_clsshowStatusTask;
    static jmethodID s_midshowStatusTask;
    static const char* const PLAYFILE_TASK_CLASS;
    static jclass s_clsplayFileTask;
    static jmethodID s_midplayFileTask;
    static const char* const BEEP_TASK_CLASS;
    static jclass s_clsbeepTask;
    static jmethodID s_midbeepTask;
    static const char* const VIBRATE_TASK_CLASS;
    static jclass s_clsvibrateTask;
    static jmethodID s_midvibrateTask;


    static JNIEnv* jniInit(JNIEnv* env);
    static JNIEnv* jniInit();

    static jobject getFactory(JNIEnv* env);
    static jobject getSingleton(JNIEnv* env);

    rho::String m_id;
    jobject getObject(JNIEnv* env);
public:
    static void setJavaFactory(JNIEnv* env, jobject jFactory);


    CNotificationBase(const rho::String& id)
        : MethodExecutorJni(), m_id(id)
        {}
    virtual ~CNotificationBase() {}
};

template <typename T>
class CNotificationProxy : public CNotificationBase
{
public:
    CNotificationProxy(const rho::String& id)
        : CNotificationBase(id)
        {}
    virtual ~CNotificationProxy() {}

    static
    void showPopup(const T& argsAdapter, MethodResultJni& result)
    {
        LOG(TRACE) + "showPopup";

        JNIEnv *env = jniInit();
        if (!env) {
            LOG(FATAL) + "JNI initialization failed";
            return;
        }

        jhobject jhObject = 
            getSingleton(env); 

        if(argsAdapter.size() <= 0)
        {
            LOG(ERROR) + "Wrong number of arguments: 'propertyMap' must be set ^^^";
            result.setArgError("Wrong number of arguments: 'propertyMap' must be set");
            return;
        }
        jholder< jobject > jhpropertyMap = 
            rho_cast< jobject >(env, argsAdapter[0]);

        jhobject jhTask = env->NewObject(s_clsshowPopupTask, s_midshowPopupTask,
                    jhObject.get(), 
                    jhpropertyMap.get(),
                    static_cast<jobject>(result));

        run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD);
        if(env->ExceptionCheck() == JNI_TRUE)
        {
            rho::String message = rho::common::clearException(env);
            LOG(ERROR) + message;
            result.setError(message);
        }
    }

    static
    void hidePopup(const T& argsAdapter, MethodResultJni& result)
    {
        LOG(TRACE) + "hidePopup";

        JNIEnv *env = jniInit();
        if (!env) {
            LOG(FATAL) + "JNI initialization failed";
            return;
        }

        jhobject jhObject = 
            getSingleton(env); 

        jhobject jhTask = env->NewObject(s_clshidePopupTask, s_midhidePopupTask,
                    jhObject.get(), 
                    static_cast<jobject>(result));

        run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD);
        if(env->ExceptionCheck() == JNI_TRUE)
        {
            rho::String message = rho::common::clearException(env);
            LOG(ERROR) + message;
            result.setError(message);
        }
    }

    static
    void showStatus(const T& argsAdapter, MethodResultJni& result)
    {
        LOG(TRACE) + "showStatus";

        JNIEnv *env = jniInit();
        if (!env) {
            LOG(FATAL) + "JNI initialization failed";
            return;
        }

        jhobject jhObject = 
            getSingleton(env); 

        jholder< jstring > jhtitle = (argsAdapter.size() <= 0) ?
            0 : 
                rho_cast< jstring >(env, argsAdapter[0]);

        if(argsAdapter.size() <= 1)
        {
            LOG(ERROR) + "Wrong number of arguments: 'status_text' must be set ^^^";
            result.setArgError("Wrong number of arguments: 'status_text' must be set");
            return;
        }
        jholder< jstring > jhstatus_text = 
            rho_cast< jstring >(env, argsAdapter[1]);

        if(argsAdapter.size() <= 2)
        {
            LOG(ERROR) + "Wrong number of arguments: 'hide_button_label' must be set ^^^";
            result.setArgError("Wrong number of arguments: 'hide_button_label' must be set");
            return;
        }
        jholder< jstring > jhhide_button_label = 
            rho_cast< jstring >(env, argsAdapter[2]);

        jhobject jhTask = env->NewObject(s_clsshowStatusTask, s_midshowStatusTask,
                    jhObject.get(), 
                    jhtitle.get(),
                    jhstatus_text.get(),
                    jhhide_button_label.get(),
                    static_cast<jobject>(result));

        run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD);
        if(env->ExceptionCheck() == JNI_TRUE)
        {
            rho::String message = rho::common::clearException(env);
            LOG(ERROR) + message;
            result.setError(message);
        }
    }

    static
    void playFile(const T& argsAdapter, MethodResultJni& result)
    {
        LOG(TRACE) + "playFile";

        JNIEnv *env = jniInit();
        if (!env) {
            LOG(FATAL) + "JNI initialization failed";
            return;
        }

        jhobject jhObject = 
            getSingleton(env); 

        if(argsAdapter.size() <= 0)
        {
            LOG(ERROR) + "Wrong number of arguments: 'path' must be set ^^^";
            result.setArgError("Wrong number of arguments: 'path' must be set");
            return;
        }
        jholder< jstring > jhpath = 
            rho_cast< jstring >(env, argsAdapter[0]);

        jholder< jstring > jhmedia_type = (argsAdapter.size() <= 1) ?
            rho_cast<jstring>(env, "") : 
                rho_cast< jstring >(env, argsAdapter[1]);

        jhobject jhTask = env->NewObject(s_clsplayFileTask, s_midplayFileTask,
                    jhObject.get(), 
                    jhpath.get(),
                    jhmedia_type.get(),
                    static_cast<jobject>(result));

        run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD);
        if(env->ExceptionCheck() == JNI_TRUE)
        {
            rho::String message = rho::common::clearException(env);
            LOG(ERROR) + message;
            result.setError(message);
        }
    }

    static
    void beep(const T& argsAdapter, MethodResultJni& result)
    {
        LOG(TRACE) + "beep";

        JNIEnv *env = jniInit();
        if (!env) {
            LOG(FATAL) + "JNI initialization failed";
            return;
        }

        jhobject jhObject = 
            getSingleton(env); 

        if(argsAdapter.size() <= 0)
        {
            LOG(ERROR) + "Wrong number of arguments: 'propertyMap' must be set ^^^";
            result.setArgError("Wrong number of arguments: 'propertyMap' must be set");
            return;
        }
        jholder< jobject > jhpropertyMap = 
            rho_cast< jobject >(env, argsAdapter[0]);

        jhobject jhTask = env->NewObject(s_clsbeepTask, s_midbeepTask,
                    jhObject.get(), 
                    jhpropertyMap.get(),
                    static_cast<jobject>(result));

        run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD);
        if(env->ExceptionCheck() == JNI_TRUE)
        {
            rho::String message = rho::common::clearException(env);
            LOG(ERROR) + message;
            result.setError(message);
        }
    }

    static
    void vibrate(const T& argsAdapter, MethodResultJni& result)
    {
        LOG(TRACE) + "vibrate";

        JNIEnv *env = jniInit();
        if (!env) {
            LOG(FATAL) + "JNI initialization failed";
            return;
        }

        jhobject jhObject = 
            getSingleton(env); 

        jholder< jint > jhduration = (argsAdapter.size() <= 0) ?
            rho_cast<jint>(env, static_cast<int>(1000)) : 
                rho_cast< jint >(env, argsAdapter[0]);

        jhobject jhTask = env->NewObject(s_clsvibrateTask, s_midvibrateTask,
                    jhObject.get(), 
                    jhduration.get(),
                    static_cast<jobject>(result));

        run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD);
        if(env->ExceptionCheck() == JNI_TRUE)
        {
            rho::String message = rho::common::clearException(env);
            LOG(ERROR) + message;
            result.setError(message);
        }
    }


};


}