/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#include "../../SDL_internal.h"

#include "SDL_stdinc.h"

#include "SDL_assert.h"

#include "SDL_hints.h"

#include "SDL_log.h"

#ifdef __ANDROID__

#include "SDL_system.h"

#include "SDL_android.h"

#include <EGL/egl.h>

#include "../../events/SDL_events_c.h"

#include "../../video/android/SDL_androidkeyboard.h"

#include "../../video/android/SDL_androidtouch.h"

#include "../../video/android/SDL_androidvideo.h"

#include "../../video/android/SDL_androidwindow.h"

#include "../../joystick/android/SDL_sysjoystick_c.h"

#include <android/log.h>

#include <pthread.h>

#include <sys/types.h>

#include <unistd.h>

#define LOG_TAG "SDL_android"

/* #define LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) */

/* #define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) */

#define LOGI(...) do {} while (false)

#define LOGE(...) do {} while (false)

/* Uncomment this to log messages entering and exiting methods in this file */

/* #define DEBUG_JNI */

static void Android_JNI_ThreadDestroyed(void*);

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

 This file links the Java side of Android with libsdl

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

#include <jni.h>

#include <android/log.h>

#include <stdbool.h>

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

                               Globals

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

static pthread_key_t mThreadKey;

static JavaVM* mJavaVM;

/* Main activity */

static jclass mActivityClass;

/* method signatures */

static jmethodID midGetNativeSurface;

static jmethodID midFlipBuffers;

static jmethodID midAudioInit;

static jmethodID midAudioWriteShortBuffer;

static jmethodID midAudioWriteByteBuffer;

static jmethodID midAudioQuit;

static jmethodID midPollInputDevices;

/* Accelerometer data storage */

static float fLastAccelerometer[3];

static bool bHasNewData;

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

                 Functions called by JNI

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

/* Library init */

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)

{

    JNIEnv *env;

    mJavaVM = vm;

    LOGI("JNI_OnLoad called");

    if ((*mJavaVM)->GetEnv(mJavaVM, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {

        LOGE("Failed to get the environment using GetEnv()");

        return -1;

    }

    /*

     * Create mThreadKey so we can keep track of the JNIEnv assigned to each thread

     * Refer to http://developer.android.com/guide/practices/design/jni.html for the rationale behind this

     */

    if (pthread_key_create(&mThreadKey, Android_JNI_ThreadDestroyed) != 0) {

        __android_log_print(ANDROID_LOG_ERROR, "SDL", "Error initializing pthread key");

    }

    Android_JNI_SetupThread();

    return JNI_VERSION_1_4;

}

/* Called before SDL_main() to initialize JNI bindings */

JNIEXPORT void JNICALL SDL_Android_Init(JNIEnv* mEnv, jclass cls)

{

    __android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init()");

    Android_JNI_SetupThread();

    mActivityClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));

    midGetNativeSurface = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

                                "getNativeSurface","()Landroid/view/Surface;");

    midFlipBuffers = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

                                "flipBuffers","()V");

    midAudioInit = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

                                "audioInit", "(IZZI)I");

    midAudioWriteShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

                                "audioWriteShortBuffer", "([S)V");

    midAudioWriteByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

                                "audioWriteByteBuffer", "([B)V");

    midAudioQuit = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

                                "audioQuit", "()V");

    midPollInputDevices = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

                                "pollInputDevices", "()V");

    bHasNewData = false;

    if(!midGetNativeSurface || !midFlipBuffers || !midAudioInit ||

       !midAudioWriteShortBuffer || !midAudioWriteByteBuffer || !midAudioQuit || !midPollInputDevices) {

        __android_log_print(ANDROID_LOG_WARN, "SDL", "SDL: Couldn't locate Java callbacks, check that they're named and typed correctly");

    }

    __android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init() finished!");

}

/* Resize */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeResize(

                                    JNIEnv* env, jclass jcls,

                                    jint width, jint height, jint format)

{

    Android_SetScreenResolution(width, height, format);

}

/* Paddown */

JNIEXPORT int JNICALL Java_org_libsdl_app_SDLActivity_onNativePadDown(

                                    JNIEnv* env, jclass jcls,

                                    jint device_id, jint keycode)

{

    return Android_OnPadDown(device_id, keycode);

}

/* Padup */

JNIEXPORT int JNICALL Java_org_libsdl_app_SDLActivity_onNativePadUp(

                                   JNIEnv* env, jclass jcls,

                                   jint device_id, jint keycode)

{

    return Android_OnPadUp(device_id, keycode);

}

/* Joy */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeJoy(

                                    JNIEnv* env, jclass jcls,

                                    jint device_id, jint axis, jfloat value)

{

    Android_OnJoy(device_id, axis, value);

}

/* POV Hat */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeHat(

                                    JNIEnv* env, jclass jcls,

                                    jint device_id, jint hat_id, jint x, jint y)

{

    Android_OnHat(device_id, hat_id, x, y);

}

JNIEXPORT int JNICALL Java_org_libsdl_app_SDLActivity_nativeAddJoystick(

    JNIEnv* env, jclass jcls,

    jint device_id, jstring device_name, jint is_accelerometer, 

    jint nbuttons, jint naxes, jint nhats, jint nballs)

{

    int retval;

    const char *name = (*env)->GetStringUTFChars(env, device_name, NULL);

    retval = Android_AddJoystick(device_id, name, (SDL_bool) is_accelerometer, nbuttons, naxes, nhats, nballs);

    (*env)->ReleaseStringUTFChars(env, device_name, name);

    return retval;

}

JNIEXPORT int JNICALL Java_org_libsdl_app_SDLActivity_nativeRemoveJoystick(

    JNIEnv* env, jclass jcls, jint device_id)

{

    return Android_RemoveJoystick(device_id);

}

/* Surface Created */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeSurfaceChanged(JNIEnv* env, jclass jcls)

{

    SDL_WindowData *data;

    SDL_VideoDevice *_this;

    if (Android_Window == NULL || Android_Window->driverdata == NULL ) {

        return;

    }

    _this =  SDL_GetVideoDevice();

    data =  (SDL_WindowData *) Android_Window->driverdata;

    /* If the surface has been previously destroyed by onNativeSurfaceDestroyed, recreate it here */

    if (data->egl_surface == EGL_NO_SURFACE) {

        if(data->native_window) {

            ANativeWindow_release(data->native_window);

        }

        data->native_window = Android_JNI_GetNativeWindow();

        data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->native_window);

    }

    /* GL Context handling is done in the event loop because this function is run from the Java thread */

}

/* Surface Destroyed */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeSurfaceDestroyed(JNIEnv* env, jclass jcls)

{

    /* We have to clear the current context and destroy the egl surface here

     * Otherwise there's BAD_NATIVE_WINDOW errors coming from eglCreateWindowSurface on resume

     * Ref: http://stackoverflow.com/questions/8762589/eglcreatewindowsurface-on-ics-and-switching-from-2d-to-3d

     */

    SDL_WindowData *data;

    SDL_VideoDevice *_this;

    if (Android_Window == NULL || Android_Window->driverdata == NULL ) {

        return;

    }

    _this =  SDL_GetVideoDevice();

    data = (SDL_WindowData *) Android_Window->driverdata;

    if (data->egl_surface != EGL_NO_SURFACE) {

        SDL_EGL_MakeCurrent(_this, NULL, NULL);

        SDL_EGL_DestroySurface(_this, data->egl_surface);

        data->egl_surface = EGL_NO_SURFACE;

    }

    /* GL Context handling is done in the event loop because this function is run from the Java thread */

}

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_nativeFlipBuffers(JNIEnv* env, jclass jcls)

{

    SDL_GL_SwapWindow(Android_Window);

}

/* Keydown */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeKeyDown(

                                    JNIEnv* env, jclass jcls, jint keycode)

{

    Android_OnKeyDown(keycode);

}

/* Keyup */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeKeyUp(

                                    JNIEnv* env, jclass jcls, jint keycode)

{

    Android_OnKeyUp(keycode);

}

/* Keyboard Focus Lost */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeKeyboardFocusLost(

                                    JNIEnv* env, jclass jcls)

{

    /* Calling SDL_StopTextInput will take care of hiding the keyboard and cleaning up the DummyText widget */

    SDL_StopTextInput();

}

/* Touch */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeTouch(

                                    JNIEnv* env, jclass jcls,

                                    jint touch_device_id_in, jint pointer_finger_id_in,

                                    jint action, jfloat x, jfloat y, jfloat p)

{

    Android_OnTouch(touch_device_id_in, pointer_finger_id_in, action, x, y, p);

}

/* Accelerometer */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_onNativeAccel(

                                    JNIEnv* env, jclass jcls,

                                    jfloat x, jfloat y, jfloat z)

{

    fLastAccelerometer[0] = x;

    fLastAccelerometer[1] = y;

    fLastAccelerometer[2] = z;

    bHasNewData = true;

}

/* Low memory */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_nativeLowMemory(

                                    JNIEnv* env, jclass cls)

{

    SDL_SendAppEvent(SDL_APP_LOWMEMORY);

}

/* Quit */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_nativeQuit(

                                    JNIEnv* env, jclass cls)

{

    /* Discard previous events. The user should have handled state storage

     * in SDL_APP_WILLENTERBACKGROUND. After nativeQuit() is called, no

     * events other than SDL_QUIT and SDL_APP_TERMINATING should fire */

    SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);

    /* Inject a SDL_QUIT event */

    SDL_SendQuit();

    SDL_SendAppEvent(SDL_APP_TERMINATING);

    /* Resume the event loop so that the app can catch SDL_QUIT which

     * should now be the top event in the event queue. */

    if (!SDL_SemValue(Android_ResumeSem)) SDL_SemPost(Android_ResumeSem);

}

/* Pause */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_nativePause(

                                    JNIEnv* env, jclass cls)

{

    __android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativePause()");

    if (Android_Window) {

        SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);

        SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);

        SDL_SendAppEvent(SDL_APP_WILLENTERBACKGROUND);

        SDL_SendAppEvent(SDL_APP_DIDENTERBACKGROUND);

        /* *After* sending the relevant events, signal the pause semaphore 

         * so the event loop knows to pause and (optionally) block itself */

        if (!SDL_SemValue(Android_PauseSem)) SDL_SemPost(Android_PauseSem);

    }

}

/* Resume */

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLActivity_nativeResume(

                                    JNIEnv* env, jclass cls)

{

    __android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeResume()");

    if (Android_Window) {

        SDL_SendAppEvent(SDL_APP_WILLENTERFOREGROUND);

        SDL_SendAppEvent(SDL_APP_DIDENTERFOREGROUND);

        SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);

        SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_RESTORED, 0, 0);

        /* Signal the resume semaphore so the event loop knows to resume and restore the GL Context

         * We can't restore the GL Context here because it needs to be done on the SDL main thread

         * and this function will be called from the Java thread instead.

         */

        if (!SDL_SemValue(Android_ResumeSem)) SDL_SemPost(Android_ResumeSem);

    }

}

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLInputConnection_nativeCommitText(

                                    JNIEnv* env, jclass cls,

                                    jstring text, jint newCursorPosition)

{

    const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);

    SDL_SendKeyboardText(utftext);

    (*env)->ReleaseStringUTFChars(env, text, utftext);

}

JNIEXPORT void JNICALL Java_org_libsdl_app_SDLInputConnection_nativeSetComposingText(

                                    JNIEnv* env, jclass cls,

                                    jstring text, jint newCursorPosition)

{

    const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);

    SDL_SendEditingText(utftext, 0, 0);

    (*env)->ReleaseStringUTFChars(env, text, utftext);

}

    const char *utfname = (*env)->GetStringUTFChars(env, name, NULL);

    const char *hint = SDL_GetHint(utfname);

    jstring result = (*env)->NewStringUTF(env, hint);

    (*env)->ReleaseStringUTFChars(env, name, utfname);

    return result;

}

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

             Functions called by SDL into Java

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

static int s_active = 0;

struct LocalReferenceHolder

{

    JNIEnv *m_env;

    const char *m_func;

};

static struct LocalReferenceHolder LocalReferenceHolder_Setup(const char *func)

{

    struct LocalReferenceHolder refholder;

    refholder.m_env = NULL;

    refholder.m_func = func;

#ifdef DEBUG_JNI

    SDL_Log("Entering function %s", func);

#endif

    return refholder;

}

static SDL_bool LocalReferenceHolder_Init(struct LocalReferenceHolder *refholder, JNIEnv *env)

{

    const int capacity = 16;

    if ((*env)->PushLocalFrame(env, capacity) < 0) {

        SDL_SetError("Failed to allocate enough JVM local references");

        return SDL_FALSE;

    }

    ++s_active;

    refholder->m_env = env;

    return SDL_TRUE;

}

static void LocalReferenceHolder_Cleanup(struct LocalReferenceHolder *refholder)

{

#ifdef DEBUG_JNI

    SDL_Log("Leaving function %s", refholder->m_func);

#endif

    if (refholder->m_env) {

        JNIEnv* env = refholder->m_env;

        (*env)->PopLocalFrame(env, NULL);

        --s_active;

    }

}

static SDL_bool LocalReferenceHolder_IsActive()

{

    return s_active > 0;

}

ANativeWindow* Android_JNI_GetNativeWindow(void)

{

    ANativeWindow* anw;

    jobject s;

    JNIEnv *env = Android_JNI_GetEnv();

    s = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetNativeSurface);

    anw = ANativeWindow_fromSurface(env, s);

    (*env)->DeleteLocalRef(env, s);

    return anw;

}

void Android_JNI_SwapWindow()

{

    JNIEnv *mEnv = Android_JNI_GetEnv();

    (*mEnv)->CallStaticVoidMethod(mEnv, mActivityClass, midFlipBuffers);

}

void Android_JNI_SetActivityTitle(const char *title)

{

    jmethodID mid;

    JNIEnv *mEnv = Android_JNI_GetEnv();

    mid = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,"setActivityTitle","(Ljava/lang/String;)Z");

    if (mid) {

        jstring jtitle = (jstring)((*mEnv)->NewStringUTF(mEnv, title));

        (*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, mid, jtitle);

        (*mEnv)->DeleteLocalRef(mEnv, jtitle);

    }

}

SDL_bool Android_JNI_GetAccelerometerValues(float values[3])

{

    int i;