module js

import v.ast
import v.util
import strings

pub const builtin_functions = ['print', 'println', 'eprint', 'eprintln', 'isnil', 'panic', 'exit']

fn (mut g JsGen) js_mname(name_ string) string {
	mut is_js := false
	is_overload := ['+', '-', '*', '/', '==', '<', '>']
	mut name := name_
	if name.starts_with('JS.') {
		name = name[3..]
		is_js = true
	}
	ns := get_ns(name)
	name = if name in is_overload {
		match name {
			'+' {
				'\$add'
			}
			'-' {
				'\$sub'
			}
			'/' {
				'\$div'
			}
			'*' {
				'\$mul'
			}
			'%' {
				'\$mod'
			}
			'==' {
				'eq'
			}
			'>' {
				'\$gt'
			}
			'<' {
				'\$lt'
			}
			else {
				''
			}
		}
	} else if unsafe { g.ns == 0 } {
		name
	} else if ns == g.ns.name {
		name.split('.').last()
	} else {
		g.get_alias(name)
	}
	mut parts := name.split('.')
	if !is_js {
		for i, p in parts {
			if p in js_reserved {
				parts[i] = 'v_${p}'
			}
		}
	}
	return parts.join('.')
}

fn (mut g JsGen) js_call(node ast.CallExpr) {
	g.call_stack << node
	it := node
	call_return_is_option := it.return_type.has_flag(.option)
	is_await := node.name == 'JS.await'
	if call_return_is_option {
		if is_await {
			g.writeln('await (async function () {')
		} else {
			g.writeln('(function () {')
		}
		g.writeln('try {')
		g.writeln('let tmp = ')
	}
	if it.is_ctor_new {
		g.write('new ')
	}
	if is_await {
		g.write('await (')

		g.expr(it.args[0].expr)
		g.write(').promise')
	} else {
		g.write('${g.js_mname(it.name)}(')
		for i, arg in it.args {
			g.expr(arg.expr)
			if i != it.args.len - 1 {
				g.write(', ')
			}
		}
		// end call
		g.write(')')
	}
	if call_return_is_option {
		g.write(';\n')
		prev_inside_or := g.inside_or
		g.inside_or = true
		defer {
			g.inside_or = prev_inside_or
		}
		g.writeln('if (tmp === null) throw "none";')
		g.writeln('return tmp;')
		g.writeln('} catch(err) {')
		g.inc_indent()
		// gen or block contents
		match it.or_block.kind {
			.block {
				if it.or_block.stmts.len > 1 {
					g.stmts(it.or_block.stmts[..it.or_block.stmts.len - 1])
				}
				// g.write('return ')
				g.stmt(it.or_block.stmts.last())
			}
			.propagate_option {
				panicstr := '`option not set (\${err + ""})`'
				if g.file.mod.name == 'main' && g.fn_decl.name == 'main.main' {
					g.writeln('return builtin__panic(${panicstr})')
				} else {
					g.writeln('throw new Option({ state: new u8(2), err: error(new string(${panicstr})) });')
				}
			}
			else {}
		}

		// end catch
		g.dec_indent()
		g.writeln('}')
		g.writeln('})()')
	}
	g.call_stack.delete_last()
}

fn (mut g JsGen) js_method_call(node ast.CallExpr) {
	g.call_stack << node
	it := node
	call_return_is_option := it.return_type.has_flag(.option)
	if call_return_is_option {
		g.writeln('(function () {')
		g.writeln('try {')
		g.writeln('let tmp = ')
	}
	if it.is_ctor_new {
		g.write('new ')
	}
	g.expr(it.left)
	g.write('.${g.js_mname(it.name)}(')
	for i, arg in it.args {
		g.expr(arg.expr)
		if i != it.args.len - 1 {
			g.write(', ')
		}
	}
	// end method call
	g.write(')')
	if call_return_is_option {
		prev_inside_or := g.inside_or
		g.inside_or = true
		defer {
			g.inside_or = prev_inside_or
		}
		g.write(';\n')
		g.writeln('if (tmp === null) throw "none";')
		g.writeln('return tmp;')
		g.writeln('} catch(err) {')
		g.inc_indent()
		// gen or block contents
		match it.or_block.kind {
			.block {
				if it.or_block.stmts.len > 1 {
					g.stmts(it.or_block.stmts[..it.or_block.stmts.len - 1])
				}
				// g.write('return ')
				g.stmt(it.or_block.stmts.last())
			}
			.propagate_option {
				panicstr := '`option not set (\${err + ""})`'
				if g.file.mod.name == 'main' && g.fn_decl.name == 'main.main' {
					g.writeln('return builtin__panic(${panicstr})')
				} else {
					g.writeln('throw new option({ state: new u8(2), err: error(new string(${panicstr})) });')
				}
			}
			else {}
		}

		// end catch
		g.dec_indent()
		g.writeln('}')
		g.writeln('})()')
	}
	g.call_stack.delete_last()
}

fn (mut g JsGen) method_call(node ast.CallExpr) {
	g.call_stack << node
	it := node
	if it.name == 'str' {
		g.gen_expr_to_string(node.left, node.left_type)
		return
	}
	is_async := node.name == 'wait' && g.table.sym(node.receiver_type).name.starts_with('Promise<')
	call_return_is_option := it.return_type.has_flag(.option)
	if call_return_is_option {
		if is_async {
			g.writeln('(async function (){')
		} else {
			g.writeln('(function(){')
		}
		g.inc_indent()
		g.writeln('try {')
		g.inc_indent()
		g.write('return unwrap(')
	}
	if node.name == 'str' {
		mut rec_type := node.receiver_type
		if rec_type.has_flag(.shared_f) {
			rec_type = rec_type.clear_flag(.shared_f).set_nr_muls(0)
		}
		g.get_str_fn(rec_type)
	}
	mut unwrapped_rec_type := node.receiver_type
	if unsafe { g.fn_decl != 0 } && g.fn_decl.generic_names.len > 0 { // in generic fn
		unwrapped_rec_type = g.unwrap_generic(node.receiver_type)
	} else { // in non-generic fn
		sym := g.table.sym(node.receiver_type)
		match sym.info {
			ast.Struct, ast.Interface, ast.SumType {
				generic_names := sym.info.generic_types.map(g.table.sym(it).name)
				// see comment at top of vlib/v/gen/c/utils.v
				mut muttable := unsafe { &ast.Table(g.table) }
				if utyp := muttable.convert_generic_type(node.receiver_type, generic_names,
					sym.info.concrete_types)
				{
					unwrapped_rec_type = utyp
				}
			}
			else {}
		}
	}

	mut typ_sym := g.table.sym(unwrapped_rec_type)
	rec_cc_type := g.cc_type(unwrapped_rec_type, false)
	mut receiver_type_name := util.no_dots(rec_cc_type)
	// alias type that undefined this method (not include `str`) need to use parent type
	if typ_sym.kind == .alias && node.name != 'str' && !typ_sym.has_method(node.name) {
		unwrapped_rec_type = (typ_sym.info as ast.Alias).parent_type
		typ_sym = g.table.sym(unwrapped_rec_type)
	}

	if typ_sym.kind == .interface && (typ_sym.info as ast.Interface).defines_method(node.name) {
		g.expr(it.left)
		g.gen_deref_ptr(it.left_type)
		g.write('.${it.name}(')
		for i, arg in it.args {
			g.expr(arg.expr)
			if i != it.args.len - 1 {
				g.write(', ')
			}
		}
		g.write(')')
		return
	}

	left_sym := g.table.sym(node.left_type)
	final_left_sym := g.table.final_sym(node.left_type)

	if final_left_sym.kind == .map && it.name in special_map_methods {
		g.gen_map_method_call(it)
		return
	} else if final_left_sym.kind == .array {
		if it.name in ['map', 'filter'] {
			g.expr(it.left)
			mut ltyp := it.left_type
			for ltyp.is_ptr() {
				g.write('.valueOf()')
				ltyp = ltyp.deref()
			}
			g.write('.')
			// Prevent 'it' from getting shadowed inside the match

			g.write(it.name)
			g.write('(')
			expr := node.args[0].expr
			match expr {
				ast.AnonFn {
					g.gen_fn_decl(expr.decl)
					g.write(')')
					return
				}
				ast.Ident {
					if expr.kind == .function {
						g.write(g.js_name(expr.name))
						g.write(')')
						return
					} else if expr.kind == .variable && expr.info is ast.IdentVar {
						v_sym := g.table.sym(expr.var_info().typ)
						if v_sym.kind == .function {
							g.write(g.js_name(expr.name))
							g.write(')')
							return
						}
					}
				}
				else {}
			}

			g.write('it => ')
			g.expr(node.args[0].expr)
			g.write(')')
			return
		}

		if it.name in special_array_methods {
			g.gen_array_method_call(it)
			return
		}

		if node.name in ['repeat', 'sort_with_compare', 'free', 'push_many', 'trim', 'first', 'last',
			'pop_left', 'pop', 'clone', 'reverse', 'slice', 'pointers'] {
			if !(left_sym.info is ast.Alias && typ_sym.has_method(node.name)) {
				// `array_Xyz_clone` => `array_clone`
				receiver_type_name = 'array'
			}
		}
	}

	if is_async {
		g.write('await ')
		g.expr(it.left)
		g.write('.promise')
	} else {
		mut name := util.no_dots('${receiver_type_name}_${node.name}')

		name = g.generic_fn_name(node.concrete_types, name)
		g.write('${name}(')
		g.expr_with_expected_type(it.left, unwrapped_rec_type)
		g.gen_deref_ptr(it.left_type)
		g.write(',')
		for i, arg in it.args {
			expected_arg_type := if i < it.expected_arg_types.len {
				it.expected_arg_types[i]
			} else {
				arg.typ
			}
			g.expr_with_expected_type(arg.expr, expected_arg_type)
			if i != it.args.len - 1 {
				g.write(', ')
			}
		}
		g.write(')')
	}

	if call_return_is_option {
		// end unwrap
		g.writeln(')')
		g.dec_indent()
		prev_inside_or := g.inside_or
		g.inside_or = true
		defer {
			g.inside_or = prev_inside_or
		}
		// begin catch block
		g.writeln('} catch(err) {')
		g.inc_indent()
		// gen or block contents
		match it.or_block.kind {
			.block {
				if it.or_block.stmts.len > 1 {
					g.stmts(it.or_block.stmts[..it.or_block.stmts.len - 1])
				}
				// g.write('return ')
				g.stmt(it.or_block.stmts.last())
			}
			.propagate_option {
				panicstr := '`option not set (\${err.valueOf().msg})`'
				if g.file.mod.name == 'main' && g.fn_decl.name == 'main.main' {
					g.writeln('return builtin__panic(${panicstr})')
				} else {
					g.writeln('js_throw(err)')
				}
			}
			else {}
		}

		// end catch
		g.dec_indent()
		g.writeln('}')
		// end anon fn
		g.dec_indent()
		g.write('})()')
	}
	g.call_stack.delete_last()
}

fn (mut g JsGen) gen_call_expr(it ast.CallExpr) {
	if it.should_be_skipped {
		return
	}
	if it.is_method && (it.is_field || g.table.sym(it.receiver_type).name.starts_with('JS.')) {
		g.js_method_call(it)
		return
	} else if it.name.starts_with('JS.') {
		g.js_call(it)
		return
	}
	if it.is_method {
		g.method_call(it)
		return
	}
	node := it
	g.call_stack << it
	mut name := g.js_name(it.name)

	is_print := name in ['print', 'println', 'eprint', 'eprintln', 'panic']
	if name in builtin_functions {
		name = 'builtin__${name}'
	}
	print_method := name
	ret_sym := g.table.sym(it.return_type)
	if it.language == .js && ret_sym.name in v_types && ret_sym.name != 'void' {
		g.write('new ')
		g.write(ret_sym.name)
		g.write('(')
	}
	call_return_is_option := it.return_type.has_flag(.option)
	if call_return_is_option {
		g.writeln('(function(){')
		g.inc_indent()
		g.writeln('try {')
		g.inc_indent()
		g.write('return unwrap(')
	}
	if is_print {
		mut typ := node.args[0].typ

		expr := node.args[0].expr
		g.write('${print_method} (')
		g.gen_expr_to_string(expr, typ)
		g.write(')')
		return
	}
	name = g.generic_fn_name(node.concrete_types, name)
	g.expr(it.left)

	g.write('${name}(')
	for i, arg in it.args {
		expected_arg_type := if i < it.expected_arg_types.len {
			it.expected_arg_types[i]
		} else {
			arg.typ
		}
		g.expr_with_expected_type(arg.expr, expected_arg_type)
		if i != it.args.len - 1 {
			g.write(', ')
		}
	}
	// end method call
	g.write(')')
	if call_return_is_option {
		// end unwrap
		prev_inside_or := g.inside_or
		g.inside_or = true
		defer {
			g.inside_or = prev_inside_or
		}
		g.writeln(')')
		g.dec_indent()
		// begin catch block
		g.writeln('} catch(err) {')
		g.inc_indent()
		// gen or block contents
		match it.or_block.kind {
			.block {
				if it.or_block.stmts.len > 1 {
					g.stmts(it.or_block.stmts[..it.or_block.stmts.len - 1])
				}

				//	g.write('return ')
				g.stmt(it.or_block.stmts.last())
			}
			.propagate_option {
				panicstr := '`option not set (\${err.valueOf().msg})`'
				if g.file.mod.name == 'main' && g.fn_decl.name == 'main.main' {
					g.writeln('return builtin__panic(${panicstr})')
				} else {
					g.writeln('js_throw(err)')
				}
			}
			else {}
		}

		// end catch
		g.dec_indent()
		g.writeln('}')
		// end anon fn
		g.dec_indent()
		g.write('})()')
	}
	if it.language == .js && ret_sym.name in v_types && ret_sym.name != 'void' {
		g.write(')')
	}
	g.call_stack.delete_last()
}

enum FnGenType {
	function
	struct_method
	alias_method
	iface_method
}

fn (g &JsGen) fn_gen_type(it &ast.FnDecl) FnGenType {
	if it.is_method && g.table.sym(it.params[0].typ).kind == .alias {
		return .alias_method
	} else if it.is_method && g.table.sym(it.params[0].typ).kind == .interface {
		return .iface_method
	} else if it.is_method || it.no_body {
		return .struct_method
	} else {
		return .function
	}
}

fn (mut g JsGen) is_used_by_main(node ast.FnDecl) bool {
	mut is_used_by_main := true
	if g.pref.skip_unused {
		fkey := node.fkey()
		is_used_by_main = g.table.used_features.used_fns[fkey]
		$if trace_skip_unused_fns ? {
			println('> is_used_by_main: ${is_used_by_main} | node.name: ${node.name} | fkey: ${fkey} | node.is_method: ${node.is_method}')
		}
		if !is_used_by_main {
			$if trace_skip_unused_fns_in_js_code ? {
				g.writeln('// trace_skip_unused_fns_in_js_code, ${node.name}, fkey: ${fkey}')
			}
		}
	} else {
		$if trace_skip_unused_fns_in_js_code ? {
			g.writeln('// trace_skip_unused_fns_in_js_code, ${node.name}, fkey: ${node.fkey()}')
		}
	}
	return is_used_by_main
}

fn (mut g JsGen) gen_fn_decl(it ast.FnDecl) {
	res := g.fn_gen_type(it)
	if it.language == .js && it.no_body {
		for attr in it.attrs {
			match attr.name {
				'wasm_import' {
					mut x := g.wasm_export[attr.arg] or { []string{} }
					x << it.name
					g.wasm_import[attr.arg] = x
				}
				else {}
			}
		}
		return
	}
	if g.inside_builtin {
		g.builtin_fns << it.name
	}
	if !g.is_used_by_main(it) {
		return
	}
	if it.should_be_skipped {
		return
	}
	cur_fn_decl := g.fn_decl
	g.fn_decl = unsafe { &it }
	g.gen_method_decl(it, res)
	g.fn_decl = cur_fn_decl
}

fn fn_has_go(node ast.FnDecl) bool {
	mut has_go := false
	for stmt in node.stmts {
		if stmt is ast.ExprStmt {
			if stmt.expr is ast.GoExpr {
				has_go = true
				break
			}
		}
	}
	return has_go
}

fn (mut g JsGen) generic_fn_name(types []ast.Type, before string) string {
	if types.len == 0 {
		return before
	}

	mut name := before + '_T'
	for typ in types {
		name += '_' + strings.repeat_string('__ptr__', typ.nr_muls()) + g.styp(typ.set_nr_muls(0))
	}
	return name
}

fn (mut g JsGen) gen_method_decl(it ast.FnDecl, typ FnGenType) {
	node := it
	if node.generic_names.len > 0 && g.cur_concrete_types.len == 0 { // need the cur_concrete_type check to avoid inf. recursion
		// loop thru each generic type and generate a function
		for concrete_types in g.table.fn_generic_types[node.fkey()] {
			if g.pref.is_verbose {
				syms := concrete_types.map(g.table.sym(it))
				the_type := syms.map(it.name).join(', ')
				println('gen fn `${node.name}` for type `${the_type}`')
			}
			g.cur_concrete_types = concrete_types
			g.gen_method_decl(node, typ)
		}
		g.cur_concrete_types = []
		return
	}
	cur_fn_decl := g.fn_decl
	unsafe {
		g.fn_decl = &it
	}
	cur_fn_save := g.table.cur_fn
	defer {
		g.table.cur_fn = cur_fn_save
	}
	unsafe {
		g.table.cur_fn = &it
	}
	mut name := it.name
	if name in ['+', '-', '*', '**', '/', '%', '<', '==', '[]', '[]='] {
		name = util.replace_op(name)
	}

	if node.is_method {
		name = g.cc_type(node.receiver.typ, false) + '_' + name
	}
	name = g.js_name(name)

	name = g.generic_fn_name(g.cur_concrete_types, name)
	if name in builtin_functions {
		name = 'builtin__${name}'
	}
	if it.is_pub && !it.is_method {
		g.push_pub_var(name)
	}
	if it.language == .js && it.is_method {
		g.writeln('${g.styp(it.receiver.typ)}.prototype.${it.name} = ')
	}

	mut has_go := fn_has_go(it) || it.has_await
	for attr in it.attrs {
		if attr.name == 'async' {
			if g.pref.output_es5 {
				verror('cannot use @[async] attribute when outputting ES5 source code')
			}
			has_go = true
			break
		}
	}
	is_main := it.name == 'main.main'
	g.gen_attrs(it.attrs)
	if is_main {
		// there is no concept of main in JS but we do have iife
		g.writeln('/* program entry point */')
		if !g.pref.output_es5 {
			// main function is always async
			g.write('async ')
		}
		g.write('function js_main(')
	} else if it.is_anon {
		g.write('function (')
	} else {
		c := name[0]
		if c in [`+`, `-`, `*`, `/`] {
			name = util.replace_op(name)
		}
		// type_name := g.styp(it.return_type)
		// generate jsdoc for the function
		g.doc.gen_fn(it)
		if has_go && !g.pref.output_es5 {
			g.write('async ')
		}

		g.write('function ')

		g.write('${name}(')
		if it.is_pub && !it.is_method {
			g.push_pub_var(name)
		}
	}
	args := it.params

	g.fn_args(args, it.is_variadic)
	g.writeln(') {')
	for i, arg in args {
		is_varg := i == args.len - 1 && it.is_variadic
		arg_name := g.js_name(arg.name)
		if is_varg {
			g.writeln('${arg_name} = new array(new array_buffer({arr: ${arg_name},len: new int(${arg_name}.length),index_start: new int(0)}));')
		} else {
			asym := g.table.sym(arg.typ)
			if asym.kind != .interface && asym.language != .js {
				if arg.typ.is_ptr() || arg.is_mut {
					g.writeln('${arg_name} = new \$ref(${arg_name})')
				}
			}
		}
	}
	g.inc_indent()
	g.writeln('try {')
	g.inc_indent()
	g.stmts(it.stmts)
	g.dec_indent()
	g.writeln('} catch (e) { ')
	g.writeln('\tif (e instanceof ReturnException) { return e.val; } ')
	g.writeln('\tthrow e;')
	g.writeln('}')
	g.dec_indent()
	g.writeln('}')

	if is_main {
		// g.write(')')
	}
	g.writeln('')
	for attr in it.attrs {
		match attr.name {
			'export' {
				g.writeln('globalThis.${attr.arg} = ${g.js_name(it.name)};')
			}
			'wasm_export' {
				mut x := g.wasm_export[attr.arg] or { []string{} }
				g.write('function \$wasm${g.js_name(it.name)}(')
				g.fn_args(args, it.is_variadic)
				g.writeln(') {')
				g.write('\treturn ${name} (')
				for i, arg in args {
					is_varg := i == args.len - 1 && it.is_variadic
					arg_name := g.js_name(arg.name)
					if is_varg {
						g.write('...${arg_name}')
					} else {
						g.gen_cast_tmp(arg_name, arg.typ)
					}
					if i != args.len - 1 {
						g.write(',')
					}
				}
				g.writeln(').valueOf();')
				g.writeln('}')
				x << it.name
				g.wasm_export[attr.arg] = x
			}
			'wasm_import' {
				mut x := g.wasm_export[attr.arg] or { []string{} }
				x << name
				g.wasm_import[attr.arg] = x
			}
			else {}
		}
	}

	g.fn_decl = cur_fn_decl
}

fn (mut g JsGen) fn_args(args []ast.Param, is_variadic bool) {
	for i, arg in args {
		name := g.js_name(arg.name)
		is_varg := i == args.len - 1 && is_variadic
		if is_varg {
			g.write('...${name}')
		} else {
			g.write(name)
		}
		// if its not the last argument
		if i < args.len - 1 {
			g.write(', ')
		}
	}
}

fn (mut g JsGen) gen_anon_fn(mut fun ast.AnonFn) {
	mut fn_name := fun.decl.name
	if fun.decl.generic_names.len > 0 {
		fn_name = g.generic_fn_name(g.cur_concrete_types, fn_name)
	}
	if fun.has_gen[fn_name] {
		return
	}
	fun.has_gen[fn_name] = true
	it := fun.decl
	cur_fn_decl := g.fn_decl
	unsafe {
		g.fn_decl = &it
	}
	cur_fn_save := g.table.cur_fn
	defer {
		g.table.cur_fn = cur_fn_save
	}
	unsafe {
		g.table.cur_fn = &it
	}
	mut name := it.name
	if name in ['+', '-', '*', '**', '/', '%', '<', '==', '[]', '[]='] {
		name = util.replace_op(name)
	}
	g.writeln('(function () { ')
	mut inherited2copy := map[string]string{}
	for inherited in fun.inherited_vars {
		if !inherited.is_mut {
			copy := g.copy_val(inherited.typ, inherited.name)
			inherited2copy[inherited.name] = copy
		}
	}

	name = g.js_name(name)

	name = g.generic_fn_name(g.table.cur_concrete_types, name)
	if name in builtin_functions {
		name = 'builtin__${name}'
	}
	if it.is_pub && !it.is_method {
		g.push_pub_var(name)
	}
	g.gen_attrs(it.attrs)

	g.write('return function (')

	args := it.params

	g.fn_args(args, it.is_variadic)
	g.writeln(') {')

	g.inc_indent()
	for i, arg in args {
		is_varg := i == args.len - 1 && it.is_variadic
		arg_name := g.js_name(arg.name)
		if is_varg {
			g.writeln('${arg_name} = new array(new array_buffer({arr: ${arg_name},len: new int(${arg_name}.length),index_start: new int(0)}));')
		} else {
			asym := g.table.sym(arg.typ)

			if arg.typ.is_ptr() || (arg.is_mut && asym.kind != .interface && asym.language != .js) {
				g.writeln('${arg_name} = new \$ref(${arg_name})')
			}
		}
	}

	for inherited in fun.inherited_vars {
		if !inherited.is_mut {
			g.writeln('let ${inherited.name} = ${inherited2copy[inherited.name]};')
		}
	}
	g.stmts(it.stmts)
	g.dec_indent()
	g.writeln('}})()')

	g.fn_decl = cur_fn_decl
}