#include "httpd.js.h"

#include "http.h"
#include "log.h"
#include "mem.h"
#include "task.h"
#include "tlscontext.js.h"
#include "util.js.h"

#include "picohttpparser.h"

#include <stdlib.h>
#include <string.h>

#include <openssl/sha.h>

#if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(_WIN32)
#include <alloca.h>
#endif

static JSClassID _httpd_class_id;
static JSClassID _httpd_request_class_id;

typedef struct _http_handler_data_t
{
	JSContext* context;
	JSValue callback;
} http_handler_data_t;

static JSValue _httpd_response_write_head(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	JS_SetPropertyStr(context, this_val, "response_status", JS_DupValue(context, argv[0]));
	JS_SetPropertyStr(context, this_val, "response_headers", JS_DupValue(context, argv[1]));
	return JS_UNDEFINED;
}

static JSValue _httpd_response_end(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	tf_http_request_t* request = JS_GetOpaque(this_val, _httpd_request_class_id);
	size_t length = 0;
	const void* data = NULL;
	JSValue buffer;
	if (JS_IsString(argv[0]))
	{
		data = JS_ToCStringLen(context, &length, argv[0]);
	}
	else if ((data = tf_util_try_get_array_buffer(context, &length, argv[0])) != 0)
	{
	}
	else
	{
		size_t offset;
		size_t size;
		size_t element_size;
		buffer = tf_util_try_get_typed_array_buffer(context, argv[0], &offset, &size, &element_size);
		if (!JS_IsException(buffer))
		{
			data = tf_util_try_get_array_buffer(context, &length, buffer);
		}
	}
	JSValue response_status = JS_GetPropertyStr(context, this_val, "response_status");
	int status = 0;
	JS_ToInt32(context, &status, response_status);
	JS_FreeValue(context, response_status);

	const char** headers = NULL;
	int headers_length = 0;
	JSValue response_headers = JS_GetPropertyStr(context, this_val, "response_headers");
	JSPropertyEnum* ptab;
	uint32_t plen;
	JS_GetOwnPropertyNames(context, &ptab, &plen, response_headers, JS_GPN_STRING_MASK);
	headers = alloca(sizeof(const char*) * plen * 2);
	headers_length = plen;
	for (uint32_t i = 0; i < plen; ++i)
	{
		JSValue key = JS_AtomToString(context, ptab[i].atom);
		JSPropertyDescriptor desc;
		JSValue key_value = JS_NULL;
		if (JS_GetOwnProperty(context, &desc, response_headers, ptab[i].atom) == 1)
		{
			key_value = desc.value;
			JS_FreeValue(context, desc.setter);
			JS_FreeValue(context, desc.getter);
		}
		headers[i * 2 + 0] = JS_ToCString(context, key);
		headers[i * 2 + 1] = JS_ToCString(context, key_value);
	}

	tf_http_respond(request, status, headers, headers_length, data, length);

	for (int i = 0; i < headers_length * 2; i++)
	{
		JS_FreeCString(context, headers[i]);
	}
	for (uint32_t i = 0; i < plen; ++i)
	{
		JS_FreeAtom(context, ptab[i].atom);
	}
	js_free(context, ptab);
	JS_FreeValue(context, buffer);
	return JS_UNDEFINED;
}

static JSValue _httpd_response_send(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	tf_http_request_t* request = JS_GetOpaque(this_val, _httpd_request_class_id);
	int opcode = 0x1;
	JS_ToInt32(context, &opcode, argv[1]);
	uint64_t length = 0;
	size_t length_size = 0;
	const char* message = JS_ToCStringLen(context, &length_size, argv[0]);
	length = length_size;
	uint8_t* copy = tf_malloc(length + 16);
	bool fin = true;
	size_t header = 1;
	copy[0] = (fin ? (1 << 7) : 0) | (opcode & 0xf);
	if (length < 126)
	{
		copy[1] = length;
		header += 1;
	}
	else if (length < (1 << 16))
	{
		copy[1] = 126;
		copy[2] = (length >> 8) & 0xff;
		copy[3] = (length >> 0) & 0xff;
		header += 3;
	}
	else
	{
		uint32_t high = (length >> 32) & 0xffffffff;
		uint32_t low = (length >> 0) & 0xffffffff;
		copy[1] = 127;
		copy[2] = (high >> 24) & 0xff;
		copy[3] = (high >> 16) & 0xff;
		copy[4] = (high >> 8) & 0xff;
		copy[5] = (high >> 0) & 0xff;
		copy[6] = (low >> 24) & 0xff;
		copy[7] = (low >> 16) & 0xff;
		copy[8] = (low >> 8) & 0xff;
		copy[9] = (low >> 0) & 0xff;
		header += 9;
	}
	memcpy(copy + header, message, length);
	tf_http_request_send(request, copy, header + length);
	tf_free(copy);
	JS_FreeCString(context, message);
	return JS_UNDEFINED;
}

static void _httpd_message_callback(tf_http_request_t* request, int op_code, const void* data, size_t size)
{
	JSContext* context = request->context;
	JSValue response_object = JS_MKPTR(JS_TAG_OBJECT, request->user_data);
	JSValue on_message = JS_GetPropertyStr(context, response_object, "onMessage");

	JSValue event = JS_NewObject(context);
	JS_SetPropertyStr(context, event, "opCode", JS_NewInt32(context, op_code));
	JS_SetPropertyStr(context, event, "data", JS_NewStringLen(context, data, size));
	JSValue response = JS_Call(context, on_message, JS_UNDEFINED, 1, &event);
	tf_util_report_error(context, response);
	JS_FreeValue(context, event);
	JS_FreeValue(context, on_message);
}

static void _httpd_callback_internal(tf_http_request_t* request, bool is_websocket)
{
	http_handler_data_t* data = request->user_data;
	JSContext* context = data->context;
	JSValue request_object = JS_NewObject(context);
	JS_SetPropertyStr(context, request_object, "method", JS_NewString(context, request->method));
	JS_SetPropertyStr(context, request_object, "uri", JS_NewString(context, request->path));
	JSValue headers = JS_NewObject(context);
	for (int i = 0; i < request->headers_count; i++)
	{
		JS_SetPropertyStr(context, headers, request->headers[i].name, JS_NewString(context, request->headers[i].value));
	}
	JS_SetPropertyStr(context, request_object, "headers", headers);
	if (request->query)
	{
		JS_SetPropertyStr(context, request_object, "query", JS_NewString(context, request->query));
	}
	if (request->body)
	{
		JS_SetPropertyStr(context, request_object, "body", tf_util_new_uint8_array(context, request->body, request->content_length));
	}

	JSValue client = JS_NewObject(context);
	JS_SetPropertyStr(context, client, "tls", JS_FALSE);
	JS_SetPropertyStr(context, request_object, "client", client);

	JSValue response_object = JS_NewObjectClass(context, _httpd_request_class_id);
	tf_http_request_ref(request);
	JS_SetOpaque(response_object, request);
	JS_SetPropertyStr(context, response_object, "writeHead", JS_NewCFunction(context, _httpd_response_write_head, "writeHead", 2));
	JS_SetPropertyStr(context, response_object, "end", JS_NewCFunction(context, _httpd_response_end, "end", 1));
	JS_SetPropertyStr(context, response_object, "send", JS_NewCFunction(context, _httpd_response_send, "send", 2));
	JSValue args[] =
	{
		request_object,
		response_object,
	};
	JSValue response = JS_Call(context, data->callback, JS_UNDEFINED, 2, args);
	tf_util_report_error(context, response);
	JS_FreeValue(context, request_object);
	JS_FreeValue(context, response);

	if (is_websocket)
	{
		request->on_message = _httpd_message_callback;
		request->context = context;
		request->user_data = JS_VALUE_GET_PTR(response_object);
	}
	else
	{
		JS_FreeValue(context, response_object);
	}
}

static void _httpd_callback(tf_http_request_t* request)
{
	_httpd_callback_internal(request, false);
}

static void _httpd_websocket_callback(tf_http_request_t* request)
{
	const char* header_connection = tf_http_request_get_header(request, "connection");
	const char* header_upgrade = tf_http_request_get_header(request, "upgrade");
	const char* header_sec_websocket_key = tf_http_request_get_header(request, "sec-websocket-key");
	if (header_connection &&
		header_upgrade &&
		header_sec_websocket_key &&
		strstr(header_connection, "Upgrade") &&
		strcasecmp(header_upgrade, "websocket") == 0)
	{
		static const char* k_magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
		size_t key_length = strlen(header_sec_websocket_key);
		size_t size = key_length + 36;
		uint8_t* key_magic = alloca(size);
		memcpy(key_magic, header_sec_websocket_key, key_length);
		memcpy(key_magic + key_length, k_magic, 36);
		uint8_t digest[20];
		SHA1(key_magic, size, digest);
		char key[41] = { 0 };
		tf_base64_encode(digest, sizeof(digest), key, sizeof(key));
		enum { k_headers_count = 4 };
		const char* headers[k_headers_count * 2] =
		{
			"Upgrade", "websocket",
			"Connection", "Upgrade",
			"Sec-WebSocket-Accept", key,
			"Sec-WebSocket-Version", "13",
		};
		bool send_version =
			!tf_http_request_get_header(request, "sec-websocket-version") ||
			strcmp(tf_http_request_get_header(request, "sec-websocket-version"), "13") != 0;
		tf_http_request_websocket_upgrade(request);
		tf_http_respond(request, 101, headers, send_version ? k_headers_count : (k_headers_count - 1), NULL, 0);
	}
	else
	{
		tf_http_respond(request, 400, NULL, 0, NULL, 0);
	}

	_httpd_callback_internal(request, true);
}

static JSValue _httpd_all(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	tf_http_t* http = JS_GetOpaque(this_val, _httpd_class_id);
	const char* pattern = JS_ToCString(context, argv[0]);
	http_handler_data_t* data = tf_malloc(sizeof(http_handler_data_t));
	*data = (http_handler_data_t) { .context = context, .callback = JS_DupValue(context, argv[1]) };
	tf_http_add_handler(http, pattern, _httpd_callback, data);
	JS_FreeCString(context, pattern);
	return JS_UNDEFINED;
}

static JSValue _httpd_register_socket_handler(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	tf_http_t* http = JS_GetOpaque(this_val, _httpd_class_id);
	const char* pattern = JS_ToCString(context, argv[0]);
	http_handler_data_t* data = tf_malloc(sizeof(http_handler_data_t));
	*data = (http_handler_data_t) { .context = context, .callback = JS_DupValue(context, argv[1]) };
	tf_http_add_handler(http, pattern, _httpd_websocket_callback, data);
	JS_FreeCString(context, pattern);
	return JS_UNDEFINED;
}

static JSValue _httpd_start(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
{
	tf_http_t* http = JS_GetOpaque(this_val, _httpd_class_id);
	int port = 0;
	JS_ToInt32(context, &port, argv[0]);
	tf_tls_context_t* tls = tf_tls_context_get(JS_DupValue(context, argv[1]));
	int assigned_port = tf_http_listen(http, port, tls);
	return JS_NewInt32(context, assigned_port);
}

void _httpd_finalizer(JSRuntime* runtime, JSValue value)
{
	tf_http_t* http = JS_GetOpaque(value, _httpd_class_id);
	tf_http_destroy(http);
}

void _httpd_request_finalizer(JSRuntime* runtime, JSValue value)
{
	tf_http_request_t* request = JS_GetOpaque(value, _httpd_request_class_id);
	tf_http_request_release(request);
}

void tf_httpd_register(JSContext* context)
{
	JS_NewClassID(&_httpd_class_id);
	JS_NewClassID(&_httpd_request_class_id);
	JSClassDef httpd_def =
	{
		.class_name = "Httpd",
		.finalizer = &_httpd_finalizer,
	};
	if (JS_NewClass(JS_GetRuntime(context), _httpd_class_id, &httpd_def) != 0)
	{
		fprintf(stderr, "Failed to register Httpd.\n");
	}
	JSClassDef request_def =
	{
		.class_name = "Request",
		.finalizer = &_httpd_request_finalizer,
	};
	if (JS_NewClass(JS_GetRuntime(context), _httpd_request_class_id, &request_def) != 0)
	{
		fprintf(stderr, "Failed to register Request.\n");
	}
	JSValue global = JS_GetGlobalObject(context);
	JSValue httpd = JS_NewObjectClass(context, _httpd_class_id);

	tf_task_t* task = tf_task_get(context);
	uv_loop_t* loop = tf_task_get_loop(task);
	tf_http_t* http = tf_http_create(loop);
	JS_SetOpaque(httpd, http);

	JS_SetPropertyStr(context, httpd, "handlers", JS_NewObject(context));
	JS_SetPropertyStr(context, httpd, "all", JS_NewCFunction(context, _httpd_all, "all", 2));
	JS_SetPropertyStr(context, httpd, "registerSocketHandler", JS_NewCFunction(context, _httpd_register_socket_handler, "register_socket_handler", 2));
	JS_SetPropertyStr(context, httpd, "start", JS_NewCFunction(context, _httpd_start, "start", 2));
	JS_SetPropertyStr(context, global, "httpd", httpd);
	JS_FreeValue(context, global);
}