module c

import v3.types
import v3.flat

fn (mut g FlatGen) emit_sum_type(name string) {
	variants := g.tc.sum_types[name]
	g.writeln('struct ${c_name(name)} {')
	g.writeln('\tint typ;')
	g.writeln('\tunion {')
	for v in variants {
		ct := g.tc.c_type(g.tc.parse_type(v))
		field := g.sum_field_name(v)
		g.writeln('\t\t${ct}* ${field};')
	}
	g.writeln('\t};')
	g.writeln('};')
	g.writeln('')
}

fn (g &FlatGen) sum_type_contains_struct(sum_name string, struct_name string) bool {
	if sum_name in g.tc.sum_types {
		for v in g.tc.sum_types[sum_name] {
			if v == struct_name {
				return true
			}
		}
	}
	return false
}

fn (g &FlatGen) variant_references_sum(variant string, sum_name string) bool {
	_ = variant
	_ = sum_name
	return true
}

fn (g &FlatGen) variant_refs_sum_inner(variant string, sum_name string, mut visited map[string]bool) bool {
	normalized_variant := g.normalize_variant_name(variant)
	if normalized_variant == sum_name
		|| normalized_variant.all_after_last('.') == sum_name.all_after_last('.') {
		return true
	}
	if normalized_variant in visited {
		return false
	}
	visited[normalized_variant] = true
	mut lookup := normalized_variant
	if lookup !in g.tc.structs && !lookup.contains('.') && sum_name.contains('.') {
		qualified := '${sum_name.all_before_last('.')}.${lookup}'
		if qualified in g.tc.structs {
			lookup = qualified
		}
	}
	if lookup !in g.tc.structs && !lookup.contains('.') {
		for struct_name, _ in g.tc.structs {
			if struct_name.all_after_last('.') == lookup {
				lookup = struct_name
				break
			}
		}
	}
	if lookup in g.tc.structs {
		for f in g.tc.structs[lookup] {
			if g.type_references_sum(f.typ, sum_name, mut visited) {
				return true
			}
		}
	}
	return false
}

fn (g &FlatGen) normalize_variant_name(name string) string {
	_ = g
	mut res := name
	if res.starts_with('&') {
		res = res[1..]
	}
	if res.starts_with('ptr') && res.len > 3 {
		res = res[3..]
	}
	if res.contains('__') && !res.contains('.') {
		res = res.replace('__', '.')
	}
	return res
}

fn (g &FlatGen) type_references_sum(typ types.Type, sum_name string, mut visited map[string]bool) bool {
	resolved_sum := g.resolve_sum_name(sum_name)
	clean := types.unwrap_pointer(typ)
	if clean is types.Struct && g.resolve_sum_name(clean.name) == resolved_sum {
		return true
	}
	if clean is types.SumType && g.resolve_sum_name(clean.name) == resolved_sum {
		return true
	}
	if clean is types.SumType {
		return true
	}
	if clean is types.Struct {
		if g.variant_refs_sum_inner(clean.name, resolved_sum, mut visited) {
			return true
		}
	}
	if clean is types.Array {
		return g.type_references_sum(clean.elem_type, resolved_sum, mut visited)
	}
	return false
}

fn (g &FlatGen) resolve_sum_name(sum_name string) string {
	if sum_name in g.tc.sum_types {
		return sum_name
	}
	for name, _ in g.tc.sum_types {
		if name.all_after_last('.') == sum_name {
			return name
		}
	}
	return sum_name
}

fn (g &FlatGen) resolve_variant(sum_name string, variant string) string {
	resolved_sum := g.resolve_sum_name(sum_name)
	normalized_variant := g.normalize_variant_name(variant)
	if resolved_sum in g.tc.sum_types {
		for v in g.tc.sum_types[resolved_sum] {
			if v == normalized_variant {
				return normalized_variant
			}
		}
		for v in g.tc.sum_types[resolved_sum] {
			if v.all_after_last('.') == normalized_variant {
				return v
			}
		}
	}
	return normalized_variant
}

fn (g &FlatGen) sum_field_name(variant string) string {
	if variant.starts_with('&') {
		return g.sum_field_name(variant[1..])
	}
	if variant.starts_with('ptr') && variant.len > 3 && variant[3..].contains('.') {
		return g.sum_field_name(variant[3..])
	}
	if variant.starts_with('ptr') && variant.len > 3 && variant[3..].contains('__') {
		return g.sum_field_name(variant[3..].replace('__', '.'))
	}
	if variant.starts_with('[]') {
		return '_Array_${c_name(variant[2..])}'
	}
	if variant.starts_with('map[') {
		return '_Map_${c_name(variant[4..].replace(']', '_'))}'
	}
	return match variant {
		'int' { '_int' }
		'i8' { '_i8' }
		'i16' { '_i16' }
		'i64' { '_i64' }
		'u8', 'byte' { '_u8' }
		'u16' { '_u16' }
		'u32' { '_u32' }
		'u64' { '_u64' }
		'f32' { '_f32' }
		'f64' { '_f64' }
		'bool' { '_bool' }
		'string' { '_string' }
		else { c_name(variant) }
	}
}

fn (mut g FlatGen) register_interface_strings() {
	for iface_name, methods in g.interfaces {
		cn := c_name(iface_name)
		for method in methods {
			g.intern_string('interface method ${cn}.${method} not implemented')
		}
	}
}

// collect_interface_impls discovers, for every interface, the concrete struct
// types that implement it (structural typing), and assigns each a stable 1-based
// type id. The id is stored in the boxed interface value's `_typ` field and is
// what the generated method-dispatch switch matches on.
fn (mut g FlatGen) collect_interface_impls() {
	mut iface_names := []string{}
	for name, _ in g.interfaces {
		iface_names << name
	}
	iface_names.sort()
	mut struct_names := []string{}
	for name, _ in g.tc.structs {
		struct_names << name
	}
	struct_names.sort()
	for iface in iface_names {
		if c_name(iface) == 'IError' {
			continue
		}
		mut impls := []string{}
		for concrete in struct_names {
			if g.tc.named_type_implements_interface(concrete, iface) {
				impls << concrete
			}
		}
		g.iface_impls[iface] = impls
		for idx, concrete in impls {
			g.iface_type_ids['${iface}::${concrete}'] = idx + 1
		}
	}
}

// iface_type_id returns the 1-based dispatch id assigned to `concrete` for
// interface `iface`, or 0 if `concrete` does not implement `iface`.
fn (g &FlatGen) iface_type_id(iface string, concrete string) int {
	return g.iface_type_ids['${iface}::${concrete}'] or { 0 }
}

fn (g &FlatGen) is_interface_type_name(name string) bool {
	return name in g.interfaces || g.tc.qualify_name(name) in g.interfaces
}

fn (g &FlatGen) has_ierror_interface() bool {
	for name, _ in g.interfaces {
		if c_name(name) == 'IError' {
			return true
		}
	}
	return false
}

// interface_init_typ_id computes the `_typ` dispatch id for a boxed interface
// literal by recovering the concrete type from its `_object` field.
fn (g &FlatGen) interface_init_typ_id(node flat.Node) ?int {
	iface := if node.value in g.interfaces {
		node.value
	} else {
		g.tc.qualify_name(node.value)
	}
	for i in 0 .. node.children_count {
		field := g.a.child_node(&node, i)
		if field.kind == .field_init && field.value == '_object' && field.children_count > 0 {
			obj_type := g.tc.resolve_type(g.a.child(field, 0))
			concrete := types.unwrap_pointer(obj_type)
			id := g.iface_type_id(iface, concrete.name())
			if id != 0 {
				return id
			}
			return none
		}
	}
	return none
}

// interface_method_stubs emits a dispatch function for every abstract interface
// method: it switches on the boxed value's `_typ` and forwards to the concrete
// implementation, passing `_object` as the receiver. Interfaces with no known
// implementers (and the special builtin `IError`) fall back to a panic stub.
fn (mut g FlatGen) interface_method_stubs() {
	for iface_name, methods in g.interfaces {
		cn := c_name(iface_name)
		for method in methods {
			g.gen_interface_dispatch(iface_name, cn, method)
		}
	}
	if g.interfaces.len > 0 {
		g.writeln('')
	}
}

fn (mut g FlatGen) gen_interface_dispatch(iface_name string, cn string, method string) {
	sid := g.intern_string('interface method ${cn}.${method} not implemented')
	mname := '${iface_name}.${method}'
	impls := g.iface_impls[iface_name] or { []string{} }
	if cn == 'IError' {
		ret_ct := if method == 'code' { 'int' } else { 'string' }
		g.writeln('${ret_ct} ${cn}__${method}(${cn}* i) {')
		match method {
			'msg' {
				g.writeln('\treturn i->message;')
			}
			'code' {
				g.writeln('\treturn i->code;')
			}
			else {
				g.writeln('\tv_panic(_str_${sid});')
				g.writeln('\treturn (${ret_ct}){0};')
			}
		}

		g.writeln('}')
		return
	}
	// Interface-declared method signatures store named params unreliably (a named
	// param like `node &ast.Node` can be split into two type-only params). The
	// concrete implementer's method is a real fn_decl with a correctly parsed
	// signature, so derive the dispatch parameter types from the first implementer
	// that has the method. The receiver convention is resolved per implementer.
	mut sig_key := ''
	for concrete in impls {
		ck := '${concrete}.${method}'
		if ck in g.tc.fn_param_types {
			sig_key = ck
			break
		}
	}
	ret_type := g.tc.fn_ret_types[mname] or {
		if sig_key.len > 0 {
			g.tc.fn_ret_types[sig_key] or { types.Type(types.void_) }
		} else {
			types.Type(types.void_)
		}
	}
	ret_ct := g.optional_type_name(ret_type)
	mut sig_params := if sig_key.len > 0 {
		g.tc.fn_param_types[sig_key] or { []types.Type{} }
	} else {
		[]types.Type{}
	}
	mut arg_names := []string{}
	g.write('${ret_ct} ${cn}__${method}(${cn}* i')
	for pi := 1; pi < sig_params.len; pi++ {
		pt := sig_params[pi]
		pct := if pt is types.OptionType || pt is types.ResultType {
			g.optional_type_name(pt)
		} else {
			g.tc.c_type(pt)
		}
		an := '_a${pi - 1}'
		arg_names << an
		g.write(', ${pct} ${an}')
	}
	g.writeln(') {')
	if impls.len > 0 {
		g.writeln('\tswitch (i->_typ) {')
		for concrete in impls {
			id := g.iface_type_id(iface_name, concrete)
			concrete_key := '${concrete}.${method}'
			if id == 0 || concrete_key !in g.tc.fn_param_types {
				continue
			}
			concrete_params := g.tc.fn_param_types[concrete_key] or { []types.Type{} }
			recv_is_ptr := concrete_params.len > 0 && concrete_params[0] is types.Pointer
			cct := g.tc.c_type(g.tc.parse_type(concrete))
			recv := if recv_is_ptr {
				'(${cct}*)i->_object'
			} else {
				'*(${cct}*)i->_object'
			}
			g.write('\t\tcase ${id}: ')
			mut call := '${c_name(concrete_key)}(${recv}'
			for an in arg_names {
				call += ', ${an}'
			}
			call += ')'
			if ret_ct == 'void' {
				g.writeln('${call}; return;')
			} else {
				g.writeln('return ${call};')
			}
		}
		g.writeln('\t\tdefault: break;')
		g.writeln('\t}')
	}
	g.writeln('\tv_panic(_str_${sid});')
	if ret_ct != 'void' {
		g.writeln('\treturn (${ret_ct}){0};')
	}
	g.writeln('}')
}

fn (g &FlatGen) sum_type_index(sum_name string, variant string) int {
	if sum_name in g.tc.sum_types {
		for i, v in g.tc.sum_types[sum_name] {
			if v == variant {
				return i + 1
			}
		}
		for i, v in g.tc.sum_types[sum_name] {
			if v.all_after_last('.') == variant {
				return i + 1
			}
		}
	}
	return 0
}