// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license that can be found in the LICENSE file.
module c

import strings
import v.ast

fn (mut g Gen) equality_fn(typ ast.Type) string {
	eq_key := g.eq_fn_key(typ)
	g.needed_equality_fns << eq_key
	st2 := g.styp(eq_key)
	res := st2.replace('struct ', '')
	return res
}

@[inline]
fn string_eq_expr(left string, right string, is_ptr bool) string {
	return if is_ptr {
		'(${left} == ${right} || (${left} != 0 && ${right} != 0 && (((*${left}).len == (*${right}).len && (*${left}).len == 0) || builtin__fast_string_eq(*${left}, *${right}))))'
	} else {
		'(((${left}).len == (${right}).len && (${left}).len == 0) || builtin__fast_string_eq(${left}, ${right}))'
	}
}

@[inline]
fn (mut g Gen) eq_fn_key(typ ast.Type) ast.Type {
	return g.unwrap_generic(typ).set_nr_muls(0)
}

fn (mut g Gen) gen_equality_fns() {
	for needed_typ in g.needed_equality_fns {
		eq_key := g.eq_fn_key(needed_typ)
		if eq_key in g.generated_eq_fns {
			continue
		}
		sym := g.table.sym(eq_key)
		match sym.kind {
			.sum_type {
				g.gen_sumtype_equality_fn(eq_key)
			}
			.struct {
				g.gen_struct_equality_fn(eq_key)
			}
			.array {
				g.gen_array_equality_fn(eq_key)
			}
			.array_fixed {
				g.gen_fixed_array_equality_fn(eq_key)
			}
			.map {
				g.gen_map_equality_fn(eq_key)
			}
			.alias {
				g.gen_alias_equality_fn(eq_key)
			}
			.interface {
				g.gen_interface_equality_fn(eq_key)
			}
			else {
				verror('could not generate equality function for type ${sym.kind}')
			}
		}
	}
}

fn (mut g Gen) gen_sumtype_equality_fn(left_type ast.Type) string {
	left := g.unwrap(left_type)
	ptr_styp := g.styp(left.typ.set_nr_muls(0))

	left_no_ptr := g.eq_fn_key(left_type)
	if left_no_ptr in g.generated_eq_fns {
		return ptr_styp
	}
	g.generated_eq_fns << left_no_ptr

	info := left.sym.sumtype_info()
	g.definitions.writeln('${g.static_non_parallel}bool ${ptr_styp}_sumtype_eq(${ptr_styp} a, ${ptr_styp} b);')

	left_typ := g.read_field(left_type, '_typ', 'a')
	right_typ := g.read_field(left_type, '_typ', 'b')

	mut fn_builder := strings.new_builder(512)
	fn_builder.writeln('${g.static_non_parallel}inline bool ${ptr_styp}_sumtype_eq(${ptr_styp} a, ${ptr_styp} b) {')
	fn_builder.writeln('\tif (${left_typ} != ${right_typ}) { return false; }')
	fn_builder.writeln('\tif (${left_typ} == ${right_typ} && ${right_typ} == 0) { return true; } // uninitialized')
	for typ in info.variants {
		variant := g.unwrap(typ)
		fn_builder.writeln('\tif (${left_typ} == ${int(variant.typ)}) {')
		name := '_${g.get_sumtype_variant_name(variant.typ, variant.sym)}'

		left_arg := g.read_field(left_type, name, 'a')
		right_arg := g.read_field(left_type, name, 'b')

		if variant.typ.has_flag(.option) {
			fn_builder.writeln('\t\treturn ((*${left_arg}).state == 2 && (*${right_arg}).state == 2) || !memcmp(&(*${left_arg}).data, &(*${right_arg}).data, sizeof(${g.base_type(variant.typ)}));')
		} else if variant.sym.kind == .string {
			fn_builder.writeln('\t\treturn builtin__string__eq(*${left_arg}, *${right_arg});')
		} else if variant.sym.kind == .sum_type && !typ.is_ptr() {
			eq_fn := g.gen_sumtype_equality_fn(typ)
			fn_builder.writeln('\t\treturn ${eq_fn}_sumtype_eq(*${left_arg}, *${right_arg});')
		} else if variant.sym.kind == .struct && !typ.is_ptr() {
			eq_fn := g.gen_struct_equality_fn(typ)
			fn_builder.writeln('\t\treturn ${eq_fn}_struct_eq(*${left_arg}, *${right_arg});')
		} else if variant.sym.kind == .array && !typ.is_ptr() {
			eq_fn := g.gen_array_equality_fn(typ)
			fn_builder.writeln('\t\treturn ${eq_fn}_arr_eq(*${left_arg}, *${right_arg});')
		} else if variant.sym.kind == .array_fixed && !typ.is_ptr() {
			eq_fn := g.gen_fixed_array_equality_fn(typ)
			fn_builder.writeln('\t\treturn ${eq_fn}_arr_eq(*${left_arg}, *${right_arg});')
		} else if variant.sym.kind == .map && !typ.is_ptr() {
			eq_fn := g.gen_map_equality_fn(typ)
			fn_builder.writeln('\t\treturn ${eq_fn}_map_eq(*${left_arg}, *${right_arg});')
		} else if variant.sym.kind == .alias && !typ.is_ptr() {
			if g.no_eq_method_types[typ] {
				fn_builder.writeln('\t\treturn *${left_arg} == *${right_arg};')
			} else {
				eq_fn := g.gen_alias_equality_fn(typ)
				fn_builder.writeln('\t\treturn ${eq_fn}_alias_eq(*${left_arg}, *${right_arg});')
			}
		} else if variant.sym.kind == .function {
			fn_builder.writeln('\t\treturn *((voidptr*)(*${left_arg})) == *((voidptr*)(*${right_arg}));')
		} else {
			fn_builder.writeln('\t\treturn *${left_arg} == *${right_arg};')
		}
		fn_builder.writeln('\t}')
	}
	fn_builder.writeln('\treturn false;')
	fn_builder.writeln('}')
	g.auto_fn_definitions << fn_builder.str()
	return ptr_styp
}

// read_opt generates C code accessing option data
@[inline]
fn (mut g Gen) read_opt(typ ast.Type, var_name string) string {
	return '(${g.base_type(typ)}*)${var_name}.data'
}

// read_field generates C code for reading option/no-option struct field
@[inline]
fn (mut g Gen) read_field(struct_type ast.Type, field_name string, var_name string) string {
	return if struct_type.has_flag(.option) {
		'(${g.read_opt(struct_type, var_name)})->${field_name}'
	} else {
		'${var_name}.${field_name}'
	}
}

// read_map generates C code for reading option/no-option struct field
@[inline]
fn (mut g Gen) read_map_from_option(typ ast.Type, var_name string) string {
	return if typ.has_flag(.option) {
		return '(${g.base_type(typ)}*)&${var_name}.data'
	} else {
		var_name
	}
}

// read_map_field generates C code for reading option/no-option struct field
@[inline]
fn (mut g Gen) read_map_field_from_option(typ ast.Type, field_name string, var_name string) string {
	return if typ.has_flag(.option) {
		'(*(${g.base_type(typ)}*)${var_name}.data).${field_name}'
	} else {
		'${var_name}.${field_name}'
	}
}

// read_opt_field generates C code for reading option/no-option struct field
@[inline]
fn (mut g Gen) read_opt_field(struct_type ast.Type, field_name string, var_name string, field_typ ast.Type) string {
	return if field_typ.has_flag(.option) {
		'*(${g.base_type(field_typ)}*)${g.read_field(struct_type, field_name, var_name)}.data'
	} else {
		g.read_field(struct_type, field_name, var_name)
	}
}

// read_map_opt_field generates C code for reading option/no-option map field
@[inline]
fn (mut g Gen) read_map_opt_field(struct_type ast.Type, field_name string, var_name string, field_typ ast.Type) string {
	return if field_typ.has_flag(.option) {
		'*(${g.base_type(field_typ)}*)${g.read_field(struct_type, field_name, var_name)}.data'
	} else {
		g.read_field(struct_type, field_name, var_name)
	}
}

fn (mut g Gen) gen_struct_equality_fn(left_type ast.Type) string {
	left := g.unwrap(left_type)
	ptr_styp := g.styp(left.typ.set_nr_muls(0))
	fn_name := ptr_styp.replace('struct ', '')

	left_no_ptr := g.eq_fn_key(left_type)
	if left_no_ptr in g.generated_eq_fns {
		return fn_name
	}
	g.generated_eq_fns << left_no_ptr

	info := left.sym.struct_info()
	if left.sym.language == .c && info.fields.len == 0 {
		g.definitions.writeln('#define ${fn_name}_struct_eq(a, b) (false)')
		return fn_name
	}
	g.definitions.writeln('${g.static_non_parallel}bool ${fn_name}_struct_eq(${ptr_styp} a, ${ptr_styp} b);')

	mut fn_builder := strings.new_builder(512)
	defer {
		g.auto_fn_definitions << fn_builder.str()
	}
	fn_builder.writeln('${g.static_non_parallel}inline bool ${fn_name}_struct_eq(${ptr_styp} a, ${ptr_styp} b) {')

	// overloaded
	if left.sym.has_method('==') {
		if left.typ.has_flag(.option) {
			opt_ptr_styp := g.styp(left.typ.set_nr_muls(0).clear_flag(.option))
			opt_fn_name := opt_ptr_styp.replace('struct ', '')
			fn_builder.writeln('\treturn (a.state == b.state && b.state == 2) || ${opt_fn_name}__eq(*(${opt_ptr_styp}*)a.data, *(${opt_ptr_styp}*)b.data);')
		} else {
			fn_builder.writeln('\treturn ${fn_name}__eq(a, b);')
		}
		fn_builder.writeln('}')
		return fn_name
	}

	fn_builder.write_string('\treturn ')
	if info.fields.len > 0 {
		for i, field in info.fields {
			if i > 0 {
				fn_builder.write_string('\n\t\t&& ')
			}
			field_type := g.unwrap(field.typ)
			field_name := c_name(field.name)

			mut left_arg := g.read_field(left_type, field_name, 'a')
			mut right_arg := g.read_field(left_type, field_name, 'b')

			if field.typ.has_flag(.option) {
				fn_builder.write_string('((${left_arg}.state == ${right_arg}.state && ${right_arg}.state == 2) || (${left_arg}.state != 2 && ${right_arg}.state != 2 && (')
			}
			if field_type.sym.kind == .string {
				if field.typ.has_flag(.option) {
					left_arg = g.read_opt_field(left_type, field_name, 'a', field.typ)
					right_arg = g.read_opt_field(left_type, field_name, 'b', field.typ)
				}

				if field.typ.is_ptr() {
					fn_builder.write_string('(${left_arg} == ${right_arg} || (${left_arg} != 0 &&  ${right_arg} != 0 && ((${left_arg})->len == (${right_arg})->len && (${left_arg})->len == 0) || builtin__fast_string_eq(*(${left_arg}), *(${right_arg}))))')
				} else {
					fn_builder.write_string('(((${left_arg}).len == (${right_arg}).len && (${left_arg}).len == 0) || builtin__fast_string_eq(${left_arg}, ${right_arg}))')
				}
			} else if field_type.sym.kind == .sum_type && !field.typ.is_ptr() {
				eq_fn := g.gen_sumtype_equality_fn(field.typ)
				fn_builder.write_string('${eq_fn}_sumtype_eq(${left_arg}, ${right_arg})')
			} else if field_type.sym.kind == .struct && !field.typ.is_ptr() {
				eq_fn := g.gen_struct_equality_fn(field.typ)
				if field_type.sym.struct_info().is_anon && !field.typ.has_flag(.option)
					&& !field.typ.has_flag(.shared_f) {
					styp := g.styp(field.typ)
					fn_name_ := styp.replace('struct ', '')
					fn_builder.write_string('${eq_fn}_struct_eq(*(${fn_name_}*)&(${left_arg}), *(${fn_name_}*)&(${right_arg}))')
				} else {
					fn_builder.write_string('${eq_fn}_struct_eq(${left_arg}, ${right_arg})')
				}
			} else if field_type.sym.kind == .array && !field.typ.is_ptr() {
				eq_fn := g.gen_array_equality_fn(field.typ)
				fn_builder.write_string('${eq_fn}_arr_eq(${left_arg}, ${right_arg})')
			} else if field_type.sym.kind == .array_fixed && !field.typ.is_ptr() {
				eq_fn := g.gen_fixed_array_equality_fn(field.typ)
				fn_builder.write_string('${eq_fn}_arr_eq(${left_arg}, ${right_arg})')
			} else if field_type.sym.kind == .map && !field.typ.is_ptr() {
				eq_fn := g.gen_map_equality_fn(field.typ)
				fn_builder.write_string('${eq_fn}_map_eq(${left_arg}, ${right_arg})')
			} else if field_type.sym.kind == .alias && !field.typ.is_ptr() {
				if g.no_eq_method_types[field.typ] {
					fn_builder.write_string('${left_arg} == ${right_arg}')
				} else {
					eq_fn := g.gen_alias_equality_fn(field.typ)
					fn_builder.write_string('${eq_fn}_alias_eq(${left_arg}, ${right_arg})')
				}
			} else if field_type.sym.kind == .function && !field.typ.has_flag(.option) {
				fn_builder.write_string('((voidptr*)(${left_arg})) == ((voidptr*)(${right_arg}))')
			} else if field_type.sym.kind == .interface
				&& (!field.typ.has_flag(.option) || !field.typ.is_ptr()) {
				ptr := if field.typ.is_ptr() { '*'.repeat(field.typ.nr_muls()) } else { '' }
				eq_fn := g.gen_interface_equality_fn(field.typ)
				if ptr != '' {
					fn_builder.write_string('((${left_arg} == (void*)0 && ${right_arg} == (void*)0) || (${left_arg} != (void*)0 && ${right_arg} != (void*)0 && ')
				}
				fn_builder.write_string('${eq_fn}_interface_eq(${ptr}${left_arg}, ${ptr}${right_arg})')
				if ptr != '' {
					fn_builder.write_string('))')
				}
			} else if field.typ.has_flag(.option) {
				fn_builder.write_string('!memcmp(&${left_arg}.data, &${right_arg}.data, sizeof(${g.base_type(field.typ)}))')
			} else {
				fn_builder.write_string('${left_arg} == ${right_arg}')
			}
			if field.typ.has_flag(.option) {
				fn_builder.write_string(')))')
			}
		}
	} else {
		fn_builder.write_string('true')
	}
	fn_builder.writeln(';')
	fn_builder.writeln('}')
	return fn_name
}

fn (mut g Gen) gen_alias_equality_fn(left_type ast.Type) string {
	left := g.unwrap(left_type)
	ptr_styp := g.styp(left.typ.set_nr_muls(0))

	left_no_ptr := g.eq_fn_key(left_type)
	if left_no_ptr in g.generated_eq_fns {
		return ptr_styp
	}
	g.generated_eq_fns << left_no_ptr

	info := left.sym.info as ast.Alias
	g.definitions.writeln('${g.static_non_parallel}bool ${ptr_styp}_alias_eq(${ptr_styp} a, ${ptr_styp} b);')

	mut fn_builder := strings.new_builder(512)
	fn_builder.writeln('${g.static_non_parallel}inline bool ${ptr_styp}_alias_eq(${ptr_styp} a, ${ptr_styp} b) {')

	is_option := left.typ.has_flag(.option)

	mut left_var := if is_option { '*' + g.read_opt(info.parent_type, 'a') } else { 'a' }
	mut right_var := if is_option { '*' + g.read_opt(info.parent_type, 'b') } else { 'b' }

	sym := g.table.sym(info.parent_type)
	if sym.kind == .string {
		if info.parent_type.has_flag(.option) {
			left_var = '*' + g.read_opt(info.parent_type, 'a')
			right_var = '*' + g.read_opt(info.parent_type, 'b')
			fn_builder.writeln('\treturn ((${left_var}).len == (${right_var}).len && (${left_var}).len == 0) || builtin__fast_string_eq(${left_var}, ${right_var});')
		} else {
			fn_builder.writeln('\treturn builtin__string__eq(a, b);')
		}
	} else if sym.kind == .sum_type && !left.typ.is_ptr() {
		eq_fn := g.gen_sumtype_equality_fn(info.parent_type)
		fn_builder.writeln('\treturn ${eq_fn}_sumtype_eq(${left_var}, ${right_var});')
	} else if sym.kind == .struct && !left.typ.is_ptr() {
		eq_fn := g.gen_struct_equality_fn(info.parent_type)
		fn_builder.writeln('\treturn ${eq_fn}_struct_eq(${left_var}, ${right_var});')
	} else if sym.kind == .interface && !left.typ.is_ptr() {
		eq_fn := g.gen_interface_equality_fn(info.parent_type)
		fn_builder.writeln('\treturn ${eq_fn}_interface_eq(${left_var}, ${right_var});')
	} else if sym.kind == .array && !left.typ.is_ptr() {
		eq_fn := g.gen_array_equality_fn(info.parent_type)
		fn_builder.writeln('\treturn ${eq_fn}_arr_eq(${left_var}, ${right_var});')
	} else if sym.kind == .array_fixed && !left.typ.is_ptr() {
		eq_fn := g.gen_fixed_array_equality_fn(info.parent_type)
		fn_builder.writeln('\treturn ${eq_fn}_arr_eq(${left_var}, ${right_var});')
	} else if sym.kind == .map && !left.typ.is_ptr() {
		eq_fn := g.gen_map_equality_fn(info.parent_type)
		fn_builder.writeln('\treturn ${eq_fn}_map_eq(${left_var}, ${right_var});')
	} else if sym.kind == .function && !left.typ.has_flag(.option) {
		fn_builder.writeln('\treturn *((voidptr*)(a)) == *((voidptr*)(b));')
	} else if info.parent_type.has_flag(.option) || left.typ.has_flag(.option) {
		fn_builder.writeln('\treturn a.state == b.state && !memcmp(&a.data, &b.data, sizeof(${g.base_type(info.parent_type)}));')
	} else {
		fn_builder.writeln('\treturn a == b;')
	}
	fn_builder.writeln('}')
	g.auto_fn_definitions << fn_builder.str()
	return ptr_styp
}

fn (mut g Gen) gen_array_equality_fn(left_type ast.Type) string {
	left := g.unwrap(left_type)
	ptr_styp := g.styp(left.typ.set_nr_muls(0))

	left_no_ptr := g.eq_fn_key(left_type)
	if left_no_ptr in g.generated_eq_fns {
		return ptr_styp
	}
	g.generated_eq_fns << left_no_ptr

	elem := g.unwrap(left.sym.array_info().elem_type)
	ptr_elem_styp := g.styp(elem.typ)
	g.definitions.writeln('${g.static_non_parallel}bool ${ptr_styp}_arr_eq(${ptr_styp} a, ${ptr_styp} b);')

	mut fn_builder := strings.new_builder(512)
	fn_builder.writeln('${g.static_non_parallel}inline bool ${ptr_styp}_arr_eq(${ptr_styp} a, ${ptr_styp} b) {')

	left_len := g.read_field(left_type, 'len', 'a')
	right_len := g.read_field(left_type, 'len', 'b')

	left_data := g.read_field(left_type, 'data', 'a')
	right_data := g.read_field(left_type, 'data', 'b')

	left_elem := g.read_field(left_type, 'element_size', 'a')
	right_elem := g.read_field(left_type, 'element_size', 'b')

	if left_type.has_flag(.option) {
		fn_builder.writeln('\tif (a.state != b.state) return false;')
		fn_builder.writeln('\tif (a.state == 2 && a.state == b.state) return true;')
	}

	fn_builder.writeln('\tif (${left_len} != ${right_len}) {')
	fn_builder.writeln('\t\treturn false;')
	fn_builder.writeln('\t}')
	fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < ${left_len}; ++i) {')
	// compare every pair of elements of the two arrays
	if elem.sym.kind == .string {
		left_arg := '*((${ptr_elem_styp}*)((byte*)${left_data}+(i*${left_elem})))'
		right_arg := '*((${ptr_elem_styp}*)((byte*)${right_data}+(i*${right_elem})))'
		fn_builder.writeln('\t\tif (!${string_eq_expr(left_arg, right_arg, elem.typ.is_ptr())}) {')
	} else if elem.sym.kind == .sum_type && !elem.typ.is_ptr() {
		eq_fn := g.gen_sumtype_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_sumtype_eq(((${ptr_elem_styp}*)${left_data})[i], ((${ptr_elem_styp}*)${right_data})[i])) {')
	} else if elem.sym.kind == .struct && !elem.typ.is_ptr() {
		eq_fn := g.gen_struct_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_struct_eq(((${ptr_elem_styp}*)${left_data})[i], ((${ptr_elem_styp}*)${right_data})[i])) {')
	} else if elem.sym.kind == .interface && !elem.typ.is_ptr() {
		eq_fn := g.gen_interface_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_interface_eq(((${ptr_elem_styp}*)${left_data})[i], ((${ptr_elem_styp}*)${right_data})[i])) {')
	} else if elem.sym.kind == .array && !elem.typ.is_ptr() {
		eq_fn := g.gen_array_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_arr_eq(((${ptr_elem_styp}*)${left_data})[i], ((${ptr_elem_styp}*)${right_data})[i])) {')
	} else if elem.sym.kind == .array_fixed && !elem.typ.is_ptr() {
		eq_fn := g.gen_fixed_array_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_arr_eq(((${ptr_elem_styp}*)${left_data})[i], ((${ptr_elem_styp}*)${right_data})[i])) {')
	} else if elem.sym.kind == .map && !elem.typ.is_ptr() {
		eq_fn := g.gen_map_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_map_eq(((${ptr_elem_styp}*)${left_data})[i], ((${ptr_elem_styp}*)${right_data})[i])) {')
	} else if elem.sym.kind == .alias && !elem.typ.is_ptr() {
		if g.no_eq_method_types[elem.typ] {
			fn_builder.writeln('\t\tif (((${ptr_elem_styp}*)${left_data})[i] != ((${ptr_elem_styp}*)${right_data})[i]) {')
		} else {
			eq_fn := g.gen_alias_equality_fn(elem.typ)
			fn_builder.writeln('\t\tif (!${eq_fn}_alias_eq(((${ptr_elem_styp}*)${left_data})[i], ((${ptr_elem_styp}*)${right_data})[i])) {')
		}
	} else if elem.sym.kind == .function {
		fn_builder.writeln('\t\tif (*((voidptr*)((byte*)${left_data}+(i*${left_elem}))) != *((voidptr*)((byte*)${right_data}+(i*${right_elem})))) {')
	} else {
		if elem.typ.has_flag(.option) {
			fn_builder.writeln('\t\t${ptr_elem_styp}* left = ((${ptr_elem_styp}*)${left_data})+(i*${left_elem});')
			fn_builder.writeln('\t\t${ptr_elem_styp}* right = ((${ptr_elem_styp}*)${right_data})+(i*${right_elem});')
			fn_builder.writeln('\t\tif (!(left->state == 2 && left->state == right->state) && memcmp(left->data, right->data, sizeof(${g.base_type(elem.typ)}))) {')
		} else {
			fn_builder.writeln('\t\tif (*((${ptr_elem_styp}*)((byte*)${left_data}+(i*${left_elem}))) != *((${ptr_elem_styp}*)((byte*)${right_data}+(i*${right_elem})))) {')
		}
	}
	fn_builder.writeln('\t\t\treturn false;')
	fn_builder.writeln('\t\t}')
	fn_builder.writeln('\t}')
	fn_builder.writeln('\treturn true;')
	fn_builder.writeln('}')
	g.auto_fn_definitions << fn_builder.str()
	return ptr_styp
}

fn (mut g Gen) gen_fixed_array_equality_fn(left_type ast.Type) string {
	left_typ := g.unwrap(left_type)
	ptr_styp := g.styp(left_typ.typ.set_nr_muls(0))

	left_no_ptr := g.eq_fn_key(left_type)
	if left_no_ptr in g.generated_eq_fns {
		return ptr_styp
	}
	g.generated_eq_fns << left_no_ptr

	elem_info := left_typ.sym.array_fixed_info()
	elem := g.unwrap(elem_info.elem_type)
	ptr_elem_styp := g.styp(elem.typ)
	size := elem_info.size
	mut arg_styp := ptr_styp
	if elem_info.is_fn_ret {
		arg_styp = ptr_styp[3..] // removes the _v_ prefix for returning fixed array
	}
	g.definitions.writeln('${g.static_non_parallel}bool ${ptr_styp}_arr_eq(${arg_styp} a, ${arg_styp} b);')

	is_option := left_type.has_flag(.option)
	left_item := if is_option { '((${ptr_elem_styp}*)a.data)' } else { 'a' }
	right_item := if is_option { '((${ptr_elem_styp}*)b.data)' } else { 'b' }

	mut fn_builder := strings.new_builder(512)
	fn_builder.writeln('${g.static_non_parallel}inline bool ${ptr_styp}_arr_eq(${arg_styp} a, ${arg_styp} b) {')
	if is_option {
		fn_builder.writeln('\tif (a.state != b.state) return false;')
		fn_builder.writeln('\tif (a.state == 2 && a.state == b.state) return true;')
	}
	if left_typ.sym.is_primitive_fixed_array() {
		suffix := if is_option { '.data' } else { '[0]' }
		size_styp := if is_option {
			g.base_type(left_typ.typ.set_nr_muls(0))
		} else {
			arg_styp
		}
		fn_builder.writeln('\tif (!memcmp(&a${suffix}, &b${suffix}, sizeof(${size_styp}))) {')
		fn_builder.writeln('\t\treturn true;')
		fn_builder.writeln('\t}')
	}
	fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < ${size}; ++i) {')
	// compare every pair of elements of the two fixed arrays
	if elem.sym.kind == .string {
		left_arg := '${left_item}[i]'
		right_arg := '${right_item}[i]'
		fn_builder.writeln('\t\tif (!${string_eq_expr(left_arg, right_arg, elem.typ.is_ptr())}) {')
	} else if elem.sym.kind == .sum_type && !elem.typ.is_ptr() {
		eq_fn := g.gen_sumtype_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_sumtype_eq(${left_item}[i], ${right_item}[i])) {')
	} else if elem.sym.kind == .struct && !elem.typ.is_ptr() {
		eq_fn := g.gen_struct_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_struct_eq(${left_item}[i], ${right_item}[i])) {')
	} else if elem.sym.kind == .interface && !elem.typ.is_ptr() {
		eq_fn := g.gen_interface_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_interface_eq(${left_item}[i], ${right_item}[i])) {')
	} else if elem.sym.kind == .array && !elem.typ.is_ptr() {
		eq_fn := g.gen_array_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_arr_eq(${left_item}[i], ${right_item}[i])) {')
	} else if elem.sym.kind == .array_fixed && !elem.typ.is_ptr() {
		eq_fn := g.gen_fixed_array_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_arr_eq(${left_item}[i], ${right_item}[i])) {')
	} else if elem.sym.kind == .map && !elem.typ.is_ptr() {
		eq_fn := g.gen_map_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_map_eq(${left_item}[i], ${right_item}[i])) {')
	} else if elem.sym.kind == .alias && !elem.typ.is_ptr() {
		eq_fn := g.gen_alias_equality_fn(elem.typ)
		fn_builder.writeln('\t\tif (!${eq_fn}_alias_eq(${left_item}[i], ${right_item}[i])) {')
	} else if elem.sym.kind == .function {
		fn_builder.writeln('\t\tif (${left_item}[i] != ${right_item}[i]) {')
	} else {
		fn_builder.writeln('\t\tif (${left_item}[i] != ${right_item}[i]) {')
	}
	fn_builder.writeln('\t\t\treturn false;')
	fn_builder.writeln('\t\t}')
	fn_builder.writeln('\t}')
	fn_builder.writeln('\treturn true;')
	fn_builder.writeln('}')
	g.auto_fn_definitions << fn_builder.str()
	return ptr_styp
}

fn (mut g Gen) gen_map_equality_fn(left_type ast.Type) string {
	left := g.unwrap(left_type)
	ptr_styp := g.styp(left.typ.set_nr_muls(0))

	left_no_ptr := g.eq_fn_key(left_type)
	if left_no_ptr in g.generated_eq_fns {
		return ptr_styp
	}
	g.generated_eq_fns << left_no_ptr

	value := g.unwrap(left.sym.map_info().value_type)
	ptr_value_styp := g.styp(value.typ)
	g.definitions.writeln('${g.static_non_parallel}bool ${ptr_styp}_map_eq(${ptr_styp} a, ${ptr_styp} b);')

	left_len := g.read_map_field_from_option(left.typ, 'len', 'a')
	right_len := g.read_map_field_from_option(left.typ, 'len', 'b')
	key_values := g.read_map_field_from_option(left.typ, 'key_values', 'a')

	a := if left.typ.has_flag(.option) { g.read_map_from_option(left.typ, 'a') } else { '&a' }
	b := if left.typ.has_flag(.option) { g.read_map_from_option(left.typ, 'b') } else { '&b' }

	mut fn_builder := strings.new_builder(512)
	fn_builder.writeln('${g.static_non_parallel}inline bool ${ptr_styp}_map_eq(${ptr_styp} a, ${ptr_styp} b) {')
	fn_builder.writeln('\tif (${left_len} != ${right_len}) {')
	fn_builder.writeln('\t\treturn false;')
	fn_builder.writeln('\t}')
	fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < ${key_values}.len; ++i) {')
	fn_builder.writeln('\t\tif (!builtin__DenseArray_has_index(&${key_values}, i)) continue;')
	fn_builder.writeln('\t\tvoidptr k = builtin__DenseArray_key(&${key_values}, i);')
	fn_builder.writeln('\t\tif (!builtin__map_exists(${b}, k)) return false;')
	sym := g.table.sym(value.typ)
	kind := g.table.type_kind(value.typ)
	initializer := if !(sym.info is ast.Struct && sym.info.is_empty_struct()) { '0' } else { '' }
	if kind == .function {
		info := value.sym.info as ast.FnType
		sig := g.fn_var_signature(ast.void_type, info.func.return_type,
			info.func.params.map(it.typ), 'v')
		fn_builder.writeln('\t\t${sig} = *(voidptr*)builtin__map_get(${a}, k, &(voidptr[]){ 0 });')
	} else {
		fn_builder.writeln('\t\t${ptr_value_styp} v = *(${ptr_value_styp}*)builtin__map_get(${a}, k, &(${ptr_value_styp}[]){ ${initializer} });')
	}
	match kind {
		.string {
			fn_builder.writeln('\t\tif (!builtin__fast_string_eq(*(string*)builtin__map_get(${b}, k, &(string[]){_S("")}), v)) {')
		}
		.sum_type {
			eq_fn := g.gen_sumtype_equality_fn(value.typ)
			fn_builder.writeln('\t\tif (!${eq_fn}_sumtype_eq(*(${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ 0 }), v)) {')
		}
		.struct {
			eq_fn := g.gen_struct_equality_fn(value.typ)
			fn_builder.writeln('\t\tif (!${eq_fn}_struct_eq(*(${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ ${initializer} }), v)) {')
		}
		.interface {
			eq_fn := g.gen_interface_equality_fn(value.typ)
			fn_builder.writeln('\t\tif (!${eq_fn}_interface_eq(*(${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ 0 }), v)) {')
		}
		.array {
			eq_fn := g.gen_array_equality_fn(value.typ)
			fn_builder.writeln('\t\tif (!${eq_fn}_arr_eq(*(${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ 0 }), v)) {')
		}
		.array_fixed {
			eq_fn := g.gen_fixed_array_equality_fn(value.typ)
			fn_builder.writeln('\t\tif (!${eq_fn}_arr_eq(*(${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ 0 }), v)) {')
		}
		.map {
			eq_fn := g.gen_map_equality_fn(value.typ)
			fn_builder.writeln('\t\tif (!${eq_fn}_map_eq(*(${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ 0 }), v)) {')
		}
		.alias {
			eq_fn := g.gen_alias_equality_fn(value.typ)
			fn_builder.writeln('\t\tif (!${eq_fn}_alias_eq(*(${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ 0 }), v)) {')
		}
		.function {
			fn_builder.writeln('\t\tif (*(voidptr*)builtin__map_get(${b}, k, &(voidptr[]){ 0 }) != v) {')
		}
		else {
			if value.typ.has_flag(.option) {
				// For option types, use the unaliased type to get the correct sizeof
				unaliased_typ := g.table.unaliased_type(value.typ)
				fn_builder.writeln('\t\tif (memcmp(v.data, ((${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ 0 }))->data, sizeof(${g.base_type(unaliased_typ)})) != 0) {')
			} else {
				fn_builder.writeln('\t\tif (*(${ptr_value_styp}*)builtin__map_get(${b}, k, &(${ptr_value_styp}[]){ 0 }) != v) {')
			}
		}
	}

	fn_builder.writeln('\t\t\treturn false;')
	fn_builder.writeln('\t\t}')
	fn_builder.writeln('\t}')
	fn_builder.writeln('\treturn true;')
	fn_builder.writeln('}')
	g.auto_fn_definitions << fn_builder.str()
	return ptr_styp
}

fn (mut g Gen) gen_interface_equality_fn(left_type ast.Type) string {
	left := g.unwrap(left_type)
	ptr_styp := g.styp(left.typ.set_nr_muls(0))
	idx_fn := g.styp(left.typ.set_nr_muls(0).clear_flag(.option))
	fn_name := ptr_styp.replace('interface ', '')

	left_no_ptr := g.eq_fn_key(left_type)
	if left_no_ptr in g.generated_eq_fns {
		return fn_name
	}
	g.generated_eq_fns << left_no_ptr

	info := left.sym.info
	g.definitions.writeln('${g.static_non_parallel}bool ${ptr_styp}_interface_eq(${ptr_styp} a, ${ptr_styp} b);')

	mut fn_builder := strings.new_builder(512)
	defer {
		g.auto_fn_definitions << fn_builder.str()
	}

	left_arg := g.read_field(left_type, '_typ', 'a')
	right_arg := g.read_field(left_type, '_typ', 'b')

	fn_builder.writeln('${g.static_non_parallel}inline bool ${fn_name}_interface_eq(${ptr_styp} a, ${ptr_styp} b) {')
	fn_builder.writeln('\tif (${left_arg} == ${right_arg}) {')
	fn_builder.writeln('\t\tu32 idx = v_typeof_interface_idx_${idx_fn}(${left_arg});')
	if info is ast.Interface {
		for typ in info.types {
			sym := g.table.sym(typ.set_nr_muls(0))
			if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
				continue
			}
			fn_builder.writeln('\t\tif (idx == ${typ.idx()}) {')
			fn_builder.write_string('\t\t\treturn ')
			match sym.kind {
				.struct {
					eq_fn := g.gen_struct_equality_fn(typ)
					l_eqfn := g.read_field(left_type, '_${eq_fn}', 'a')
					r_eqfn := g.read_field(left_type, '_${eq_fn}', 'b')
					fn_builder.write_string('${eq_fn}_struct_eq(*(${l_eqfn}), *(${r_eqfn}))')
				}
				.string {
					l_str := g.read_field(left_type, '_string', 'a')
					r_str := g.read_field(left_type, '_string', 'b')
					fn_builder.write_string('builtin__string__eq(*(${l_str}), *(${r_str}))')
				}
				.sum_type {
					eq_fn := g.gen_sumtype_equality_fn(typ)
					l_eqfn := g.read_field(left_type, '_${eq_fn}', 'a')
					r_eqfn := g.read_field(left_type, '_${eq_fn}', 'b')
					fn_builder.write_string('${eq_fn}_sumtype_eq(*(${l_eqfn}), *(${r_eqfn}))')
				}
				.array {
					eq_fn := g.gen_array_equality_fn(typ)
					l_eqfn := g.read_field(left_type, '_${eq_fn}', 'a')
					r_eqfn := g.read_field(left_type, '_${eq_fn}', 'b')
					fn_builder.write_string('${eq_fn}_arr_eq(*(${l_eqfn}), *(${r_eqfn}))')
				}
				.array_fixed {
					eq_fn := g.gen_fixed_array_equality_fn(typ)
					l_eqfn := g.read_field(left_type, '_${eq_fn}', 'a')
					r_eqfn := g.read_field(left_type, '_${eq_fn}', 'b')
					fn_builder.write_string('${eq_fn}_arr_eq(*(${l_eqfn}), *(${r_eqfn}))')
				}
				.map {
					eq_fn := g.gen_map_equality_fn(typ)
					l_eqfn := g.read_field(left_type, '_${eq_fn}', 'a')
					r_eqfn := g.read_field(left_type, '_${eq_fn}', 'b')
					fn_builder.write_string('${eq_fn}_map_eq(*(${l_eqfn}), *(${r_eqfn}))')
				}
				.alias {
					eq_fn := g.gen_alias_equality_fn(typ)
					l_eqfn := g.read_field(left_type, '_${eq_fn}', 'a')
					r_eqfn := g.read_field(left_type, '_${eq_fn}', 'b')
					fn_builder.write_string('${eq_fn}_alias_eq(*(${l_eqfn}), *(${r_eqfn}))')
				}
				else {
					fn_builder.write_string('true')
				}
			}

			fn_builder.writeln(';')
			fn_builder.writeln('\t\t}')
		}
	}
	fn_builder.writeln('\t}')
	fn_builder.writeln('\treturn false;')
	fn_builder.writeln('}')

	return fn_name
}