// vtest build: macos
module cleanc

import os
import v2.parser
import v2.pref as vpref
import v2.token
import v2.transformer
import v2.types

fn generate_array_append_c_for_test(code string) string {
	return generate_array_append_c_for_test_files([code])
}

fn generate_array_append_c_for_test_files(sources []string) string {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_array_append_codegen_test_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic('failed to create temp dir') }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	mut paths := []string{cap: sources.len}
	for i, code in sources {
		tmp_file := os.join_path(tmp_dir, 'file_${i}.v')
		os.write_file(tmp_file, code) or { panic('failed to write temp file') }
		paths << tmp_file
	}
	prefs := &vpref.Preferences{
		backend:     .cleanc
		no_parallel: true
	}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(prefs)
	files := par.parse_files(paths, mut file_set)
	env := types.Environment.new()
	mut checker := types.Checker.new(prefs, file_set, env)
	checker.check_files(files)
	mut trans := transformer.Transformer.new_with_pref(env, prefs)
	mut gen := Gen.new_with_env_and_pref(trans.transform_files(files), env, prefs)
	return gen.gen()
}

fn test_generate_c_uses_push_many_for_array_slice_append() {
	csrc := generate_array_append_c_for_test('
fn main() {
	mut dst := []u8{}
	haystack := [u8(1), 2, 3]
	dst << haystack[1..3]
}
')
	assert csrc.contains('array__push_many(')
	assert !csrc.contains('&(u8[1]){array__slice(haystack, 1, 3)}')
}

fn test_generate_c_uses_push_many_for_array_literal_append() {
	csrc := generate_array_append_c_for_test('
fn main() {
	mut dst := []u8{}
	dst << [u8(`$`)]
}
')
	assert csrc.contains('array__push_many(')
	assert !csrc.contains('&(u8[1]){new_array_from_c_array(')
}

fn test_generate_c_uses_push_many_for_local_array_append() {
	csrc := generate_array_append_c_for_test('
fn source() []u8 {
	return [u8(1), 2]
}

fn main() {
	mut dst := []u8{}
	src := source()
	dst << src
}
')
	assert csrc.contains('array__push_many(')
	assert !csrc.contains('&(u8[1]){src}')
}

fn test_generate_c_push_many_to_mut_array_param_uses_param_pointer() {
	csrc := generate_array_append_c_for_test('
fn extend(mut dst []usize, src []usize) {
	dst << src
}
')
	assert csrc.contains('array__push_many(')
	assert csrc.contains('array__push_many(((array*)(dst)),')
	assert !csrc.contains('array__push_many((array*)&dst,')
	assert !csrc.contains('array__push_many(((array*)(&dst)),')
}

fn test_generate_c_lowered_push_many_to_mut_array_param_uses_param_pointer() {
	csrc := generate_array_append_c_for_test('
struct Index {
	entries map[string][]usize
}

fn (idx Index) matches_into(candidate string, mut matches []usize) {
	if hits := idx.entries[candidate] {
		matches << hits
	}
}
')
	assert csrc.contains('array__push_many(')
	assert csrc.contains('array__push_many(((array*)(matches)),')
	assert !csrc.contains('array__push_many((array*)&matches,')
	assert !csrc.contains('array__push_many(((array*)(&matches)),')
}

fn test_generate_c_uses_push_many_for_fn_pointer_array_return_append() {
	csrc := generate_array_append_c_for_test('
fn source(data []u8) []u8 {
	return data
}

fn consume(hash_func fn ([]u8) []u8) {
	mut dst := []u8{}
	src := hash_func(dst)
	dst << src
}

fn main() {
	consume(source)
}
')
	assert csrc.contains('array__push_many(')
	assert !csrc.contains('&(u8[1]){src}')
}

fn test_generate_c_keeps_bitwise_or_inside_array_append_value() {
	csrc := generate_array_append_c_for_test('
fn main() {
	mut bytes := []u8{}
	n1 := u8(1)
	n0 := u8(2)
	bytes << (n1 << 4) | n0
}
')
	assert csrc.contains('array__push(')
	assert csrc.contains('| n0')
	assert !csrc.contains('array__push_many(')
	assert !csrc.contains('_arr_push_many_tmp_')
	assert !csrc.contains('}) | n0')
}

fn test_generate_c_wraps_mut_u8_array_param_bitwise_append_value() {
	csrc := generate_array_append_c_for_test('
fn write_int(mut out []u8, value u64, high_bits u8) {
	out << high_bits | u8(value)
}
')
	assert csrc.contains('array__push(((array*)(out)), &(u8[1]){')
	assert !csrc.contains('array__push(((array*)(out)), (high_bits | ((u8)(value))))')
}

fn test_generate_c_appends_for_mut_pointer_value_to_array() {
	csrc := generate_array_append_c_for_test('
struct PullRequest {
mut:
	repo_name string
}

fn copy(mut prs []PullRequest) []PullRequest {
	mut out := []PullRequest{}
	for mut pr in prs {
		pr.repo_name = "x"
		out << pr
	}
	return out
}
')
	assert csrc.contains('array__push(((array*)(&out)), pr);')
	assert !csrc.contains('array__push(((array*)(&out)), &(PullRequest[1]){pr});')
}

fn test_generate_c_indexes_local_array_that_shadows_function_name() {
	csrc := generate_array_append_c_for_test('
fn bytes() []u8 {
	return []u8{}
}

fn main() {
	mut bytes := [u8(1)]
	bytes[0] &= u8(3)
}
')
	assert csrc.contains('((u8*)bytes.data)[((int)(0))] &= ((u8)(3));')
	assert !csrc.contains('bytes &= ((u8)(3));')
}

fn test_generate_c_uses_typed_zero_for_array_tuple_if_declarations() {
	csrc := generate_array_append_c_for_test('
fn pick(operand_a []u64, operand_b []u64) {
	mut a, mut b := if operand_a.len >= operand_b.len {
		operand_a, operand_b
	} else {
		operand_b, operand_a
	}
	_ = a
	_ = b
}
')
	assert csrc.contains('Array_u64 a = ((Array_u64){0});')
	assert csrc.contains('Array_u64 b = ((Array_u64){0});')
	assert !csrc.contains('Array_u64 a = 0;')
	assert !csrc.contains('Array_u64 b = 0;')
}

fn test_generate_c_uses_default_init_for_empty_array_struct_fields() {
	csrc := generate_array_append_c_for_test('
struct Pool {
	items []voidptr
}

fn main() {
	pool := Pool{
		items: []
	}
	_ = pool.items.len
}
	')
	assert csrc.contains('.items = __new_array_with_default_noscan(0, 0, sizeof(void*)')
	assert !csrc.contains('.items = new_array_from_c_array(0, 0, sizeof(void*)')
}

fn test_generate_c_specializes_generic_pointer_array_push_literal() {
	csrc := generate_array_append_c_for_test('
struct Foo {}

fn get_results_ref[T](items []voidptr) []&T {
	mut res := []&T{cap: items.len}
	for i in 0 .. items.len {
		res << unsafe { &T(items[i]) }
	}
	return res
}

fn main() {
	items := []voidptr{}
	res := get_results_ref[Foo](items)
	_ = res.len
}
	')
	assert csrc.contains('(Foo*[1]){((Foo*)')
	assert !csrc.contains('(T*[1])')
	assert !csrc.contains('stdatomic__T')
}

fn test_generate_c_uses_captured_mut_array_pointer_for_closure_push() {
	csrc := generate_array_append_c_for_test('
fn consume(cb fn (int) bool) {
	_ = cb(1)
}

fn main() {
	mut values := []int{}
	consume(fn [mut values] (value int) bool {
		values << value
		return true
	})
}
	')
	assert csrc.contains('Array_int* values = _anon_fn_')
	assert csrc.contains('array__push(((array*)(values)),')
	assert !csrc.contains('array__push(((array*)(&values)),')
}

fn test_generate_c_updates_captured_mut_scalar_for_closure_postfix() {
	csrc := generate_array_append_c_for_test('
fn consume(cb fn () bool) {
	_ = cb()
}

fn main() {
	mut count := u64(0)
	consume(fn [mut count] () bool {
		count++
		return true
	})
}
	')
	assert csrc.contains('u64* count = _anon_fn_')
	assert csrc.contains('(*count)++')
	assert !csrc.contains('count++;')
}

fn test_generate_c_evaluates_generic_comptime_is_against_implements() {
	csrc := generate_array_append_c_for_test('
interface Writer {
	write([]u8) !int
}

struct Buffer implements Writer {}

fn (mut b Buffer) write(buf []u8) !int {
	_ = b
	return buf.len
}

fn choose[T]() int {
	$if T is Writer {
		return 1
	} $else {
		return 2
	}
}

fn main() {
	_ = choose[Buffer]()
}
	')
	assert csrc.contains('return 1;')
	assert !csrc.contains('return 2;')
}

fn test_generate_c_specializes_comptime_pointer_field_generic_call_by_field_type() {
	csrc := generate_array_append_c_for_test('
fn struct_field_should_encode[T](val T) bool {
	_ = val
	return true
}

fn encode_fields[T](val T) bool {
	mut ok := true
	$for field in T.fields {
		ok = struct_field_should_encode(val.$(field.name))
	}
	return ok
}

struct Node {
	next &Node = unsafe { nil }
}

fn main() {
	_ = encode_fields(Node{})
}
')
	assert csrc.contains('struct_field_should_encode_T_Nodeptr(val.next)')
	assert !csrc.contains('struct_field_should_encode_T_Node((*val.next))')
}

fn test_generate_c_specializes_comptime_generic_pointer_field_by_field_type() {
	csrc := generate_array_append_c_for_test('
module json2

struct ValueInfo {}

struct Node[T] {
	value T
	next  &Node[T] = unsafe { nil }
}

struct Decoder {
	current_node &Node[ValueInfo] = unsafe { nil }
}

struct EncoderFieldInfo {}

struct Encoder {}

fn (mut encoder Encoder) encode_value[T](val T) {
	$if T is $pointer {
		encoder.encode_value(*val)
	} $else $if T is $struct {
		_ = encoder.encode_fields[T](val)
	}
}

fn (mut encoder Encoder) cached_field_infos[T]() []EncoderFieldInfo {
	return []EncoderFieldInfo{}
}

fn (mut encoder Encoder) encode_struct_field_value[T](val T) {
	$if T.indirections == 1 {
		encoder.encode_value(*val)
	} $else {
		encoder.encode_value(val)
	}
}

fn struct_field_should_encode[T](field_info EncoderFieldInfo, val T) bool {
	_ = field_info
	_ = val
	return true
}

fn (mut encoder Encoder) encode_fields[T](val T) bool {
	field_infos := encoder.cached_field_infos[T]()
	mut ok := true
	mut i := 0
	$for field in T.fields {
		field_info := field_infos[i]
		ok = struct_field_should_encode(field_info, val.$(field.name))
		encoder.encode_struct_field_value(val.$(field.name))
		i++
	}
	return ok
}

fn use_encoder() {
	mut encoder := Encoder{}
	_ = encoder.encode_fields(Decoder{})
	_ = encoder.encode_fields(Node[ValueInfo]{})
}
')
	assert csrc.contains('json2__struct_field_should_encode_T_json2_Nodeptr(field_info, val.current_node)')
	assert csrc.contains('json2__Encoder__encode_struct_field_value_T_json2_Nodeptr(encoder, val.current_node)')
	assert csrc.contains('json2__Encoder__cached_field_infos_T_json2_Decoder(encoder)')
	assert csrc.contains('Array_json2__EncoderFieldInfo json2__Encoder__cached_field_infos_T_json2_Node(json2__Encoder* encoder)')
	assert !csrc.contains('json2__struct_field_should_encode_T_json2_Node(field_info, (*val.current_node))')
	assert !csrc.contains('json2__Encoder__encode_struct_field_value_T_json2_Node(encoder, (*val.current_node))')
}

fn test_generate_c_extracts_array_sum_variant_for_generic_array_param() {
	csrc := generate_array_append_c_for_test_files([
		'
module orm

pub struct InfixType {
	right int
}

pub type Primitive = InfixType | []InfixType | int

pub fn tenant_filter_array_primitive_type[T](value []T) int {
	return value.len
}

pub fn tenant_filter_primitive_type(value Primitive) int {
	return match value {
		InfixType {
			2
		}
		[]InfixType {
			tenant_filter_array_primitive_type(value)
		}
		int {
			3
		}
	}
}
',
		'
module main

import orm

fn main() {
	_ = orm.tenant_filter_primitive_type([]orm.InfixType{})
}
',
	])
	assert csrc.contains('orm__tenant_filter_array_primitive_type_T_orm_InfixType(((((Array_orm__InfixType*)(value._data._Array_orm__InfixType))')
	assert !csrc.contains('orm__tenant_filter_array_primitive_type_T_orm_InfixType(((((orm__InfixType*)(value._data._InfixType))')
}

fn test_generate_c_lowers_global_interface_generic_method_call() {
	csrc := generate_array_append_c_for_test('
interface Rng {
	intn(max int) !int
}

__global default_rng &Rng

fn (mut rng Rng) element[T](array []T) !T {
	if array.len == 0 {
		return error("empty")
	}
	return array[rng.intn(array.len)!]
}

fn element[T](array []T) !T {
	return default_rng.element[T](array)
}

fn main() {
	_ = element[u8]([u8(1)]) or { u8(0) }
}
')
	assert csrc.contains('Rng__element_T_u8(default_rng, _v_array)')
	assert !csrc.contains('u8 _val = (_v_array)')
}