#include "Push.h"


namespace rho {

IMPLEMENT_LOGCLASS(CPushBase, "PushJNI");

//PushFactorySingleton staff
const char* const CPushBase::FACTORY_SINGLETON_CLASS = "com.rho.push.PushFactorySingleton";
jclass CPushBase::s_clsFactorySingleton = 0;
jmethodID CPushBase::s_midFactorySetInstance;
jmethodID CPushBase::s_midFactoryGetInstance;

//PushFactory staff
const char* const CPushBase::IFACTORY_CLASS = "com.rho.push.IPushFactory";
jclass CPushBase::s_clsIFactory = 0;
jmethodID CPushBase::s_midGetApiSingleton;
jmethodID CPushBase::s_midGetApiObject;

//PushSingletonBase staff
const char* const CPushBase::SINGLETON_BASE_CLASS = "com.rho.push.PushSingletonBase";
jclass CPushBase::s_clsSingletonBase = 0;

//PushBase staff
const char* const CPushBase::OBJECT_BASE_CLASS = "com.rho.push.PushBase";
jclass CPushBase::s_clsObjectBase = 0;


//IRhoApiDefaultId staff
const char* const CPushBase::IDEFAULTID_CLASS = "com.rhomobile.rhodes.api.IRhoApiDefaultId";
jclass CPushBase::s_clsIDefaultId = 0;
jmethodID CPushBase::s_midGetDefaultID;
jmethodID CPushBase::s_midSetDefaultID;


//Method tasks

const char* const CPushBase::GETTYPE_TASK_CLASS = 
        "com.rho.push.PushBase$getTypeTask";

jclass CPushBase::s_clsgetTypeTask = 0;
jmethodID CPushBase::s_midgetTypeTask;

const char* const CPushBase::GETUSERNOTIFYMODE_TASK_CLASS = 
        "com.rho.push.PushBase$getUserNotifyModeTask";

jclass CPushBase::s_clsgetUserNotifyModeTask = 0;
jmethodID CPushBase::s_midgetUserNotifyModeTask;

const char* const CPushBase::SETUSERNOTIFYMODE_TASK_CLASS = 
        "com.rho.push.PushBase$setUserNotifyModeTask";

jclass CPushBase::s_clssetUserNotifyModeTask = 0;
jmethodID CPushBase::s_midsetUserNotifyModeTask;

const char* const CPushBase::GETPUSHSERVER_TASK_CLASS = 
        "com.rho.push.PushBase$getPushServerTask";

jclass CPushBase::s_clsgetPushServerTask = 0;
jmethodID CPushBase::s_midgetPushServerTask;

const char* const CPushBase::GETPUSHAPPNAME_TASK_CLASS = 
        "com.rho.push.PushBase$getPushAppNameTask";

jclass CPushBase::s_clsgetPushAppNameTask = 0;
jmethodID CPushBase::s_midgetPushAppNameTask;

const char* const CPushBase::ENUMERATE_TASK_CLASS = 
        "com.rho.push.PushSingletonBase$enumerateTask";

jclass CPushBase::s_clsenumerateTask = 0;
jmethodID CPushBase::s_midenumerateTask;

const char* const CPushBase::GETDEVICEID_TASK_CLASS = 
        "com.rho.push.PushBase$getDeviceIdTask";

jclass CPushBase::s_clsgetDeviceIdTask = 0;
jmethodID CPushBase::s_midgetDeviceIdTask;

const char* const CPushBase::STARTNOTIFICATIONS_TASK_CLASS = 
        "com.rho.push.PushBase$startNotificationsTask";

jclass CPushBase::s_clsstartNotificationsTask = 0;
jmethodID CPushBase::s_midstartNotificationsTask;

const char* const CPushBase::STOPNOTIFICATIONS_TASK_CLASS = 
        "com.rho.push.PushBase$stopNotificationsTask";

jclass CPushBase::s_clsstopNotificationsTask = 0;
jmethodID CPushBase::s_midstopNotificationsTask;

const char* const CPushBase::GETPROPERTY_TASK_CLASS = 
        "com.rho.push.PushBase$getPropertyTask";

jclass CPushBase::s_clsgetPropertyTask = 0;
jmethodID CPushBase::s_midgetPropertyTask;

const char* const CPushBase::GETPROPERTIES_TASK_CLASS = 
        "com.rho.push.PushBase$getPropertiesTask";

jclass CPushBase::s_clsgetPropertiesTask = 0;
jmethodID CPushBase::s_midgetPropertiesTask;

const char* const CPushBase::GETALLPROPERTIES_TASK_CLASS = 
        "com.rho.push.PushBase$getAllPropertiesTask";

jclass CPushBase::s_clsgetAllPropertiesTask = 0;
jmethodID CPushBase::s_midgetAllPropertiesTask;

const char* const CPushBase::SETPROPERTY_TASK_CLASS = 
        "com.rho.push.PushBase$setPropertyTask";

jclass CPushBase::s_clssetPropertyTask = 0;
jmethodID CPushBase::s_midsetPropertyTask;

const char* const CPushBase::SETPROPERTIES_TASK_CLASS = 
        "com.rho.push.PushBase$setPropertiesTask";

jclass CPushBase::s_clssetPropertiesTask = 0;
jmethodID CPushBase::s_midsetPropertiesTask;


//----------------------------------------------------------------------------------------------------------------------

JNIEnv* CPushBase::jniInit()
{
    JNIEnv *env = jnienv();
    if(!env)
    {
        LOG(FATAL) + "JNI init failed: JNIEnv is null";
        return 0;
    }
    return jniInit(env);
}
//----------------------------------------------------------------------------------------------------------------------

JNIEnv* CPushBase::jniInit(JNIEnv* env)
{
    static bool initialized = false;
    env = MethodExecutorJni::jniInit(env);
    if (!env) {
        LOG(FATAL) + "JNI init failed";
        return 0;
    }

    if(!initialized)
    {
        //init PushFactorySingleton JNI
        s_clsFactorySingleton = loadClass(env, FACTORY_SINGLETON_CLASS);
        if (!s_clsFactorySingleton) return 0;

        s_midFactorySetInstance = env->GetStaticMethodID(s_clsFactorySingleton, "setInstance", "(Lcom/rho/push/IPushFactory;)V");
        if(!s_midFactorySetInstance)
        {
            LOG(FATAL) + "Failed to get method 'setInstance' for java class " + FACTORY_SINGLETON_CLASS;
            return NULL;
        }
        s_midFactoryGetInstance = env->GetStaticMethodID(s_clsFactorySingleton, "getInstance", "()Lcom/rho/push/IPushFactory;");
        if(!s_midFactoryGetInstance)
        {
            LOG(FATAL) + "Failed to get method 'getInstance' for java class " + FACTORY_SINGLETON_CLASS;
            return NULL;
        }

        //init IPushFactory JNI
        s_clsIFactory = loadClass(env, IFACTORY_CLASS);
        if (!s_clsIFactory) return 0;
        s_midGetApiSingleton = env->GetMethodID(s_clsIFactory, "getApiSingleton", "()Lcom/rho/push/IPushSingleton;");
        if(!s_midGetApiSingleton)
        {
            LOG(FATAL) + "Failed to get method 'getApiSingleton' for java class " + IFACTORY_CLASS;
            return NULL;
        }
        s_midGetApiObject = env->GetMethodID(s_clsIFactory, "getApiObject", "(Ljava/lang/String;)Lcom/rho/push/IPush;");
        if(!s_midGetApiObject)
        {
            LOG(FATAL) + "Failed to get method 'getApiObject' for java class " + IFACTORY_CLASS;
            return NULL;
        }

        s_clsSingletonBase = loadClass(env, SINGLETON_BASE_CLASS);
        if (!s_clsSingletonBase) return 0;
        s_clsObjectBase = loadClass(env, OBJECT_BASE_CLASS);
        if (!s_clsObjectBase) return 0;



        s_clsgetTypeTask = loadClass(env, GETTYPE_TASK_CLASS);
        if (!s_clsgetTypeTask) return 0;
        s_midgetTypeTask = env->GetMethodID(s_clsgetTypeTask, "<init>",
                        "(Lcom/rho/push/IPush;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midgetTypeTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + GETTYPE_TASK_CLASS;
            return NULL;
        }

        s_clsgetUserNotifyModeTask = loadClass(env, GETUSERNOTIFYMODE_TASK_CLASS);
        if (!s_clsgetUserNotifyModeTask) return 0;
        s_midgetUserNotifyModeTask = env->GetMethodID(s_clsgetUserNotifyModeTask, "<init>",
                        "(Lcom/rho/push/IPush;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midgetUserNotifyModeTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + GETUSERNOTIFYMODE_TASK_CLASS;
            return NULL;
        }

        s_clssetUserNotifyModeTask = loadClass(env, SETUSERNOTIFYMODE_TASK_CLASS);
        if (!s_clssetUserNotifyModeTask) return 0;
        s_midsetUserNotifyModeTask = env->GetMethodID(s_clssetUserNotifyModeTask, "<init>",
                        "(Lcom/rho/push/IPush;Ljava/lang/String;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midsetUserNotifyModeTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + SETUSERNOTIFYMODE_TASK_CLASS;
            return NULL;
        }

        s_clsgetPushServerTask = loadClass(env, GETPUSHSERVER_TASK_CLASS);
        if (!s_clsgetPushServerTask) return 0;
        s_midgetPushServerTask = env->GetMethodID(s_clsgetPushServerTask, "<init>",
                        "(Lcom/rho/push/IPush;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midgetPushServerTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + GETPUSHSERVER_TASK_CLASS;
            return NULL;
        }

        s_clsgetPushAppNameTask = loadClass(env, GETPUSHAPPNAME_TASK_CLASS);
        if (!s_clsgetPushAppNameTask) return 0;
        s_midgetPushAppNameTask = env->GetMethodID(s_clsgetPushAppNameTask, "<init>",
                        "(Lcom/rho/push/IPush;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midgetPushAppNameTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + GETPUSHAPPNAME_TASK_CLASS;
            return NULL;
        }

        s_clsenumerateTask = loadClass(env, ENUMERATE_TASK_CLASS);
        if (!s_clsenumerateTask) return 0;
        s_midenumerateTask = env->GetMethodID(s_clsenumerateTask, "<init>",
                        "(Lcom/rho/push/IPushSingleton;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midenumerateTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + ENUMERATE_TASK_CLASS;
            return NULL;
        }

        s_clsgetDeviceIdTask = loadClass(env, GETDEVICEID_TASK_CLASS);
        if (!s_clsgetDeviceIdTask) return 0;
        s_midgetDeviceIdTask = env->GetMethodID(s_clsgetDeviceIdTask, "<init>",
                        "(Lcom/rho/push/IPush;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midgetDeviceIdTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + GETDEVICEID_TASK_CLASS;
            return NULL;
        }

        s_clsstartNotificationsTask = loadClass(env, STARTNOTIFICATIONS_TASK_CLASS);
        if (!s_clsstartNotificationsTask) return 0;
        s_midstartNotificationsTask = env->GetMethodID(s_clsstartNotificationsTask, "<init>",
                        "(Lcom/rho/push/IPush;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midstartNotificationsTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + STARTNOTIFICATIONS_TASK_CLASS;
            return NULL;
        }

        s_clsstopNotificationsTask = loadClass(env, STOPNOTIFICATIONS_TASK_CLASS);
        if (!s_clsstopNotificationsTask) return 0;
        s_midstopNotificationsTask = env->GetMethodID(s_clsstopNotificationsTask, "<init>",
                        "(Lcom/rho/push/IPush;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midstopNotificationsTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + STOPNOTIFICATIONS_TASK_CLASS;
            return NULL;
        }

        s_clsgetPropertyTask = loadClass(env, GETPROPERTY_TASK_CLASS);
        if (!s_clsgetPropertyTask) return 0;
        s_midgetPropertyTask = env->GetMethodID(s_clsgetPropertyTask, "<init>",
                        "(Lcom/rho/push/IPush;Ljava/lang/String;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midgetPropertyTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + GETPROPERTY_TASK_CLASS;
            return NULL;
        }

        s_clsgetPropertiesTask = loadClass(env, GETPROPERTIES_TASK_CLASS);
        if (!s_clsgetPropertiesTask) return 0;
        s_midgetPropertiesTask = env->GetMethodID(s_clsgetPropertiesTask, "<init>",
                        "(Lcom/rho/push/IPush;Ljava/util/List;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midgetPropertiesTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + GETPROPERTIES_TASK_CLASS;
            return NULL;
        }

        s_clsgetAllPropertiesTask = loadClass(env, GETALLPROPERTIES_TASK_CLASS);
        if (!s_clsgetAllPropertiesTask) return 0;
        s_midgetAllPropertiesTask = env->GetMethodID(s_clsgetAllPropertiesTask, "<init>",
                        "(Lcom/rho/push/IPush;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midgetAllPropertiesTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + GETALLPROPERTIES_TASK_CLASS;
            return NULL;
        }

        s_clssetPropertyTask = loadClass(env, SETPROPERTY_TASK_CLASS);
        if (!s_clssetPropertyTask) return 0;
        s_midsetPropertyTask = env->GetMethodID(s_clssetPropertyTask, "<init>",
                        "(Lcom/rho/push/IPush;Ljava/lang/String;Ljava/lang/String;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midsetPropertyTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + SETPROPERTY_TASK_CLASS;
            return NULL;
        }

        s_clssetPropertiesTask = loadClass(env, SETPROPERTIES_TASK_CLASS);
        if (!s_clssetPropertiesTask) return 0;
        s_midsetPropertiesTask = env->GetMethodID(s_clssetPropertiesTask, "<init>",
                        "(Lcom/rho/push/IPush;Ljava/util/Map;Lcom/rhomobile/rhodes/api/IMethodResult;)V");
        if(!s_midsetPropertiesTask)
        {
            LOG(FATAL) + "Failed to get constructor for java class " + SETPROPERTIES_TASK_CLASS;
            return NULL;
        }


        s_clsIDefaultId = loadClass(env, IDEFAULTID_CLASS);
        if (!s_clsIDefaultId) return 0;
        s_midGetDefaultID = env->GetMethodID(s_clsIDefaultId, "getDefaultID", "()Ljava/lang/String;");
        if(!s_midGetDefaultID)
        {
            LOG(FATAL) + "Failed to get method 'getDefaultID' for java class " + IDEFAULTID_CLASS;
            return NULL;
        }
        s_midSetDefaultID = env->GetMethodID(s_clsIDefaultId, "setDefaultID", "(Ljava/lang/String;)V");
        if(!s_midSetDefaultID)
        {
            LOG(FATAL) + "Failed to get method 'setDefaultID' for java class " + IDEFAULTID_CLASS;
            return NULL;
        }


        initialized = true;
        LOG(TRACE) + "CPush JNI init succeeded";
    }
    return env;
}
//----------------------------------------------------------------------------------------------------------------------

void CPushBase::setJavaFactory(JNIEnv* env, jobject jFactory)
{
    LOG(TRACE) + "setJavaFactory";

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

    env->CallStaticVoidMethod(s_clsFactorySingleton, s_midFactorySetInstance, jFactory);

    LOG(TRACE) + "setJavaFactory succeeded";
}
//----------------------------------------------------------------------------------------------------------------------

rho::String CPushBase::getDefaultID()
{
    LOG(TRACE) + "getDefaultID";

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

    jhobject jhSingleton = getSingleton(env);
    jhstring res = static_cast<jstring>(env->CallObjectMethod(jhSingleton.get(), s_midGetDefaultID));
    return rho_cast<rho::String>(env, res);
}
//----------------------------------------------------------------------------------------------------------------------

void CPushBase::setDefaultID(const rho::String& id)
{
    LOG(TRACE) + "setDefaultID: " + id;

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

    jhobject instance = getSingleton(env);
    jhstring jhId = rho_cast<jstring>(env, id);
    env->CallVoidMethod(instance.get(), s_midSetDefaultID, jhId.get());
}
//----------------------------------------------------------------------------------------------------------------------

jobject CPushBase::getFactory(JNIEnv* env)
{
    jobject res = env->CallStaticObjectMethod(s_clsFactorySingleton, s_midFactoryGetInstance);
    return res;
}
//----------------------------------------------------------------------------------------------------------------------

jobject CPushBase::getSingleton(JNIEnv* env)
{
    jhobject jhFactory = getFactory(env);
    jobject res = env->CallObjectMethod(jhFactory.get(), s_midGetApiSingleton);
    return res;
}
//----------------------------------------------------------------------------------------------------------------------

jobject CPushBase::getObject(JNIEnv* env)
{
    jhstring jhId = rho_cast<jstring>(env, m_id);
    jhobject jhFactory = getFactory(env);
    jobject res = env->CallObjectMethod(jhFactory.get(), s_midGetApiObject, jhId.get());
    return res;
}
//----------------------------------------------------------------------------------------------------------------------


}