/*
 * Copyright 2007-2010 The OpenRA Developers (see AUTHORS)
 * This file is part of OpenRA, which is free software. It is made 
 * available to you under the terms of the GNU General Public License
 * as published by the Free Software Foundation. For more information,
 * see LICENSE.
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <webkit/webkit.h>
#include <JavaScriptCore/JavaScript.h>
#include <glib.h>

#include "main.h"
#include "utility.h"

#define JS_STR(str) JSStringCreateWithUTF8CString(str)
#define JS_FUNC(ctx, callback) JSObjectMakeFunctionWithCallback(ctx, NULL, \
						  callback)

int js_check_num_args(JSContextRef ctx, char const * func_name, int argc, int num_expected, JSValueRef * exception)
{
  char buf[64];
  if (argc < num_expected)
  {
    sprintf(buf, "%s: Not enough args, expected %d got %d", func_name, num_expected, argc);
    *exception = JSValueMakeString(ctx, JS_STR(buf));
    return 0;
  }
  return 1;
}

char * js_get_cstr_from_val(JSContextRef ctx, JSValueRef val, size_t * size)
{
  char * buf;
  size_t str_size;
  JSStringRef str = JSValueToStringCopy(ctx, val, NULL);
  str_size = JSStringGetMaximumUTF8CStringSize(str);
  buf = (char *)malloc(str_size);
  *size = JSStringGetUTF8CString(str, buf, str_size);
  return buf;
}

JSValueRef js_log(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
		  size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  JSValueRef return_value = JSValueMakeNull(ctx);
  if (!js_check_num_args(ctx, "log", argc, 1, exception))
    return return_value;

  if (JSValueIsString(ctx, argv[0]))
  {
    char * buffer;
    size_t str_size;
    buffer = js_get_cstr_from_val(ctx, argv[0], &str_size);
    g_message("JS Log: %s", buffer);
    free(buffer);
    return return_value;
  }
  else
  {
    *exception = JSValueMakeString(ctx, JS_STR("Tried to log something other than a string"));
    return return_value;
  }
}

JSValueRef js_exists_in_mod(JSContextRef ctx, JSObjectRef func, 
			  JSObjectRef this, size_t argc, 
			  const JSValueRef argv[], JSValueRef * exception)
{
  char * mod_buf, * file_buf, search_path[512];
  size_t mod_size, file_size;
  JSValueRef return_value = JSValueMakeNumber(ctx, 0);
  FILE * f;
  if (!js_check_num_args(ctx, "existsInMod", argc, 2, exception))
    return JSValueMakeNull(ctx);

  if (!JSValueIsString(ctx, argv[0]) || !JSValueIsString(ctx, argv[1]))
  {
    *exception = JSValueMakeString(ctx, JS_STR("One or more args are incorrect types."));
    return JSValueMakeNull(ctx);
  }

  file_buf = js_get_cstr_from_val(ctx, argv[0], &file_size);
  mod_buf = js_get_cstr_from_val(ctx, argv[1], &mod_size);
  
  sprintf(search_path, "mods/%s/%s", mod_buf, file_buf);

  free(file_buf);
  free(mod_buf);
 
  g_message("JS ExistsInMod: Looking for %s", search_path);

  f = fopen(search_path, "r");

  if (f != NULL)
  {
    g_message("JS ExistsInMod: Found");
    fclose(f);
    return_value = JSValueMakeNumber(ctx, 1);
  }

  g_message("JS ExistsInMod: Not found");

  return return_value;
}

JSValueRef js_launch_mod(JSContextRef ctx, JSObjectRef func, 
			 JSObjectRef this, size_t argc,
			 const JSValueRef argv[], JSValueRef * exception)
{
  char * mod_key, * mod_list;
  size_t mod_size;
  mod_t * mod;
  int offset;
  JSValueRef return_value = JSValueMakeNull(ctx);

  if (!js_check_num_args(ctx, "launchMod", argc, 1, exception))
    return return_value;

  if (!JSValueIsString(ctx, argv[0]))
  {
    *exception = JSValueMakeString(ctx, JS_STR("One or more args are incorrect types."));
    return return_value;
  }

  mod_key = js_get_cstr_from_val(ctx, argv[0], &mod_size);

  g_message("JS LaunchMod: %s", mod_key);

  mod = get_mod(mod_key);

  offset = strlen(mod_key);
  mod_list = (char *)malloc(offset + 1);
  strcpy(mod_list, mod_key);

  free(mod_key);

  while (strlen(mod->requires) > 0)
  {
    char r[MOD_requires_MAX_LEN], * comma;
    strcpy(r, mod->requires);
    if (NULL != (comma = strchr(r, ',')))
    {
      *comma = '\0';
    }

    mod = get_mod(r);
    if (mod == NULL)
    {
      char exception_msg[64];
      sprintf(exception_msg, "The mod %s is missing, cannot launch.", r);
      *exception = JSValueMakeString(ctx, JS_STR(exception_msg));
      free(mod_list);
      return return_value;
    }

    mod_list = (char *)realloc(mod_list, offset + strlen(r) + 1);
    sprintf(mod_list + offset, ",%s", r);
    offset += strlen(r) + 1;
  }

  {
    char * launch_args[] = { "mono", "OpenRA.Game.exe", NULL, NULL };
    char * game_mods_arg;

    game_mods_arg = (char *)malloc(strlen(mod_list) + strlen("Game.Mods=") + 1);
    sprintf(game_mods_arg, "Game.Mods=%s", mod_list);

    launch_args[2] = game_mods_arg;
    
    g_spawn_async(NULL, launch_args, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL);
    free(game_mods_arg);
  }
  free(mod_list);
  return return_value;
}

typedef struct download_t 
{
  char key[32];
  char url[128];
  char dest[128];
  int current_bytes;
  int total_bytes;
  JSContextGroupRef ctx_group;
  JSObjectRef download_progressed_func;
  JSObjectRef extraction_progressed_func;
  JSValueRef status;
  JSValueRef error;
  GIOChannel * output_channel;
  GPid pid;
} download_t;

#define MAX_DOWNLOADS 16

static download_t downloads[MAX_DOWNLOADS];
static int num_downloads = 0;

download_t * find_download(char const * key)
{
  int i;
  for (i = 0; i < num_downloads; i++)
  {
    if (0 == strcmp(downloads[i].key, key))
      return downloads + i;
  }
  return NULL;
}

void set_download_status(JSContextRef ctx, download_t * download, const char * status)
{
  JSValueUnprotect(ctx, download->status);

  download->status = JSValueMakeString(ctx, JS_STR(status));

  JSValueProtect(ctx, download->status);
}

void set_download_error(JSContextRef ctx, download_t * download, const char * error)
{
  JSValueUnprotect(ctx, download->error);

  download->error = JSValueMakeString(ctx, JS_STR(error));

  JSValueProtect(ctx, download->error);
}

JSValueRef js_register_download(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
				size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  char * key, * url, * filename;
  size_t key_size, url_size, filename_size;
  download_t * download;
  JSValueRef o;
  FILE * f;
  if (!js_check_num_args(ctx, "registerDownload", argc, 3, exception))
    return JSValueMakeNull(ctx);

  key = js_get_cstr_from_val(ctx, argv[0], &key_size);

  g_message("JS RegisterDownload: Registering %s", key);

  if (NULL == (download = find_download(key)))
  {
    download = downloads + num_downloads++;
    if (num_downloads >= MAX_DOWNLOADS)
    {
      num_downloads = MAX_DOWNLOADS - 1;
      return JSValueMakeNull(ctx);
    }
  }

  memset(download, 0, sizeof(download_t));

  download->ctx_group = JSContextGetGroup(ctx);
  o = JSObjectGetProperty(ctx, JSContextGetGlobalObject(ctx), JS_STR("downloadProgressed"), NULL);
  download->download_progressed_func = JSValueToObject(ctx, o, NULL);
  o = JSObjectGetProperty(ctx, JSContextGetGlobalObject(ctx), JS_STR("extractProgressed"), NULL);
  download->extraction_progressed_func = JSValueToObject(ctx, o, NULL);

  strncpy(download->key, key, 31);
  download->key[31] = '\0';

  free(key);

  url = js_get_cstr_from_val(ctx, argv[1], &url_size);
  strncpy(download->url, url, 127);
  download->url[127] = '\0';
  free(url);

  filename = js_get_cstr_from_val(ctx, argv[2], &filename_size);
  //TODO Clean filename to stop access to locations it shouldn't be allowed to access
  sprintf(download->dest, "/tmp/%s", filename);
  download->dest[127] = '\0';
  free(filename);

  f = fopen(download->dest, "r");

  if (NULL != f)
  {
    fclose(f);
    set_download_status(ctx, download, "DOWNLOADED");
  }
  else
    set_download_status(ctx, download, "AVAILABLE");
  
  return JSValueMakeNull(ctx);
}

gboolean update_download_stats(GIOChannel * source, GIOCondition condition, gpointer data)
{
  int ret = TRUE;
  download_t * download = (download_t *)data;
  gchar * line;
  gsize line_length;
  GIOStatus io_status;
  JSValueRef args[1];
  JSContextRef ctx;

  ctx = JSGlobalContextCreateInGroup(download->ctx_group, NULL);
 
  switch(condition)
  {
  case G_IO_IN:
    io_status = g_io_channel_read_line(source, &line, &line_length, NULL, NULL);
    if (G_IO_STATUS_NORMAL == io_status)
    {
      if (0 == memcmp(line, "Error:", 6))
      {
        set_download_status(ctx, download, "ERROR");
        set_download_error(ctx, download, line + 7);
      }
      else
      {
	      set_download_status(ctx, download, "DOWNLOADING");
	      GRegex * pattern = g_regex_new("(\\d{1,3})% (\\d+)/(\\d+) bytes", 0, 0, NULL);
	      GMatchInfo * match;
	      if (g_regex_match(pattern, line, 0, &match))
	      {
	        gchar * current = g_match_info_fetch(match, 2), * total = g_match_info_fetch(match, 3);
	        download->current_bytes = atoi(current);
       	  download->total_bytes = atoi(total);
	        g_free(current);
	        g_free(total);
	      }
	      g_free(match);
      }
    }
    g_free(line);
    break;
  case G_IO_HUP:
    if (!JSStringIsEqualToUTF8CString(JSValueToStringCopy(ctx, download->status, NULL), "ERROR"))
      set_download_status(ctx, download, "DOWNLOADED");
    g_io_channel_shutdown(source, FALSE, NULL);
    ret = FALSE;
    break;
  default:
    break;
  }

  args[0] = JSValueMakeString(ctx, JS_STR(download->key));
  JSObjectCallAsFunction(ctx, download->download_progressed_func, NULL, 1, args, NULL);

  return ret;
}

JSValueRef js_start_download(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
				size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  char * key;
  size_t key_size;
  download_t * download;
  int fd;
  GPid pid;

  if (!js_check_num_args(ctx, "startDownload", argc, 1, exception))
    return JSValueMakeNull(ctx);  

  key = js_get_cstr_from_val(ctx, argv[0], &key_size);

  if (NULL == (download = find_download(key)))
  {
    free(key);
    return JSValueMakeBoolean(ctx, 0);
  }

  free(key);

  g_message("Starting download %s", download->key);

  set_download_status(ctx, download, "DOWNLOADING");

  fd = util_do_download(download->url, download->dest, &pid);

  if (!fd)
    return JSValueMakeBoolean(ctx, 0);

  download->pid = pid;
  download->output_channel = g_io_channel_unix_new(fd);

  g_io_add_watch(download->output_channel, G_IO_IN | G_IO_HUP, update_download_stats, download);

  return JSValueMakeBoolean(ctx, 1);
}

JSValueRef js_cancel_download(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
				size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  char * key;
  size_t key_size;
  download_t * download;

  if (!js_check_num_args(ctx, "cancelDownload", argc, 1, exception))
    return JSValueMakeNull(ctx);

  key = js_get_cstr_from_val(ctx, argv[0], &key_size);

  if (NULL == (download = find_download(key)))
  {
    free(key);
    return JSValueMakeBoolean(ctx, 0);
  }

  if (download->pid)
  {
    set_download_status(ctx, download, "ERROR");
    set_download_error(ctx, download, "Download Cancelled");
    kill(download->pid, SIGTERM);
    remove(download->dest);
  }

  free(key);
  return JSValueMakeBoolean(ctx, 1);
}

JSValueRef js_download_status(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
			      size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  char * key;
  size_t key_size;
  download_t * download;

  if (!js_check_num_args(ctx, "downloadStatus", argc, 1, exception))
    return JSValueMakeNull(ctx);

  key = js_get_cstr_from_val(ctx, argv[0], &key_size);

  if (NULL == (download = find_download(key)))
  {
    free(key);
    return JSValueMakeString(ctx, JS_STR("NOT_REGISTERED"));
  }

  free(key);

  return download->status;
}

JSValueRef js_download_error(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
			     size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  char * key;
  size_t key_size;
  download_t * download;

  if (!js_check_num_args(ctx, "downloadError", argc, 1, exception))
    return JSValueMakeNull(ctx);

  key = js_get_cstr_from_val(ctx, argv[0], &key_size);

  g_message("JS DownloadError: Retrieving error message for %s", key);

  if (NULL == (download = find_download(key)))
  {
    free(key);
    return JSValueMakeString(ctx, JS_STR(""));
  }

  free(key);

  return download->error;
}

JSValueRef js_bytes_completed(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
				size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  char * key;
  size_t key_size;
  download_t * download;

  if (!js_check_num_args(ctx, "bytesCompleted", argc, 1, exception))
    return JSValueMakeNull(ctx);

  key = js_get_cstr_from_val(ctx, argv[0], &key_size);

  if (NULL == (download = find_download(key)))
  {
    free(key);
    return JSValueMakeNumber(ctx, -1);
  }

  free(key);

  return JSValueMakeNumber(ctx, download->current_bytes);
}

JSValueRef js_bytes_total(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
				size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  char * key;
  size_t key_size;
  download_t * download;

  if (!js_check_num_args(ctx, "bytesTotal", argc, 1, exception))
    return JSValueMakeNull(ctx);

  key = js_get_cstr_from_val(ctx, argv[0], &key_size);

  if (NULL == (download = find_download(key)))
  {
    free(key);
    return JSValueMakeNumber(ctx, -1);
  }

  free(key);

  return JSValueMakeNumber(ctx, download->total_bytes);
}

gboolean update_extraction_progress(GIOChannel * source, GIOCondition condition, gpointer data)
{
  int ret = TRUE;
  download_t * download = (download_t *)data;
  gchar * line;
  gsize line_length;
  GIOStatus io_status;
  JSValueRef args[1];
  JSContextRef ctx;

  ctx = JSGlobalContextCreateInGroup(download->ctx_group, NULL);

  switch(condition)
  {
  case G_IO_IN:
    io_status = g_io_channel_read_line(source, &line, &line_length, NULL, NULL);
    if ((G_IO_STATUS_NORMAL == io_status) && (0 == memcmp(line, "Error:", 6)))
    {
      set_download_status(ctx, download, "ERROR");
      set_download_error(ctx, download, line + 7);
    }
    free(line);
    break;
  case G_IO_HUP:
    if (!JSStringIsEqualToUTF8CString(JSValueToStringCopy(ctx, download->status, NULL), "ERROR"))
      set_download_status(ctx, download, "EXTRACTED");
    g_io_channel_shutdown(source, FALSE, NULL);
    ret = FALSE;
    break;
  default:
    break;
  }

  args[0] = JSValueMakeString(ctx, JS_STR(download->key));
  JSObjectCallAsFunction(ctx, download->extraction_progressed_func, NULL, 1, args, NULL);

  return ret;  
}

JSValueRef js_extract_download(JSContextRef ctx, JSObjectRef func, JSObjectRef this,
				size_t argc, const JSValueRef argv[], JSValueRef * exception)
{
  char * key, * dir, * mod, * status, dest_path[512];
  size_t size;
  download_t * download;
  int fd;
  GPid pid;

  if (!js_check_num_args(ctx, "extractDownload", argc, 3, exception))
    return JSValueMakeNull(ctx);

  key = js_get_cstr_from_val(ctx, argv[0], &size);

  if (NULL == (download = find_download(key)))
    return JSValueMakeBoolean(ctx, 0);

  status = js_get_cstr_from_val(ctx, download->status, &size);

  if (0 != strcmp(status, "DOWNLOADED"))
    return JSValueMakeBoolean(ctx, 0);

  free(status);

  set_download_status(ctx, download, "EXTRACTING");

  dir = js_get_cstr_from_val(ctx, argv[1], &size);
  mod = js_get_cstr_from_val(ctx, argv[2], &size);

  sprintf(dest_path, "%s/%s", mod, dir);

  fd = util_do_extract(download->dest, dest_path, &pid);

  if (!fd)
  {
    free(key);
    free(dir);
    free(mod);
    return JSValueMakeBoolean(ctx, 0);
  }

  download->pid = pid;
  download->output_channel = g_io_channel_unix_new(fd);

  g_io_add_watch(download->output_channel, G_IO_IN | G_IO_HUP, update_extraction_progress, download);

  free(key);
  free(dir);
  free(mod);

  return JSValueMakeBoolean(ctx, 1);
}

void js_add_functions(JSGlobalContextRef ctx, JSObjectRef target, char ** names, 
		      JSObjectCallAsFunctionCallback * callbacks, size_t count)
{
  int i;
  for (i = 0; i < count; i++)
  {
    JSObjectRef func = JS_FUNC(ctx, callbacks[i]);
    JSObjectSetProperty(ctx, target, JS_STR(names[i]), func, kJSPropertyAttributeNone, NULL);
  }
}

void bind_js_bridge(WebKitWebView * view, WebKitWebFrame * frame,
		    gpointer context, gpointer window_object,
		    gpointer user_data)
{
  JSGlobalContextRef js_ctx;
  JSObjectRef window_obj, external_obj;
  
  int func_count = 11;
  char * names[] = { "log", "existsInMod", "launchMod", "registerDownload",
		     "startDownload", "cancelDownload", "downloadStatus",
		     "downloadError", "bytesCompleted", "bytesTotal",
		     "extractDownload"};
  JSObjectCallAsFunctionCallback callbacks[] = { js_log, js_exists_in_mod, js_launch_mod,
						 js_register_download, js_start_download,
						 js_cancel_download, js_download_status,
						 js_download_error, js_bytes_completed,
						 js_bytes_total, js_extract_download };
  
  js_ctx = (JSGlobalContextRef)context;

  external_obj = JSObjectMake(js_ctx, NULL, NULL);

  window_obj = (JSObjectRef)window_object;
  JSObjectSetProperty(js_ctx, window_obj, JS_STR("external"),
		      external_obj, 0, NULL);

  js_add_functions(js_ctx, external_obj, names, callbacks, func_count);
}