/**************************************************************************/
/*  library_godot_javascript_singleton.js                                 */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

const GodotJSWrapper = {

	$GodotJSWrapper__deps: ['$GodotRuntime', '$IDHandler'],
	$GodotJSWrapper__postset: 'GodotJSWrapper.proxies = new Map();',
	$GodotJSWrapper: {
		proxies: null,
		cb_ret: null,

		MyProxy: function (val) {
			const id = IDHandler.add(this);
			GodotJSWrapper.proxies.set(val, id);
			let refs = 1;
			this.ref = function () {
				refs++;
			};
			this.unref = function () {
				refs--;
				if (refs === 0) {
					IDHandler.remove(id);
					GodotJSWrapper.proxies.delete(val);
				}
			};
			this.get_val = function () {
				return val;
			};
			this.get_id = function () {
				return id;
			};
		},

		get_proxied: function (val) {
			const id = GodotJSWrapper.proxies.get(val);
			if (id === undefined) {
				const proxy = new GodotJSWrapper.MyProxy(val);
				return proxy.get_id();
			}
			IDHandler.get(id).ref();
			return id;
		},

		get_proxied_value: function (id) {
			const proxy = IDHandler.get(id);
			if (proxy === undefined) {
				return undefined;
			}
			return proxy.get_val();
		},

		variant2js: function (type, val) {
			switch (type) {
			case 0:
				return null;
			case 1:
				return Boolean(GodotRuntime.getHeapValue(val, 'i64'));
			case 2: {
				// `heap_value` may be a bigint.
				const heap_value = GodotRuntime.getHeapValue(val, 'i64');
				return heap_value >= Number.MIN_SAFE_INTEGER && heap_value <= Number.MAX_SAFE_INTEGER
					? Number(heap_value)
					: heap_value;
			}
			case 3:
				return Number(GodotRuntime.getHeapValue(val, 'double'));
			case 4:
				return GodotRuntime.parseString(GodotRuntime.getHeapValue(val, '*'));
			case 24: // OBJECT
				return GodotJSWrapper.get_proxied_value(GodotRuntime.getHeapValue(val, 'i64'));
			default:
				return undefined;
			}
		},

		js2variant: function (p_val, p_exchange) {
			if (p_val === undefined || p_val === null) {
				return 0; // NIL
			}
			const type = typeof (p_val);
			if (type === 'boolean') {
				GodotRuntime.setHeapValue(p_exchange, p_val, 'i64');
				return 1; // BOOL
			} else if (type === 'number') {
				if (Number.isInteger(p_val)) {
					GodotRuntime.setHeapValue(p_exchange, p_val, 'i64');
					return 2; // INT
				}
				GodotRuntime.setHeapValue(p_exchange, p_val, 'double');
				return 3; // FLOAT
			} else if (type === 'bigint') {
				GodotRuntime.setHeapValue(p_exchange, p_val, 'i64');
				return 2; // INT
			} else if (type === 'string') {
				const c_str = GodotRuntime.allocString(p_val);
				GodotRuntime.setHeapValue(p_exchange, c_str, '*');
				return 4; // STRING
			}
			const id = GodotJSWrapper.get_proxied(p_val);
			GodotRuntime.setHeapValue(p_exchange, id, 'i64');
			return 24; // OBJECT
		},

		isBuffer: function (obj) {
			return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
		},
	},

	godot_js_wrapper_interface_get__proxy: 'sync',
	godot_js_wrapper_interface_get__sig: 'ii',
	godot_js_wrapper_interface_get: function (p_name) {
		const name = GodotRuntime.parseString(p_name);
		if (typeof (window[name]) !== 'undefined') {
			return GodotJSWrapper.get_proxied(window[name]);
		}
		return 0;
	},

	godot_js_wrapper_object_get__proxy: 'sync',
	godot_js_wrapper_object_get__sig: 'iiii',
	godot_js_wrapper_object_get: function (p_id, p_exchange, p_prop) {
		const obj = GodotJSWrapper.get_proxied_value(p_id);
		if (obj === undefined) {
			return 0;
		}
		if (p_prop) {
			const prop = GodotRuntime.parseString(p_prop);
			try {
				return GodotJSWrapper.js2variant(obj[prop], p_exchange);
			} catch (e) {
				GodotRuntime.error(`Error getting variable ${prop} on object`, obj);
				return 0; // NIL
			}
		}
		return GodotJSWrapper.js2variant(obj, p_exchange);
	},

	godot_js_wrapper_object_set__proxy: 'sync',
	godot_js_wrapper_object_set__sig: 'viiii',
	godot_js_wrapper_object_set: function (p_id, p_name, p_type, p_exchange) {
		const obj = GodotJSWrapper.get_proxied_value(p_id);
		if (obj === undefined) {
			return;
		}
		const name = GodotRuntime.parseString(p_name);
		try {
			obj[name] = GodotJSWrapper.variant2js(p_type, p_exchange);
		} catch (e) {
			GodotRuntime.error(`Error setting variable ${name} on object`, obj);
		}
	},

	godot_js_wrapper_object_call__proxy: 'sync',
	godot_js_wrapper_object_call__sig: 'iiiiiiiii',
	godot_js_wrapper_object_call: function (p_id, p_method, p_args, p_argc, p_convert_callback, p_exchange, p_lock, p_free_lock_callback) {
		const obj = GodotJSWrapper.get_proxied_value(p_id);
		if (obj === undefined) {
			return -1;
		}
		const method = GodotRuntime.parseString(p_method);
		const convert = GodotRuntime.get_func(p_convert_callback);
		const freeLock = GodotRuntime.get_func(p_free_lock_callback);
		const args = new Array(p_argc);
		for (let i = 0; i < p_argc; i++) {
			const type = convert(p_args, i, p_exchange, p_lock);
			const lock = GodotRuntime.getHeapValue(p_lock, '*');
			args[i] = GodotJSWrapper.variant2js(type, p_exchange);
			if (lock) {
				freeLock(p_lock, type);
			}
		}
		try {
			const res = obj[method](...args);
			return GodotJSWrapper.js2variant(res, p_exchange);
		} catch (e) {
			GodotRuntime.error(`Error calling method ${method} on:`, obj, 'error:', e);
			return -1;
		}
	},

	godot_js_wrapper_object_unref__proxy: 'sync',
	godot_js_wrapper_object_unref__sig: 'vi',
	godot_js_wrapper_object_unref: function (p_id) {
		const proxy = IDHandler.get(p_id);
		if (proxy !== undefined) {
			proxy.unref();
		}
	},

	godot_js_wrapper_create_cb__proxy: 'sync',
	godot_js_wrapper_create_cb__sig: 'iii',
	godot_js_wrapper_create_cb: function (p_ref, p_func) {
		const func = GodotRuntime.get_func(p_func);
		let id = 0;
		const cb = function () {
			if (!GodotJSWrapper.get_proxied_value(id)) {
				return undefined;
			}
			// The callback will store the returned value in this variable via
			// "godot_js_wrapper_object_set_cb_ret" upon calling the user function.
			// This is safe! JavaScript is single threaded (and using it in threads is not a good idea anyway).
			GodotJSWrapper.cb_ret = null;
			const args = Array.from(arguments);
			const argsProxy = new GodotJSWrapper.MyProxy(args);
			func(p_ref, argsProxy.get_id(), args.length);
			argsProxy.unref();
			const ret = GodotJSWrapper.cb_ret;
			GodotJSWrapper.cb_ret = null;
			return ret;
		};
		id = GodotJSWrapper.get_proxied(cb);
		return id;
	},

	godot_js_wrapper_object_set_cb_ret__proxy: 'sync',
	godot_js_wrapper_object_set_cb_ret__sig: 'vii',
	godot_js_wrapper_object_set_cb_ret: function (p_val_type, p_val_ex) {
		GodotJSWrapper.cb_ret = GodotJSWrapper.variant2js(p_val_type, p_val_ex);
	},

	godot_js_wrapper_object_getvar__proxy: 'sync',
	godot_js_wrapper_object_getvar__sig: 'iiii',
	godot_js_wrapper_object_getvar: function (p_id, p_type, p_exchange) {
		const obj = GodotJSWrapper.get_proxied_value(p_id);
		if (obj === undefined) {
			return -1;
		}
		const prop = GodotJSWrapper.variant2js(p_type, p_exchange);
		if (prop === undefined || prop === null) {
			return -1;
		}
		try {
			return GodotJSWrapper.js2variant(obj[prop], p_exchange);
		} catch (e) {
			GodotRuntime.error(`Error getting variable ${prop} on object`, obj, e);
			return -1;
		}
	},

	godot_js_wrapper_object_setvar__proxy: 'sync',
	godot_js_wrapper_object_setvar__sig: 'iiiiii',
	godot_js_wrapper_object_setvar: function (p_id, p_key_type, p_key_ex, p_val_type, p_val_ex) {
		const obj = GodotJSWrapper.get_proxied_value(p_id);
		if (obj === undefined) {
			return -1;
		}
		const key = GodotJSWrapper.variant2js(p_key_type, p_key_ex);
		try {
			obj[key] = GodotJSWrapper.variant2js(p_val_type, p_val_ex);
			return 0;
		} catch (e) {
			GodotRuntime.error(`Error setting variable ${key} on object`, obj);
			return -1;
		}
	},

	godot_js_wrapper_create_object__proxy: 'sync',
	godot_js_wrapper_create_object__sig: 'iiiiiiii',
	godot_js_wrapper_create_object: function (p_object, p_args, p_argc, p_convert_callback, p_exchange, p_lock, p_free_lock_callback) {
		const name = GodotRuntime.parseString(p_object);
		if (typeof (window[name]) === 'undefined') {
			return -1;
		}
		const convert = GodotRuntime.get_func(p_convert_callback);
		const freeLock = GodotRuntime.get_func(p_free_lock_callback);
		const args = new Array(p_argc);
		for (let i = 0; i < p_argc; i++) {
			const type = convert(p_args, i, p_exchange, p_lock);
			const lock = GodotRuntime.getHeapValue(p_lock, '*');
			args[i] = GodotJSWrapper.variant2js(type, p_exchange);
			if (lock) {
				freeLock(p_lock, type);
			}
		}
		try {
			const res = new window[name](...args);
			return GodotJSWrapper.js2variant(res, p_exchange);
		} catch (e) {
			GodotRuntime.error(`Error calling constructor ${name} with args:`, args, 'error:', e);
			return -1;
		}
	},

	godot_js_wrapper_object_is_buffer__proxy: 'sync',
	godot_js_wrapper_object_is_buffer__sig: 'ii',
	godot_js_wrapper_object_is_buffer: function (p_id) {
		const obj = GodotJSWrapper.get_proxied_value(p_id);
		return GodotJSWrapper.isBuffer(obj)
			? 1
			: 0;
	},

	godot_js_wrapper_object_transfer_buffer__proxy: 'sync',
	godot_js_wrapper_object_transfer_buffer__sig: 'viiii',
	godot_js_wrapper_object_transfer_buffer: function (p_id, p_byte_arr, p_byte_arr_write, p_callback) {
		let obj = GodotJSWrapper.get_proxied_value(p_id);
		if (!GodotJSWrapper.isBuffer(obj)) {
			return;
		}

		if (ArrayBuffer.isView(obj) && !(obj instanceof Uint8Array)) {
			obj = new Uint8Array(obj.buffer);
		} else if (obj instanceof ArrayBuffer) {
			obj = new Uint8Array(obj);
		}

		const resizePackedByteArrayAndOpenWrite = GodotRuntime.get_func(p_callback);
		const bytesPtr = resizePackedByteArrayAndOpenWrite(p_byte_arr, p_byte_arr_write, obj.length);
		HEAPU8.set(obj, bytesPtr);
	},
};

autoAddDeps(GodotJSWrapper, '$GodotJSWrapper');
mergeInto(LibraryManager.library, GodotJSWrapper);

const GodotEval = {
	godot_js_eval__deps: ['$GodotRuntime'],
	godot_js_eval__sig: 'iiiiiii',
	godot_js_eval: function (p_js, p_use_global_ctx, p_union_ptr, p_byte_arr, p_byte_arr_write, p_callback) {
		const js_code = GodotRuntime.parseString(p_js);
		let eval_ret = null;
		try {
			if (p_use_global_ctx) {
				// indirect eval call grants global execution context
				const global_eval = eval; // eslint-disable-line no-eval
				eval_ret = global_eval(js_code);
			} else {
				eval_ret = eval(js_code); // eslint-disable-line no-eval
			}
		} catch (e) {
			GodotRuntime.error(e);
		}

		switch (typeof eval_ret) {
		case 'boolean':
			GodotRuntime.setHeapValue(p_union_ptr, eval_ret, 'i32');
			return 1; // BOOL

		case 'number':
			GodotRuntime.setHeapValue(p_union_ptr, eval_ret, 'double');
			return 3; // FLOAT

		case 'string':
			GodotRuntime.setHeapValue(p_union_ptr, GodotRuntime.allocString(eval_ret), '*');
			return 4; // STRING

		case 'object':
			if (eval_ret === null) {
				break;
			}

			if (ArrayBuffer.isView(eval_ret) && !(eval_ret instanceof Uint8Array)) {
				eval_ret = new Uint8Array(eval_ret.buffer);
			} else if (eval_ret instanceof ArrayBuffer) {
				eval_ret = new Uint8Array(eval_ret);
			}
			if (eval_ret instanceof Uint8Array) {
				const func = GodotRuntime.get_func(p_callback);
				const bytes_ptr = func(p_byte_arr, p_byte_arr_write, eval_ret.length);
				HEAPU8.set(eval_ret, bytes_ptr);
				return 29; // PACKED_BYTE_ARRAY
			}
			break;

			// no default
		}
		return 0; // NIL
	},
};

mergeInto(LibraryManager.library, GodotEval);
