module js

import v.ast
import strings
import v.util

@[inline]
fn styp_to_copy_fn_name(styp string) string {
	return styp.replace_each(['*', '', '.', '__', ' ', '__']) + '_\$copy'
}

fn (mut g JsGen) get_copy_fn(typ ast.Type) string {
	mut unwrapped := g.unwrap_generic(typ).set_nr_muls(0).clear_flag(.variadic)
	if g.pref.nofloat {
		if typ == ast.f32_type {
			unwrapped = ast.u32_type
		} else if typ == ast.f64_type {
			unwrapped = ast.u64_type
		}
	}
	if typ.has_flag(.option) {
		unwrapped.set_flag(.option)
	}
	styp := g.styp(unwrapped)
	mut sym := g.table.sym(unwrapped)
	mut copy_fn_name := styp_to_copy_fn_name(styp)
	if mut sym.info is ast.Alias {
		if sym.info.is_import {
			sym = g.table.sym(sym.info.parent_type)
			copy_fn_name = styp_to_copy_fn_name(sym.name)
		}
	}
	g.copy_types << StrType{
		typ:  unwrapped
		styp: styp
	}
	return copy_fn_name
}

fn (mut g JsGen) gen_copy_for_option(_typ ast.Type, _styp string, copy_fn_name string) {
	g.definitions.writeln('function ${copy_fn_name}(it) { return it; }')
}

fn (mut g JsGen) gen_copy_for_alias(info ast.Alias, _styp string, copy_fn_name string) {
	parent_copy_fn_name := g.get_str_fn(info.parent_type)

	g.definitions.writeln('function ${copy_fn_name}(it) {')
	g.definitions.writeln('\tlet res = ${parent_copy_fn_name}(it);')
	g.definitions.writeln('\treturn res;')
	g.definitions.writeln('}')
}

fn (mut g JsGen) gen_copy_for_multi_return(info ast.MultiReturn, _styp string, copy_fn_name string) {
	mut fn_builder := strings.new_builder(512)
	fn_builder.writeln('function ${copy_fn_name}(a) {')
	fn_builder.writeln('\tlet arr = []')
	for i, typ in info.types {
		sym := g.table.sym(typ)
		arg_copy_fn_name := g.get_copy_fn(typ)

		if sym.kind in [.f32, .f64] {
			if sym.kind == .f32 {
				fn_builder.writeln('\tarr.push(new f32(a[${i}].val));')
			} else {
				fn_builder.writeln('\tarr.push(new f64(a[${i}].val));')
			}
		} else if sym.kind == .string {
			fn_builder.writeln('\tarr.push(new string(a[${i}].str +""));')
		} else if sym.kind == .function {
			fn_builder.writeln('\tarr.push(a[${i}]);')
		} else {
			fn_builder.writeln('\tarr.push(${arg_copy_fn_name}(a[${i}]));')
		}
	}
	fn_builder.writeln('\treturn arr;')
	fn_builder.writeln('}')
	g.definitions.writeln(fn_builder.str())
}

fn (mut g JsGen) gen_copy_for_enum(_info ast.Enum, _styp string, copy_fn_name string) {
	g.definitions.writeln('function ${copy_fn_name}(it) { return it; }')
}

fn (mut g JsGen) gen_copy_for_union_sum_type(info ast.SumType, _styp string, copy_fn_name string) {
	mut fn_builder := strings.new_builder(512)
	fn_builder.writeln('function ${copy_fn_name}(x) {')
	for typ in info.variants {
		typ_str := g.styp(typ)
		mut func_name := g.get_copy_fn(typ)
		fn_builder.writeln('if (x instanceof ${typ_str}) { return ${func_name}(x); }')
	}
	fn_builder.writeln('builtin__panic(new string("unknown sum type value"));\n}')
	g.definitions.writeln(fn_builder.str())
}

fn (mut g JsGen) gen_copy_for_interface(_info ast.Interface, styp string, copy_fn_name string) {
	mut fn_builder := strings.new_builder(512)
	mut clean_interface_v_type_name := styp.replace('__', '.')
	if styp.ends_with('*') {
		clean_interface_v_type_name = '&' + clean_interface_v_type_name.replace('*', '')
	}
	if clean_interface_v_type_name.contains('_T_') {
		clean_interface_v_type_name =
			clean_interface_v_type_name.replace('Array_', '[]').replace('_T_', '<').replace('_', ', ') +
			'>'
	}
	clean_interface_v_type_name = util.strip_main_name(clean_interface_v_type_name)
	fn_builder.writeln('function ${copy_fn_name}(x) { return x; }')
	/*
	for typ in info.types {
		subtype := g.table.sym(typ)
		mut func_name := g.get_copy_fn(typ)
		if typ == ast.string_type {

			fn_builder.write_string('\tif (x instanceof string)')
			fn_builder.write_string(' return new string(x.str + "");')
		} else {
			/*
			mut val := '${func_name}(${deref}(${subtype.cname}*)x._${subtype.cname}'
			if should_use_indent_func(subtype.kind) && !sym_has_str_method {
				val += ', indent_count'
			}
			val += ')'
			val = val
			*/
			res := '"TODO'
			fn_builder.write_string('\tif (x instanceof ${g.styp(typ)})')
			fn_builder.write_string(' return ${func_name}(x);\n')
		}
	}
	fn_builder.writeln('\tbuiltin__panic("unknown interface value");')
	fn_builder.writeln('}')*/
	g.definitions.writeln(fn_builder.str())
}

fn (mut g JsGen) gen_copy_for_fn_type(_info ast.FnType, _styp string, copy_fn_name string) {
	g.definitions.writeln('function ${copy_fn_name} (x) { return x; }')
}

fn (mut g JsGen) gen_copy_for_array(_info ast.Array, _styp string, copy_fn_name string) {
	g.definitions.writeln('function ${copy_fn_name} (x) { return x; }')
}

fn (mut g JsGen) gen_copy_for_array_fixed(_info ast.ArrayFixed, _styp string, copy_fn_name string) {
	g.definitions.writeln('function ${copy_fn_name} (x) { return x; }')
}

fn (mut g JsGen) gen_copy_for_map(_info ast.Map, _styp string, copy_fn_name string) {
	g.definitions.writeln('function ${copy_fn_name} (x) { return x; }')
}

fn (mut g JsGen) gen_copy_for_struct(_info ast.Struct, _styp string, copy_fn_name string) {
	mut fn_builder := strings.new_builder(512)
	defer {
		g.definitions.writeln(fn_builder.str())
	}

	fn_builder.writeln('function ${copy_fn_name}(it) { return it }')

	/*
	tmp := g.new_tmp_var()
	fn_builder.writeln('\tlet ${tmp} = new ${styp}({});')
	for field in info.fields {
		println(field)
		if field.name == '' {

		} else {
			mut shall_copy := true
			for attr in field.attrs {
				if attr.name == 'noinit' {
					shall_copy = false
					break
				}
			}
			if shall_copy {
				func_name := g.get_copy_fn(field.typ)
				fn_builder.writeln('\t${tmp}.${field.name} = ${func_name}(it.${field.name});')
			} else {
				fn_builder.writeln('\t${tmp}.${field.name} = it.${field.name}')
			}
		}
	}
	fn_builder.writeln('\treturn ${tmp};\n}')*/
}

fn (mut g JsGen) final_gen_copy(typ StrType) {
	if typ in g.generated_copy_fns {
		return
	}
	g.generated_copy_fns << typ
	sym := g.table.sym(typ.typ)
	if sym.has_method('\$copy') && !typ.typ.has_flag(.option) {
		return
	}
	styp := typ.styp
	copy_fn_name := styp_to_copy_fn_name(styp)
	if typ.typ.has_flag(.option) {
		g.gen_copy_for_option(typ.typ, styp, copy_fn_name)
		return
	}
	match styp {
		'byte', 'u8', 'u16', 'u32', 'u64', 'i16', 'i32', 'int', 'i64', 'isize', 'usize', 'bool',
		'char', 'rune', 'int_literal', 'float_literal', 'f32', 'f64', 'voidptr' {
			g.definitions.writeln('function ${sym.cname}_\$copy(it) { return new ${sym.cname}(it.val); }')
			return
		}
		else {}
	}

	match sym.info {
		ast.Alias {
			g.gen_copy_for_alias(sym.info, styp, copy_fn_name)
		}
		ast.Array {
			g.gen_copy_for_array(sym.info, styp, copy_fn_name)
		}
		ast.ArrayFixed {
			g.gen_copy_for_array_fixed(sym.info, styp, copy_fn_name)
		}
		ast.Enum {
			g.gen_copy_for_enum(sym.info, styp, copy_fn_name)
		}
		ast.FnType {
			g.gen_copy_for_fn_type(sym.info, styp, copy_fn_name)
		}
		ast.Struct {
			g.gen_copy_for_struct(sym.info, styp, copy_fn_name)
		}
		ast.Map {
			g.gen_copy_for_map(sym.info, styp, copy_fn_name)
		}
		ast.MultiReturn {
			g.gen_copy_for_multi_return(sym.info, styp, copy_fn_name)
		}
		ast.SumType {
			g.gen_copy_for_union_sum_type(sym.info, styp, copy_fn_name)
		}
		ast.Interface {
			g.gen_copy_for_interface(sym.info, styp, copy_fn_name)
		}
		else {
			verror("could not generate string method ${copy_fn_name} for type '${styp}'")
		}
	}
}