// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
// vtest build: macos

module abi

import os
import v2.ast
import v2.mir
import v2.parser
import v2.pref
import v2.ssa
import v2.token

fn parse_code_for_test(code string) []ast.File {
	tmp_file := os.join_path(os.temp_dir(), 'v2_abi_parser_test_${os.getpid()}.v')
	os.write_file(tmp_file, code) or { panic(err) }
	defer {
		os.rm(tmp_file) or {}
	}
	prefs := &pref.Preferences{}
	mut file_set := token.FileSet.new()
	mut p := parser.Parser.new(prefs)
	return p.parse_files([tmp_file], mut file_set)
}

fn first_fn_decl(file ast.File) ast.FnDecl {
	for stmt in file.stmts {
		if stmt is ast.FnDecl {
			return stmt
		}
	}
	panic('expected function declaration in parsed file')
}

fn test_parser_sql_expr_allows_nested_braces_in_body() {
	files := parse_code_for_test("
module main

fn main() {
	req_status := true
	sql db {
		update User set
		name = 'Jengro',
		status = if req_status { 1 } else { 0 }
		status = fn [req_status] () u8 { if req_status { return 1 } else { return 0 } }()
		where id == '100'
	}
}
")
	assert files.len == 1
	main_fn := first_fn_decl(files[0])
	assert main_fn.stmts.len == 2
	assert main_fn.stmts[1] is ast.ExprStmt
	sql_stmt := main_fn.stmts[1] as ast.ExprStmt
	assert sql_stmt.expr is ast.SqlExpr
}

fn test_arm64_large_struct_call_is_lowered_to_call_sret() {
	mut ssa_mod := ssa.Module.new('abi_test')
	i64_t := ssa_mod.type_store.get_int(64)
	i8_t := ssa_mod.type_store.get_int(8)
	ptr_t := ssa_mod.type_store.get_ptr(i8_t)
	large_struct_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [ptr_t, i64_t, i64_t] // 24 bytes
	})

	callee_id := ssa_mod.new_function('callee', large_struct_t, [])
	callee_entry := ssa_mod.add_block(callee_id, 'entry')
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, callee_entry, 0, [zero])

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
	call_val := ssa_mod.add_instr(.call, caller_entry, large_struct_t, [fn_val])
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower(mut mir_mod, .arm64)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.op == .call_sret
}

fn test_x64_large_struct_call_is_lowered_to_call_sret() {
	mut ssa_mod := ssa.Module.new('abi_test_x64')
	i64_t := ssa_mod.type_store.get_int(64)
	i8_t := ssa_mod.type_store.get_int(8)
	ptr_t := ssa_mod.type_store.get_ptr(i8_t)
	large_struct_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [ptr_t, i64_t, i64_t]
	})

	callee_id := ssa_mod.new_function('callee', large_struct_t, [])
	callee_entry := ssa_mod.add_block(callee_id, 'entry')
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, callee_entry, 0, [zero])

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
	call_val := ssa_mod.add_instr(.call, caller_entry, large_struct_t, [fn_val])
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower(mut mir_mod, .x64)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.op == .call_sret
}

fn test_x64_sysv_sixteen_byte_struct_return_stays_direct() {
	mut ssa_mod := ssa.Module.new('abi_test_x64_sysv_16_ret')
	i64_t := ssa_mod.type_store.get_int(64)
	struct16_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t, i64_t]
	})

	callee_id := ssa_mod.new_function('callee', struct16_t, [])
	callee_entry := ssa_mod.add_block(callee_id, 'entry')
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, callee_entry, 0, [zero])

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
	call_val := ssa_mod.add_instr(.call, caller_entry, struct16_t, [fn_val])
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower(mut mir_mod, .x64)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.op == .call
	assert !call_instr.abi_ret_indirect
}

fn test_x64_windows_struct_return_classification() {
	mut ssa_mod := ssa.Module.new('abi_test_x64_windows_ret')
	i64_t := ssa_mod.type_store.get_int(64)
	i8_t := ssa_mod.type_store.get_int(8)
	struct8_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t]
	})
	struct9_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t, i8_t]
	})
	struct16_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t, i64_t]
	})

	fn8 := ssa_mod.new_function('ret8', struct8_t, [])
	fn9 := ssa_mod.new_function('ret9', struct9_t, [])
	fn16 := ssa_mod.new_function('ret16', struct16_t, [])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower_with_x64_abi(mut mir_mod, .x64, .windows)

	assert !mir_mod.funcs[fn8].abi_ret_indirect
	assert mir_mod.funcs[fn9].abi_ret_indirect
	assert mir_mod.funcs[fn16].abi_ret_indirect
}

fn test_x64_windows_struct_param_classification() {
	mut ssa_mod := ssa.Module.new('abi_test_x64_windows_param')
	i64_t := ssa_mod.type_store.get_int(64)
	i8_t := ssa_mod.type_store.get_int(8)
	struct8_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t]
	})
	struct9_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t, i8_t]
	})
	struct16_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t, i64_t]
	})

	fn_id := ssa_mod.new_function('callee', i64_t, [])
	param8 := ssa_mod.add_value_node(.argument, struct8_t, 's8', 0)
	param9 := ssa_mod.add_value_node(.argument, struct9_t, 's9', 0)
	param16 := ssa_mod.add_value_node(.argument, struct16_t, 's16', 0)
	ssa_mod.funcs[fn_id].params << [param8, param9, param16]

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower_with_x64_abi(mut mir_mod, .x64, .windows)

	assert mir_mod.funcs[fn_id].abi_param_class == [.in_reg, .indirect, .indirect]
}

fn test_x64_windows_callsite_struct_arg_classification() {
	mut ssa_mod := ssa.Module.new('abi_test_x64_windows_call_arg')
	i64_t := ssa_mod.type_store.get_int(64)
	i8_t := ssa_mod.type_store.get_int(8)
	struct8_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t]
	})
	struct9_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t, i8_t]
	})
	struct16_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t, i64_t]
	})

	callee_id := ssa_mod.new_function('callee', i64_t, [])
	param8 := ssa_mod.add_value_node(.argument, struct8_t, 's8', 0)
	param9 := ssa_mod.add_value_node(.argument, struct9_t, 's9', 0)
	param16 := ssa_mod.add_value_node(.argument, struct16_t, 's16', 0)
	ssa_mod.funcs[callee_id].params << [param8, param9, param16]

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	arg8 := ssa_mod.add_value_node(.argument, struct8_t, 'arg8', 0)
	arg9 := ssa_mod.add_value_node(.argument, struct9_t, 'arg9', 0)
	arg16 := ssa_mod.add_value_node(.argument, struct16_t, 'arg16', 0)
	ssa_mod.funcs[caller_id].params << [arg8, arg9, arg16]
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
	call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, [fn_val, arg8, arg9, arg16])
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower_with_x64_abi(mut mir_mod, .x64, .windows)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.abi_arg_class == [.in_reg, .indirect, .indirect]
}

fn test_arm64_external_large_struct_call_is_lowered_to_call_sret() {
	mut ssa_mod := ssa.Module.new('abi_test_external')
	i64_t := ssa_mod.type_store.get_int(64)
	i8_t := ssa_mod.type_store.get_int(8)
	ptr_t := ssa_mod.type_store.get_ptr(i8_t)
	large_struct_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [ptr_t, i64_t, i64_t]
	})

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	external_fn := ssa_mod.add_value_node(.unknown, 0, 'external_make', 0)
	call_val := ssa_mod.add_instr(.call, caller_entry, large_struct_t, [external_fn])
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower(mut mir_mod, .arm64)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.op == .call_sret
}

fn test_arm64_indirect_call_large_struct_return_is_lowered_to_call_sret() {
	mut ssa_mod := ssa.Module.new('abi_test_indirect')
	i64_t := ssa_mod.type_store.get_int(64)
	i8_t := ssa_mod.type_store.get_int(8)
	ptr_t := ssa_mod.type_store.get_ptr(i8_t)
	large_struct_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [ptr_t, i64_t, i64_t]
	})
	fn_sig_t := ssa_mod.type_store.register(ssa.Type{
		kind:     .func_t
		params:   []ssa.TypeID{}
		ret_type: large_struct_t
	})
	fn_ptr_t := ssa_mod.type_store.get_ptr(fn_sig_t)

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	fn_ptr := ssa_mod.add_value_node(.argument, fn_ptr_t, 'fn_ptr', 0)
	ssa_mod.funcs[caller_id].params << fn_ptr
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	call_val := ssa_mod.add_instr(.call_indirect, caller_entry, large_struct_t, [
		fn_ptr,
	])
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower(mut mir_mod, .arm64)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.op == .call_sret
}

fn test_arm64_callsite_marks_large_struct_arg_indirect() {
	mut ssa_mod := ssa.Module.new('abi_test_arg_class')
	i64_t := ssa_mod.type_store.get_int(64)
	i8_t := ssa_mod.type_store.get_int(8)
	ptr_t := ssa_mod.type_store.get_ptr(i8_t)
	large_struct_t := ssa_mod.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [ptr_t, i64_t, i64_t]
	})

	callee_id := ssa_mod.new_function('callee', i64_t, [])
	callee_param := ssa_mod.add_value_node(.argument, large_struct_t, 'arg', 0)
	ssa_mod.funcs[callee_id].params << callee_param
	callee_entry := ssa_mod.add_block(callee_id, 'entry')
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, callee_entry, 0, [zero])

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	caller_param := ssa_mod.add_value_node(.argument, large_struct_t, 'in', 0)
	ssa_mod.funcs[caller_id].params << caller_param
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
	call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, [fn_val, caller_param])
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower(mut mir_mod, .arm64)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.abi_arg_class.len == 1
	assert call_instr.abi_arg_class[0] == .indirect
}

fn test_arm64_callsite_marks_large_array_arg_indirect() {
	mut ssa_mod := ssa.Module.new('abi_test_array_arg_class')
	i64_t := ssa_mod.type_store.get_int(64)
	large_array_t := ssa_mod.type_store.register(ssa.Type{
		kind:      .array_t
		elem_type: i64_t
		len:       3
	})

	callee_id := ssa_mod.new_function('callee', i64_t, [])
	callee_param := ssa_mod.add_value_node(.argument, large_array_t, 'arg', 0)
	ssa_mod.funcs[callee_id].params << callee_param
	callee_entry := ssa_mod.add_block(callee_id, 'entry')
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, callee_entry, 0, [zero])

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	caller_param := ssa_mod.add_value_node(.argument, large_array_t, 'in', 0)
	ssa_mod.funcs[caller_id].params << caller_param
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	fn_val := ssa_mod.add_value_node(.unknown, 0, 'callee', 0)
	call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, [fn_val, caller_param])
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower(mut mir_mod, .arm64)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.abi_arg_class.len == 1
	assert call_instr.abi_arg_class[0] == .indirect
}

fn test_arm64_unresolved_callsite_marks_large_array_alloca_arg_indirect() {
	mut ssa_mod := ssa.Module.new('abi_test_array_alloca_arg_class')
	i64_t := ssa_mod.type_store.get_int(64)
	large_array_t := ssa_mod.type_store.register(ssa.Type{
		kind:      .array_t
		elem_type: i64_t
		len:       3
	})
	large_array_ptr_t := ssa_mod.type_store.get_ptr(large_array_t)

	caller_id := ssa_mod.new_function('caller', i64_t, [])
	caller_entry := ssa_mod.add_block(caller_id, 'entry')
	tmp := ssa_mod.add_instr(.alloca, caller_entry, large_array_ptr_t, []ssa.ValueID{})
	external_fn := ssa_mod.add_value_node(.unknown, 0, 'external_append_like', 0)
	call_val := ssa_mod.add_instr(.call, caller_entry, i64_t, [external_fn, tmp])
	zero := ssa_mod.get_or_add_const(i64_t, '0')
	ssa_mod.add_instr(.ret, caller_entry, 0, [zero])

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	lower(mut mir_mod, .arm64)

	call_instr := mir_mod.instrs[mir_mod.values[call_val].index]
	assert call_instr.abi_arg_class.len == 1
	assert call_instr.abi_arg_class[0] == .indirect
}