import os
import v3.flat
import v3.parser
import v3.pref
import v3.ssa
import v3.types

// parse_checked_source reads parse checked source input for v3 tests.
fn parse_checked_source(name string, source string) (&flat.FlatAst, &types.TypeChecker) {
	src := os.join_path(os.temp_dir(), 'v3_ssa_builder_${name}.v')
	os.write_file(src, source) or { panic(err) }
	prefs := pref.new_preferences()
	mut p := parser.Parser.new(prefs)
	mut a := p.parse_file(src)
	mut tc := types.TypeChecker.new(a)
	tc.collect(a)
	tc.annotate_types()
	assert tc.errors.len == 0
	return a, &tc
}

// build_source builds source data for v3 tests.
fn build_source(name string, source string) &ssa.Module {
	return build_source_with_used(name, source, map[string]bool{})
}

// build_source_with_used builds source with used data for v3 tests.
fn build_source_with_used(name string, source string, used_fns map[string]bool) &ssa.Module {
	a, tc := parse_checked_source(name, source)
	return ssa.build_with_used(a, used_fns, tc)
}

// find_func resolves find func information for v3 tests.
fn find_func(m &ssa.Module, name string) ssa.Function {
	for f in m.funcs {
		if f.name == name {
			return f
		}
	}
	assert false
	return ssa.Function{}
}

// func_instrs supports func instrs handling for v3 tests.
fn func_instrs(m &ssa.Module, name string) []ssa.Instruction {
	f := find_func(m, name)
	mut instrs := []ssa.Instruction{}
	for block_id in f.blocks {
		for val_id in m.blocks[block_id].instrs {
			val := m.values[val_id]
			if val.kind == .instruction {
				instrs << m.instrs[val.index]
			}
		}
	}
	return instrs
}

// ret_operand supports ret operand handling for v3 tests.
fn ret_operand(m &ssa.Module, name string) ssa.ValueID {
	for instr in func_instrs(m, name) {
		if instr.op == .ret && instr.operands.len == 1 {
			return instr.operands[0]
		}
	}
	assert false
	return ssa.ValueID(0)
}

// has_call_to reports whether has call to applies in v3 tests.
fn has_call_to(m &ssa.Module, fn_name string, callee string) bool {
	for instr in func_instrs(m, fn_name) {
		if instr.op != .call || instr.operands.len == 0 {
			continue
		}
		fn_ref := m.values[instr.operands[0]]
		if fn_ref.kind == .func_ref && fn_ref.name == callee {
			return true
		}
	}
	return false
}

// has_instr_op reports whether has instr op applies in v3 tests.
fn has_instr_op(m &ssa.Module, fn_name string, op ssa.OpCode) bool {
	for instr in func_instrs(m, fn_name) {
		if instr.op == op {
			return true
		}
	}
	return false
}

// has_alloca_len_const reports whether has alloca len const applies in v3 tests.
fn has_alloca_len_const(m &ssa.Module, fn_name string, len string) bool {
	for instr in func_instrs(m, fn_name) {
		if instr.op != .alloca || instr.operands.len == 0 {
			continue
		}
		len_value := m.values[instr.operands[0]]
		if len_value.kind == .constant && len_value.name == len {
			return true
		}
	}
	return false
}

// test_if_expression_builds_phi validates if expression builds phi behavior in v3 tests.
fn test_if_expression_builds_phi() {
	m := build_source('if_phi', '
fn pick(flag bool) int {
	return if flag {
		1
	} else {
		2
	}
}
')
	mut found_phi := false
	for instr in func_instrs(m, 'pick') {
		if instr.op == .phi {
			found_phi = true
			assert instr.operands.len == 4
		}
	}
	assert found_phi
}

// test_match_expression_builds_phi validates match expression builds phi behavior in v3 tests.
fn test_match_expression_builds_phi() {
	m := build_source('match_phi', '
fn pick(x int) int {
	return match x {
		1 {
			10
		}
		2, 3 {
			20
		}
		else {
			30
		}
	}
}
')
	mut found_phi := false
	for instr in func_instrs(m, 'pick') {
		if instr.op == .phi {
			found_phi = true
			assert instr.operands.len == 6
		}
	}
	assert found_phi
}

// test_string_infix_lowers_to_runtime_calls validates this v3 regression case.
fn test_string_infix_lowers_to_runtime_calls() {
	m := build_source('string_infix', '
fn join(a string, b string) string {
	return a + b
}

fn same(a string, b string) bool {
	return a == b
}
')
	assert has_call_to(m, 'join', 'string__plus')
	assert has_call_to(m, 'same', 'string__eq')
}

// test_c_fn_decl_registers_extern_signature validates this v3 regression case.
fn test_c_fn_decl_registers_extern_signature() {
	m := build_source('c_fn_decl', '
fn C.abs(x int) int

fn main() {
	_ := C.abs(-3)
}
')
	f := find_func(m, 'C.abs')
	assert f.is_c_extern
	ret_type := m.type_store.types[f.typ]
	assert ret_type.kind == .int_t
	assert ret_type.width == 32
}

// test_function_parameter_call_lowers_to_call_indirect validates this v3 regression case.
fn test_function_parameter_call_lowers_to_call_indirect() {
	m := build_source('call_indirect', '
fn add(a int, b int) int {
	return a + b
}

fn apply(f fn (int, int) int, x int, y int) int {
	return f(x, y)
}
')
	mut found_indirect := false
	for instr in func_instrs(m, 'apply') {
		if instr.op == .call_indirect {
			found_indirect = true
			assert instr.operands.len == 3
		}
	}
	assert found_indirect
}

// test_label_and_goto_lower_to_jump_blocks validates this v3 regression case.
fn test_label_and_goto_lower_to_jump_blocks() {
	m := build_source('label_goto', '
fn jumpy() int {
	mut x := 0
	goto done
	x = 1
done:
	return x
}
')
	mut found_jump := false
	for instr in func_instrs(m, 'jumpy') {
		if instr.op == .jmp {
			found_jump = true
		}
	}
	assert found_jump
}

// test_const_identifier_lowers_to_const_value validates this v3 regression case.
fn test_const_identifier_lowers_to_const_value() {
	m := build_source('const_ident', '
const answer = 42

fn get_answer() int {
	return answer
}
')
	ret := m.values[ret_operand(m, 'get_answer')]
	assert ret.kind == .constant
	assert ret.name == '42'
}

// test_enum_selector_lowers_to_const_value validates this v3 regression case.
fn test_enum_selector_lowers_to_const_value() {
	m := build_source('enum_selector', '
enum Color {
	red
	green = 5
	blue
}

fn get_blue() int {
	return int(Color.blue)
}
')
	ret_id := ret_operand(m, 'get_blue')
	ret := m.values[ret_id]
	if ret.kind == .constant {
		assert ret.name == '6'
	} else {
		assert ret.kind == .instruction
		instr := m.instrs[ret.index]
		assert instr.operands.len > 0
		cast_input := m.values[instr.operands[0]]
		assert cast_input.kind == .constant
		assert cast_input.name == '6'
	}
}

// test_float_literal_uses_float_type validates this v3 regression case.
fn test_float_literal_uses_float_type() {
	m := build_source('float_literal', '
fn get_float() f64 {
	return 1.25
}
')
	ret := m.values[ret_operand(m, 'get_float')]
	typ := m.type_store.types[ret.typ]
	assert typ.kind == .float_t
	assert typ.width == 64
}

// test_integer_casts_emit_conversion_ops validates this v3 regression case.
fn test_integer_casts_emit_conversion_ops() {
	m := build_source('int_casts', '
fn narrow(x i64) u8 {
	return u8(x)
}

fn widen(x u8) i64 {
	return i64(x)
}

fn widen_signed(x int) i64 {
	return i64(x)
}
')
	mut found_trunc := false
	for instr in func_instrs(m, 'narrow') {
		if instr.op == .trunc {
			found_trunc = true
			assert m.type_store.types[instr.typ].width == 8
		}
	}
	assert found_trunc

	mut found_zext := false
	for instr in func_instrs(m, 'widen') {
		if instr.op == .zext {
			found_zext = true
			assert m.type_store.types[instr.typ].width == 64
		}
	}
	assert found_zext
	assert has_instr_op(m, 'widen_signed', .sext)
}

// test_unsigned_integer_infix_uses_unsigned_ops validates this v3 regression case.
fn test_unsigned_integer_infix_uses_unsigned_ops() {
	m := build_source('unsigned_ops', '
fn div_u(x u32, y u32) u32 {
	return x / y
}

fn rem_u(x u32, y u32) u32 {
	return x % y
}

fn cmp_u(x u32, y u32) bool {
	return x < y
}

fn cmp_s(x int, y int) bool {
	return x < y
}
')
	assert has_instr_op(m, 'div_u', .udiv)
	assert has_instr_op(m, 'rem_u', .urem)
	assert has_instr_op(m, 'cmp_u', .ult)
	assert has_instr_op(m, 'cmp_s', .lt)
	assert !has_instr_op(m, 'cmp_s', .ult)
}

// test_fixed_array_const_length_is_resolved validates this v3 regression case.
fn test_fixed_array_const_length_is_resolved() {
	mut used_fns := map[string]bool{}
	used_fns['make_array'] = true
	used_fns['main.make_array'] = true
	m := build_source_with_used('fixed_array_const_len', '
const fixed_len = 4

fn make_array() int {
	mut values := [fixed_len]int{}
	values[0] = 7
	return values[0]
}
',
		used_fns)
	assert has_alloca_len_const(m, 'make_array', '4')
}

// test_string_range_does_not_lower_to_array_slice validates this v3 regression case.
fn test_string_range_does_not_lower_to_array_slice() {
	m := build_source('string_range', '
fn cut(s string) string {
	return s[1..3]
}
')
	assert !has_call_to(m, 'cut', 'array_slice')
}

// test_array_first_last_load_elements validates this v3 regression case.
fn test_array_first_last_load_elements() {
	m := build_source('array_first_last', '
fn first_value(values []int) int {
	return values.first()
}

fn last_value(values []int) int {
	return values.last()
}
')
	assert has_call_to(m, 'first_value', 'array_get')
	assert has_call_to(m, 'last_value', 'array_get')
}