#include "os.h"
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/mman.h>

// This is probably bad, but makes things easier to build
#include <android_native_app_glue.c>

static struct {
  struct android_app* app;
  JNIEnv* jni;
  fn_quit* onQuit;
  fn_key* onKeyboardEvent;
  fn_text* onTextEvent;
  fn_permission* onPermissionEvent;
} state;

static void onAppCmd(struct android_app* app, int32_t cmd) {
  if (cmd == APP_CMD_DESTROY && state.onQuit) {
    state.onQuit();
  }
}

static int32_t onInputEvent(struct android_app* app, AInputEvent* event) {
  if (AInputEvent_getType(event) != AINPUT_EVENT_TYPE_KEY || !state.onKeyboardEvent) {
    return 0;
  }

  os_button_action action;
  switch (AKeyEvent_getAction(event)) {
    case AKEY_EVENT_ACTION_DOWN: action = BUTTON_PRESSED; break;
    case AKEY_EVENT_ACTION_UP: action = BUTTON_RELEASED; break;
    default: return 0;
  }

  os_key key;
  switch (AKeyEvent_getKeyCode(event)) {
    case AKEYCODE_A: key = KEY_A; break;
    case AKEYCODE_B: key = KEY_B; break;
    case AKEYCODE_C: key = KEY_C; break;
    case AKEYCODE_D: key = KEY_D; break;
    case AKEYCODE_E: key = KEY_E; break;
    case AKEYCODE_F: key = KEY_F; break;
    case AKEYCODE_G: key = KEY_G; break;
    case AKEYCODE_H: key = KEY_H; break;
    case AKEYCODE_I: key = KEY_I; break;
    case AKEYCODE_J: key = KEY_J; break;
    case AKEYCODE_K: key = KEY_K; break;
    case AKEYCODE_L: key = KEY_L; break;
    case AKEYCODE_M: key = KEY_M; break;
    case AKEYCODE_N: key = KEY_N; break;
    case AKEYCODE_O: key = KEY_O; break;
    case AKEYCODE_P: key = KEY_P; break;
    case AKEYCODE_Q: key = KEY_Q; break;
    case AKEYCODE_R: key = KEY_R; break;
    case AKEYCODE_S: key = KEY_S; break;
    case AKEYCODE_T: key = KEY_T; break;
    case AKEYCODE_U: key = KEY_U; break;
    case AKEYCODE_V: key = KEY_V; break;
    case AKEYCODE_W: key = KEY_W; break;
    case AKEYCODE_X: key = KEY_X; break;
    case AKEYCODE_Y: key = KEY_Y; break;
    case AKEYCODE_Z: key = KEY_Z; break;
    case AKEYCODE_0: key = KEY_0; break;
    case AKEYCODE_1: key = KEY_1; break;
    case AKEYCODE_2: key = KEY_2; break;
    case AKEYCODE_3: key = KEY_3; break;
    case AKEYCODE_4: key = KEY_4; break;
    case AKEYCODE_5: key = KEY_5; break;
    case AKEYCODE_6: key = KEY_6; break;
    case AKEYCODE_7: key = KEY_7; break;
    case AKEYCODE_8: key = KEY_8; break;
    case AKEYCODE_9: key = KEY_9; break;

    case AKEYCODE_SPACE: key = KEY_SPACE; break;
    case AKEYCODE_ENTER: key = KEY_ENTER; break;
    case AKEYCODE_TAB: key = KEY_TAB; break;
    case AKEYCODE_ESCAPE: key = KEY_ESCAPE; break;
    case AKEYCODE_DEL: key = KEY_BACKSPACE; break;
    case AKEYCODE_DPAD_UP: key = KEY_UP; break;
    case AKEYCODE_DPAD_DOWN: key = KEY_DOWN; break;
    case AKEYCODE_DPAD_LEFT: key = KEY_LEFT; break;
    case AKEYCODE_DPAD_RIGHT: key = KEY_RIGHT; break;
    case AKEYCODE_MOVE_HOME: key = KEY_HOME; break;
    case AKEYCODE_MOVE_END: key = KEY_END; break;
    case AKEYCODE_PAGE_UP: key = KEY_PAGE_UP; break;
    case AKEYCODE_PAGE_DOWN: key = KEY_PAGE_DOWN; break;
    case AKEYCODE_INSERT: key = KEY_INSERT; break;
    case AKEYCODE_FORWARD_DEL: key = KEY_DELETE; break;
    case AKEYCODE_F1: key = KEY_F1; break;
    case AKEYCODE_F2: key = KEY_F2; break;
    case AKEYCODE_F3: key = KEY_F3; break;
    case AKEYCODE_F4: key = KEY_F4; break;
    case AKEYCODE_F5: key = KEY_F5; break;
    case AKEYCODE_F6: key = KEY_F6; break;
    case AKEYCODE_F7: key = KEY_F7; break;
    case AKEYCODE_F8: key = KEY_F8; break;
    case AKEYCODE_F9: key = KEY_F9; break;
    case AKEYCODE_F10: key = KEY_F10; break;
    case AKEYCODE_F11: key = KEY_F11; break;
    case AKEYCODE_F12: key = KEY_F12; break;

    case AKEYCODE_GRAVE: key = KEY_BACKTICK; break;
    case AKEYCODE_MINUS: key = KEY_MINUS; break;
    case AKEYCODE_EQUALS: key = KEY_EQUALS; break;
    case AKEYCODE_LEFT_BRACKET: key = KEY_LEFT_BRACKET; break;
    case AKEYCODE_RIGHT_BRACKET: key = KEY_RIGHT_BRACKET; break;
    case AKEYCODE_BACKSLASH: key = KEY_BACKSLASH; break;
    case AKEYCODE_SEMICOLON: key = KEY_SEMICOLON; break;
    case AKEYCODE_APOSTROPHE: key = KEY_APOSTROPHE; break;
    case AKEYCODE_COMMA: key = KEY_COMMA; break;
    case AKEYCODE_PERIOD: key = KEY_PERIOD; break;
    case AKEYCODE_SLASH: key = KEY_SLASH; break;

    case AKEYCODE_CTRL_LEFT: key = KEY_LEFT_CONTROL; break;
    case AKEYCODE_SHIFT_LEFT: key = KEY_LEFT_SHIFT; break;
    case AKEYCODE_ALT_LEFT: key = KEY_LEFT_ALT; break;
    case AKEYCODE_META_LEFT: key = KEY_LEFT_OS; break;
    case AKEYCODE_CTRL_RIGHT: key = KEY_RIGHT_CONTROL; break;
    case AKEYCODE_SHIFT_RIGHT: key = KEY_RIGHT_SHIFT; break;
    case AKEYCODE_ALT_RIGHT: key = KEY_RIGHT_ALT; break;
    case AKEYCODE_META_RIGHT: key = KEY_RIGHT_OS; break;

    case AKEYCODE_CAPS_LOCK: key = KEY_CAPS_LOCK; break;
    case AKEYCODE_SCROLL_LOCK: key = KEY_SCROLL_LOCK; break;
    case AKEYCODE_NUM_LOCK: key = KEY_NUM_LOCK; break;

    default: return 0;
  }

  uint32_t scancode = AKeyEvent_getScanCode(event);
  bool repeat = AKeyEvent_getRepeatCount(event) > 0;

  state.onKeyboardEvent(action, key, scancode, repeat);

  // Text event
  if (action == BUTTON_PRESSED && state.onTextEvent) {
    jclass jKeyEvent = (*state.jni)->FindClass(state.jni, "android/view/KeyEvent");
    jmethodID jgetUnicodeChar = (*state.jni)->GetMethodID(state.jni, jKeyEvent, "getUnicodeChar", "(I)I");
    jmethodID jKeyEventInit = (*state.jni)->GetMethodID(state.jni, jKeyEvent, "<init>", "(II)V");
    jobject jevent = (*state.jni)->NewObject(state.jni, jKeyEvent, jKeyEventInit, AKEY_EVENT_ACTION_DOWN, AKeyEvent_getKeyCode(event));
    uint32_t codepoint = (*state.jni)->CallIntMethod(state.jni, jevent, jgetUnicodeChar, AKeyEvent_getMetaState(event));
    if (codepoint > 0) {
      state.onTextEvent(codepoint);
    }
    (*state.jni)->DeleteLocalRef(state.jni, jevent);
    (*state.jni)->DeleteLocalRef(state.jni, jKeyEvent);
  }

  return 1;
}

int main(int argc, char** argv);

void android_main(struct android_app* app) {
  state.app = app;
  (*app->activity->vm)->AttachCurrentThread(app->activity->vm, &state.jni, NULL);
  os_open_console();
  app->onAppCmd = onAppCmd;
  app->onInputEvent = onInputEvent;
  main(0, NULL);
  (*app->activity->vm)->DetachCurrentThread(app->activity->vm);
}

bool os_init() {
  return true;
}

void os_destroy() {
  // There are two ways a quit can happen, which need to be handled slightly differently:
  // - If the system tells us to quit, we get an event with APP_CMD_DESTROY.  In response we push a
  //   QUIT event to lovr.event and main will eventually exit cleanly.  No other teardown necessary.
  // - If the app exits manually (e.g. lovr.event.quit), then Android thinks we're still running and
  //   the app is still in APP_CMD_RESUME.  We need to tell it to exit with ANativeActivity_Finish
  //   and poll for events until the app state changes, otherwise the app is left in a broken state.
  if (state.app->activityState == APP_CMD_RESUME) {
    state.onQuit = NULL;
    state.onKeyboardEvent = NULL;
    state.onTextEvent = NULL;
    state.onPermissionEvent = NULL;
    ANativeActivity_finish(state.app->activity);
    while (!state.app->destroyRequested) {
      os_poll_events();
    }
  }
  memset(&state, 0, sizeof(state));
}

const char* os_get_name() {
  return "Android";
}

uint32_t os_get_core_count() {
  return sysconf(_SC_NPROCESSORS_ONLN);
}

// To make regular printing work, a thread makes a pipe and redirects stdout and stderr to the write
// end of the pipe.  The read end of the pipe is forwarded to __android_log_write.
static struct {
  int handles[2];
  pthread_t thread;
} log;

static void* log_main(void* data) {
  int* fd = data;
  pipe(fd);
  dup2(fd[1], STDOUT_FILENO);
  dup2(fd[1], STDERR_FILENO);
  setvbuf(stdout, 0, _IOLBF, 0);
  setvbuf(stderr, 0, _IONBF, 0);
  ssize_t length;
  char buffer[1024];
  while ((length = read(fd[0], buffer, sizeof(buffer) - 1)) > 0) {
    buffer[length] = '\0';
    __android_log_write(ANDROID_LOG_DEBUG, "LOVR", buffer);
  }
  return 0;
}

void os_open_console() {
  pthread_create(&log.thread, NULL, log_main, log.handles);
  pthread_detach(log.thread);
}

#define NS_PER_SEC 1000000000ULL

double os_get_time() {
  struct timespec t;
  clock_gettime(CLOCK_MONOTONIC, &t);
  return (double) t.tv_sec + (t.tv_nsec / (double) NS_PER_SEC);
}

void os_sleep(double seconds) {
  seconds += .5e-9;
  struct timespec t;
  t.tv_sec = seconds;
  t.tv_nsec = (seconds - t.tv_sec) * NS_PER_SEC;
  while (nanosleep(&t, &t));
}

#define _JNI(PKG, X) Java_ ## PKG ## _ ## X
#define JNI(PKG, X) _JNI(PKG, X)

JNIEXPORT void JNICALL JNI(LOVR_JAVA_PACKAGE, Activity_lovrPermissionEvent)(JNIEnv* jni, jobject activity, jint permission, jboolean granted) {
  if (state.onPermissionEvent) {
    state.onPermissionEvent(permission, granted);
  }
}

void os_request_permission(os_permission permission) {
  if (permission == OS_PERMISSION_AUDIO_CAPTURE) {
    jobject activity = state.app->activity->clazz;
    jclass class = (*state.jni)->GetObjectClass(state.jni, activity);
    jmethodID requestAudioCapturePermission = (*state.jni)->GetMethodID(state.jni, class, "requestAudioCapturePermission", "()V");
    if (!requestAudioCapturePermission) {
      (*state.jni)->DeleteLocalRef(state.jni, class);
      if (state.onPermissionEvent) state.onPermissionEvent(OS_PERMISSION_AUDIO_CAPTURE, false);
      return;
    }

    (*state.jni)->CallVoidMethod(state.jni, activity, requestAudioCapturePermission);
  }
}

void* os_vm_init(size_t size) {
  return mmap(NULL, size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
}

bool os_vm_free(void* p, size_t size) {
  return !munmap(p, size);
}

bool os_vm_commit(void* p, size_t size) {
  return !mprotect(p, size, PROT_READ | PROT_WRITE);
}

bool os_vm_release(void* p, size_t size) {
  return !madvise(p, size, MADV_DONTNEED);
}

// Notes about polling:
// - Stop polling if a destroy is requested to give the application a chance to shut down.
//   Otherwise this loop would still wait for an event and the app would seem unresponsive.
// - Block if the app is paused or no window is present
// - If the app was active and becomes inactive after an event, break instead of waiting for
//   another event.  This gives the main loop a chance to respond (e.g. exit VR mode).
void os_poll_events() {
  while (!state.app->destroyRequested) {
    int events;
    struct android_poll_source* source;
    int timeout = (state.app->window && state.app->activityState == APP_CMD_RESUME) ? 0 : -1;
    if (ALooper_pollAll(timeout, NULL, &events, (void**) &source) >= 0) {
      if (source) {
        source->process(state.app, source);
      }

      if (timeout == 0 && (!state.app->window || state.app->activityState != APP_CMD_RESUME)) {
        break;
      }
    } else {
      break;
    }
  }
}

void os_on_quit(fn_quit* callback) {
  state.onQuit = callback;
}

void os_on_focus(fn_focus* callback) {
  //
}

void os_on_resize(fn_resize* callback) {
  //
}

void os_on_key(fn_key* callback) {
  state.onKeyboardEvent = callback;
}

void os_on_text(fn_text* callback) {
  state.onTextEvent = callback;
}

void os_on_permission(fn_permission* callback) {
  state.onPermissionEvent = callback;
}

bool os_window_open(const os_window_config* config) {
  return true;
}

bool os_window_is_open() {
  return false;
}

void os_window_get_size(uint32_t* width, uint32_t* height) {
  *width = *height = 0;
}

float os_window_get_pixel_density(void) {
  return 0.f;
}

size_t os_get_home_directory(char* buffer, size_t size) {
  return 0;
}

size_t os_get_data_directory(char* buffer, size_t size) {
  const char* path = state.app->activity->externalDataPath;
  size_t length = strlen(path);
  if (length >= size) return 0;
  memcpy(buffer, path, length);
  buffer[length] = '\0';
  return length;
}

size_t os_get_working_directory(char* buffer, size_t size) {
  return getcwd(buffer, size) ? strlen(buffer) : 0;
}

size_t os_get_executable_path(char* buffer, size_t size) {
  ssize_t length = readlink("/proc/self/exe", buffer, size - 1);
  if (length >= 0) {
    buffer[length] = '\0';
    return length;
  } else {
    return 0;
  }
}

size_t os_get_bundle_path(char* buffer, size_t size, const char** root) {
  jobject activity = state.app->activity->clazz;
  jclass class = (*state.jni)->GetObjectClass(state.jni, activity);
  jmethodID getPackageCodePath = (*state.jni)->GetMethodID(state.jni, class, "getPackageCodePath", "()Ljava/lang/String;");
  if (!getPackageCodePath) {
    (*state.jni)->DeleteLocalRef(state.jni, class);
    return 0;
  }

  jstring jpath = (*state.jni)->CallObjectMethod(state.jni, activity, getPackageCodePath);
  (*state.jni)->DeleteLocalRef(state.jni, class);
  if ((*state.jni)->ExceptionOccurred(state.jni)) {
    (*state.jni)->ExceptionClear(state.jni);
    return 0;
  }

  size_t length = (*state.jni)->GetStringUTFLength(state.jni, jpath);
  if (length >= size) return 0;

  const char* path = (*state.jni)->GetStringUTFChars(state.jni, jpath, NULL);
  memcpy(buffer, path, length);
  buffer[length] = '\0';
  (*state.jni)->ReleaseStringUTFChars(state.jni, jpath, path);
  *root = "/assets";
  return length;
}

void os_get_mouse_position(double* x, double* y) {
  *x = *y = 0.;
}

void os_set_mouse_mode(os_mouse_mode mode) {
  //
}

bool os_is_mouse_down(os_mouse_button button) {
  return false;
}

bool os_is_key_down(os_key key) {
  return false;
}

// Private, must be declared manually to use

void* os_get_java_vm() {
  return state.app->activity->vm;
}

void* os_get_jni_context() {
  return state.app->activity->clazz;
}

const char** os_vk_get_instance_extensions(uint32_t* count) {
  return *count = 0, NULL;
}

uint32_t os_vk_create_surface(void* instance, void** surface) {
  return -13; // VK_ERROR_UNKNOWN
}