// 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 v.ast
import strings

@[inline]
fn (mut g Gen) register_free_method(typ ast.Type) {
	if g.type_has_unresolved_generic_parts(typ) {
		return
	}
	if typ.has_flag(.shared_f) {
		g.get_free_method(typ.clear_flag(.shared_f).set_nr_muls(0))
	} else {
		g.get_free_method(typ)
	}
}

fn (mut g Gen) get_free_method(typ ast.Type) string {
	if typ in g.autofree_methods {
		return g.autofree_methods[typ]
	}
	mut sym := g.table.sym(g.unwrap_generic(typ))
	if mut sym.info is ast.Alias {
		if sym.info.is_import {
			sym = g.table.sym(sym.info.parent_type)
		}
	}
	styp := g.styp(typ).replace('*', '')
	fn_name := styp_to_free_fn_name(styp)
	if sym.has_method_with_generic_parent('free') {
		g.autofree_methods[typ] = fn_name
		return fn_name
	}
	g.autofree_methods[typ] = fn_name
	return fn_name
}

fn (mut g Gen) gen_free_methods() {
	for typ, _ in g.autofree_methods {
		if g.type_has_unresolved_generic_parts(typ) {
			continue
		}
		g.gen_free_method(typ)
	}
}

fn (mut g Gen) gen_free_method(typ ast.Type) string {
	styp := g.styp(typ).replace('*', '')
	mut fn_name := styp_to_free_fn_name(styp)
	if g.type_has_unresolved_generic_parts(typ) {
		return fn_name
	}
	deref_typ := if typ.has_flag(.option) { typ } else { typ.set_nr_muls(0) }
	if deref_typ in g.generated_free_methods {
		return fn_name
	}
	// Also check by C function name to prevent duplicate definitions when
	// different type IDs map to the same C name (e.g. nested array types).
	if fn_name in g.generated_free_fn_names {
		return fn_name
	}
	g.generated_free_methods[deref_typ] = true
	g.generated_free_fn_names[fn_name] = true

	objtyp := g.unwrap_generic(typ)
	mut sym := g.table.sym(objtyp)
	if mut sym.info is ast.Alias {
		if sym.info.is_import {
			sym = g.table.sym(sym.info.parent_type)
		}
	}
	if sym.kind != .interface && sym.has_method_with_generic_parent('free') {
		return fn_name
	}

	match mut sym.info {
		ast.Struct {
			g.gen_free_for_struct(objtyp, sym.info, styp, fn_name, sym.is_builtin())
		}
		ast.Array {
			g.gen_free_for_array(sym.info, styp, fn_name)
		}
		ast.Map {
			g.gen_free_for_map(objtyp, styp, fn_name)
		}
		ast.Interface {
			g.gen_free_for_interface(sym, sym.info, styp, fn_name)
		}
		ast.SumType {
			g.gen_free_for_sumtype(sym.info, styp, fn_name)
		}
		else {
			println(g.table.type_str(typ))
			// print_backtrace()
			println("could not generate free method '${fn_name}' for type '${styp}'")
			// verror("could not generate free method '${fn_name}' for type '${styp}'")
		}
	}

	return fn_name
}

fn (mut g Gen) gen_free_for_interface(sym ast.TypeSymbol, info ast.Interface, styp string, fn_name string) {
	g.definitions.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it);')
	mut fn_builder := strings.new_builder(128)
	defer {
		g.auto_fn_definitions << fn_builder.str()
	}
	fn_builder.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it) {')
	for t in info.types {
		typ_ := g.unwrap_generic(t)
		sub_sym := g.table.sym(typ_)
		if sub_sym.kind !in [.string, .array, .map, .struct] {
			continue
		}
		if !sub_sym.has_method_with_generic_parent('free') {
			continue
		}
		type_styp := g.gen_type_name_for_free_call(typ_)
		free_fn_name := if sub_sym.is_builtin() {
			'builtin__${type_styp}_free'
		} else {
			'${type_styp}_free'
		}
		fn_builder.writeln('\tif (it->_typ == _${sym.cname}_${sub_sym.cname}_index) { ${free_fn_name}(it->_${sub_sym.cname}); return; }')
	}
	fn_builder.writeln('}')
}

fn (mut g Gen) gen_free_for_sumtype(info ast.SumType, styp string, fn_name string) {
	g.definitions.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it);')
	mut fn_builder := strings.new_builder(256)
	defer {
		g.auto_fn_definitions << fn_builder.str()
	}
	fn_builder.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it) {')
	mut idxs := []ast.Type{}
	for variant in info.variants {
		if variant in idxs {
			continue
		}
		idxs << variant
		free_typ := variant.clear_flag(.option)
		free_sym := g.table.sym(g.unwrap_generic(free_typ))
		variant_name := g.get_sumtype_variant_name(variant, free_sym)
		variant_ptr := 'it->_${variant_name}'
		fn_builder.writeln('\tif (it->_typ == ${g.type_sidx(variant)}) {')
		if variant.has_flag(.option) {
			match free_sym.kind {
				.string {
					fn_builder.writeln('\t\tif (${variant_ptr}->state != 2) {')
					fn_builder.writeln('\t\t\tbuiltin__string_free((${g.base_type(variant)}*)${variant_ptr}->data);')
					fn_builder.writeln('\t\t}')
				}
				.array, .map, .struct, .sum_type, .interface {
					mut free_fn_name := if free_sym.has_method('free') {
						'${g.gen_type_name_for_free_call(free_typ)}_free'
					} else {
						g.gen_free_method(free_typ)
					}
					if free_sym.is_builtin() {
						free_fn_name = 'builtin__${free_fn_name}'
					}
					fn_builder.writeln('\t\tif (${variant_ptr}->state != 2) {')
					fn_builder.writeln('\t\t\t${free_fn_name}((${g.base_type(variant)}*)${variant_ptr}->data);')
					fn_builder.writeln('\t\t}')
				}
				else {}
			}
		} else {
			match free_sym.kind {
				.string {
					fn_builder.writeln('\t\tbuiltin__string_free(${variant_ptr});')
				}
				.array, .map, .struct, .sum_type, .interface {
					mut free_fn_name := if free_sym.has_method('free') {
						'${g.gen_type_name_for_free_call(free_typ)}_free'
					} else {
						g.gen_free_method(free_typ)
					}
					if free_sym.is_builtin() {
						free_fn_name = 'builtin__${free_fn_name}'
					}
					fn_builder.writeln('\t\t${free_fn_name}(${variant_ptr});')
				}
				else {}
			}
		}
		// Sumtypes box their active payload in heap memory via memdup/HEAP.
		fn_builder.writeln('\t\tbuiltin___v_free(${variant_ptr});')
		fn_builder.writeln('\t\treturn;')
		fn_builder.writeln('\t}')
	}
	fn_builder.writeln('}')
}

fn (mut g Gen) gen_free_for_struct(typ ast.Type, info ast.Struct, styp string, ofn_name string, sym_is_builtin bool) {
	mut fn_name := ofn_name
	if sym_is_builtin {
		fn_name = 'builtin__${fn_name}'
	}
	g.definitions.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it);')
	mut fn_builder := strings.new_builder(128)
	defer {
		g.auto_fn_definitions << fn_builder.str()
	}
	fn_builder.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it) {')
	for field in info.fields {
		field_name := c_name(field.name)
		sym := g.table.sym(g.unwrap_generic(field.typ))

		if sym.kind !in [.string, .array, .map, .struct, .sum_type] {
			continue
		}
		field_styp := g.gen_type_name_for_free_call(field.typ)
		is_struct_option := typ.has_flag(.option)
		free_method_typ := if field.typ.has_flag(.shared_f) {
			field.typ.clear_flag(.shared_f).set_nr_muls(0)
		} else {
			field.typ
		}
		mut field_styp_fn_name := if sym.has_method('free') {
			'${field_styp}_free'
		} else {
			g.gen_free_method(free_method_typ)
		}
		if sym.is_builtin() {
			field_styp_fn_name = 'builtin__${field_styp_fn_name}'
		}
		is_field_option := field.typ.has_flag(.option)
		expects_opt := field_styp_fn_name.starts_with('_option_')
		if field.typ.has_flag(.shared_f) {
			fn_builder.writeln('\t${field_styp_fn_name}(&(it->${field_name}->val));')
		} else if is_struct_option {
			opt_styp := g.base_type(typ)
			prefix := if field.typ.is_ptr() { '' } else { '&' }
			if is_field_option {
				opt_field_styp := if expects_opt {
					g.styp(field.typ)
				} else {
					g.base_type(field.typ)
				}
				suffix := if expects_opt { '' } else { '.data' }

				fn_builder.writeln('\tif (((${opt_styp}*)&it->data)->${field_name}.state != 2) {')
				fn_builder.writeln('\t\t${field_styp_fn_name}((${opt_field_styp}*)${prefix}((${opt_styp}*)&it->data)->${field_name}${suffix});')
				fn_builder.writeln('\t}')
			} else {
				fn_builder.writeln('\t${field_styp_fn_name}(${prefix}((${opt_styp}*)&it->data)->${field_name});')
			}
		} else {
			if is_field_option {
				opt_field_styp := if expects_opt {
					g.styp(field.typ)
				} else {
					g.base_type(field.typ)
				}
				suffix := if expects_opt { '' } else { '.data' }

				fn_builder.writeln('\tif (it->${field_name}.state != 2) {')
				fn_builder.writeln('\t\t${field_styp_fn_name}((${opt_field_styp}*)&(it->${field_name}${suffix}));')
				fn_builder.writeln('\t}')
			} else {
				prefix := if field.typ.is_ptr() { '' } else { '&' }
				fn_builder.writeln('\t${field_styp_fn_name}(${prefix}(it->${field_name}));')
			}
		}
	}
	fn_builder.writeln('}')
}

fn (mut g Gen) gen_type_name_for_free_call(typ ast.Type) string {
	mut styp := g.styp(typ.set_nr_muls(0).clear_flag(.option)).replace('*', '')
	if styp.starts_with('__shared') {
		styp = styp.all_after('__shared__')
	}
	return styp
}

fn (mut g Gen) gen_free_for_array(info ast.Array, styp string, fn_name string) {
	g.definitions.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it);')
	mut fn_builder := strings.new_builder(128)
	defer {
		g.auto_fn_definitions << fn_builder.str()
	}
	fn_builder.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it) {')

	sym := g.table.sym(g.unwrap_generic(info.elem_type))
	if sym.kind in [.string, .array, .map, .struct, .sum_type] {
		fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < it->len; i++) {')

		mut elem_styp := g.styp(info.elem_type).replace('*', '')
		mut elem_styp_fn_name := if sym.has_method('free') {
			'${elem_styp}_free'
		} else {
			g.gen_free_method(info.elem_type)
		}
		if sym.is_builtin() {
			elem_styp_fn_name = 'builtin__${elem_styp_fn_name}'
		}
		fn_builder.writeln('\t\t${elem_styp_fn_name}(&(((${elem_styp}*)it->data)[i]));')
		fn_builder.writeln('\t}')
	}
	fn_builder.writeln('\tbuiltin__array_free(it);')
	fn_builder.writeln('}')
}

fn (mut g Gen) gen_free_for_map(typ ast.Type, styp string, fn_name string) {
	g.definitions.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it);')
	mut fn_builder := strings.new_builder(128)
	defer {
		g.auto_fn_definitions << fn_builder.str()
	}
	fn_builder.writeln('${g.static_non_parallel}void ${fn_name}(${styp}* it) {')

	if typ.has_flag(.option) {
		fn_builder.writeln('\tif (it->state != 2) {')
		fn_builder.writeln('\t\tbuiltin__map_free((map*)&it->data);')
		fn_builder.writeln('\t}')
	} else {
		fn_builder.writeln('\tbuiltin__map_free(it);')
	}
	fn_builder.writeln('}')
}

@[inline]
fn styp_to_free_fn_name(styp string) string {
	return styp.replace_each(['*', '', '.', '__', ' ', '__']) + '_free'
}