import os
import v3.flat
import v3.gen.c as cgen
import v3.markused
import v3.parser
import v3.pref
import v3.transform
import v3.types

// gen_c_for_source emits c for source output for v3 tests.
fn gen_c_for_source(name string, source string) string {
	src := os.join_path(os.temp_dir(), 'v3_${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.diagnose_unknown_calls = true
	tc.diagnostic_files[src] = true
	tc.check_semantics()
	assert tc.errors.len == 0, tc.errors.str()
	transform.transform(mut a, &tc)
	tc.annotate_types()
	used_fns := markused.mark_used(a, tc)
	mut g := cgen.FlatGen.new()
	return g.gen_with_used_options(a, used_fns, &tc, true)
}

// gen_c_for_sources emits c for sources output for v3 tests.
fn gen_c_for_sources(name string, files map[string]string) string {
	root := os.join_path(os.temp_dir(), 'v3_${name}')
	if os.exists(root) {
		os.rmdir_all(root) or { panic(err) }
	}
	os.mkdir_all(root) or { panic(err) }
	mut paths := []string{}
	mut rels := files.keys()
	rels.sort()
	for rel in rels {
		path := os.join_path(root, rel)
		os.mkdir_all(os.dir(path)) or { panic(err) }
		os.write_file(path, files[rel]) or { panic(err) }
		paths << path
	}
	prefs := pref.new_preferences()
	mut p := parser.Parser.new(prefs)
	mut a := p.parse_files(paths)
	mut tc := types.TypeChecker.new(a)
	tc.collect(a)
	tc.diagnose_unknown_calls = true
	for path in paths {
		tc.diagnostic_files[path] = true
	}
	tc.check_semantics()
	assert tc.errors.len == 0, tc.errors.str()
	transform.transform(mut a, &tc)
	tc.annotate_types()
	used_fns := markused.mark_used(a, tc)
	mut g := cgen.FlatGen.new()
	return g.gen_with_used_options(a, used_fns, &tc, true)
}

// gen_c_for_source_with_scalar_zero_decl supports gen_c_for_source_with_scalar_zero_decl handling.
fn gen_c_for_source_with_scalar_zero_decl(name string, source string, decl_name string, decl_type string) string {
	src := os.join_path(os.temp_dir(), 'v3_${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.diagnose_unknown_calls = true
	tc.diagnostic_files[src] = true
	tc.check_semantics()
	assert tc.errors.len == 0, tc.errors.str()
	transform.transform(mut a, &tc)
	tc.annotate_types()
	zero_id := a.add_node(flat.Node{
		kind:  .int_literal
		value: '0'
	})
	mut patched := false
	for i, node in a.nodes {
		if node.kind != .decl_assign || node.children_count != 2 {
			continue
		}
		lhs_id := a.child(&node, 0)
		lhs := a.nodes[int(lhs_id)]
		if lhs.kind == .ident && lhs.value == decl_name {
			a.nodes[i].typ = decl_type
			a.children[int(node.children_start) + 1] = zero_id
			patched = true
		}
	}
	assert patched
	used_fns := markused.mark_used(a, tc)
	mut g := cgen.FlatGen.new()
	return g.gen_with_used_options(a, used_fns, &tc, true)
}

// test_c_global_pointer_arg_is_not_addressed_again validates this v3 regression case.
fn test_c_global_pointer_arg_is_not_addressed_again() {
	c_code := gen_c_for_source('c_global_stdout_arg', '__global C.stdout &C.FILE

fn set_stream_unbuffered(stream &C.FILE) {}

fn main() {
	set_stream_unbuffered(C.stdout)
}
')
	assert c_code.contains('set_stream_unbuffered(stdout);')
	assert !c_code.contains('set_stream_unbuffered(&stdout);')
}

// test_mut_static_local_decl_codegen validates this v3 regression case.
fn test_mut_static_local_decl_codegen() {
	c_code := gen_c_for_source('static_local_decl', 'fn next_value() int {
	mut static x := 0
	x++
	return x
}

fn main() {
	_ := next_value()
}
')
	assert c_code.contains('static int x = 0;')
}

// test_aggregate_globals_are_brace_zero_initialized validates this v3 regression case.
fn test_aggregate_globals_are_brace_zero_initialized() {
	c_code := gen_c_for_source('aggregate_global_zero_init', 'const zero_len = 1 - 1

struct Box {
	value int
}

struct ZeroLeading {
	z [0]int
	value int
}

struct NestedZeroLeading {
	zero ZeroLeading
	value int
}

struct ZeroLeadingConst {
	z [zero_len]int
	value int
}

__global (
	names []string
	lookup map[string]int
	box Box
	empty [0]int
	slots [2]int
	zero ZeroLeading
	nested NestedZeroLeading
	zero_slots [2]ZeroLeading
	const_empty [zero_len]int
	const_zero ZeroLeadingConst
	const_zero_slots [2]ZeroLeadingConst
)

fn main() {}
')
	assert c_code.contains('Array names = {0};')
	assert c_code.contains('map lookup = {0};')
	assert c_code.contains('Box box = {0};')
	assert c_code.contains('int empty[0];')
	assert c_code.contains('int slots[2] = {0};')
	assert c_code.contains('\nZeroLeading zero;\n')
	assert c_code.contains('\nNestedZeroLeading nested;\n')
	assert c_code.contains('\nZeroLeading zero_slots[2];\n')
	assert c_code.contains('\nint const_empty[0];\n')
	assert c_code.contains('\nZeroLeadingConst const_zero;\n')
	assert c_code.contains('\nZeroLeadingConst const_zero_slots[2];\n')
	assert !c_code.contains('Array names = 0;')
	assert !c_code.contains('map lookup = 0;')
	assert !c_code.contains('Box box = 0;')
	assert !c_code.contains('int empty[0] = {0};')
	assert !c_code.contains('ZeroLeading zero = {0};')
	assert !c_code.contains('NestedZeroLeading nested = {0};')
	assert !c_code.contains('ZeroLeading zero_slots[2] = {0};')
	assert !c_code.contains('\nint const_empty[0] = {0};\n')
	assert !c_code.contains('ZeroLeadingConst const_zero = {0};')
	assert !c_code.contains('ZeroLeadingConst const_zero_slots[2] = {0};')
}

// test_imported_zero_length_leading_field_global_uses_decl_only validates this v3 regression case.
fn test_imported_zero_length_leading_field_global_uses_decl_only() {
	c_code := gen_c_for_sources('imported_zero_leading_global', {
		'main.v':      'module main

import moda

__global imported moda.ImportedZero
__global imported_slots [2]moda.ImportedZero

fn main() {}
'
		'moda/moda.v': 'module moda

const zero_len = 1 - 1

pub struct ImportedZero {
	z [zero_len]int
	value int
}
'
	})
	assert c_code.contains('\nmoda__ImportedZero imported;\n')
	assert c_code.contains('\nmoda__ImportedZero imported_slots[2];\n')
	assert !c_code.contains('moda__ImportedZero imported = {0};')
	assert !c_code.contains('moda__ImportedZero imported_slots[2] = {0};')
}

// test_aggregate_decl_with_scalar_zero_uses_brace_initializer validates this v3 regression case.
fn test_aggregate_decl_with_scalar_zero_uses_brace_initializer() {
	c_code := gen_c_for_source_with_scalar_zero_decl('aggregate_decl_scalar_zero', 'struct Box {
	value int
}

fn main() {
	box := Box{}
	_ = box.value
}
',
		'box', 'Box')
	assert c_code.contains('Box box = {0};'), c_code
	assert !c_code.contains('Box box = 0;')
}

// test_defer_capture_aggregate_decl_with_scalar_zero_uses_compound_literal
// validates this v3 regression case.
fn test_defer_capture_aggregate_decl_with_scalar_zero_uses_compound_literal() {
	c_code := gen_c_for_source_with_scalar_zero_decl('defer_capture_aggregate_decl_scalar_zero', 'struct Box {
	value int
}

fn main() {
	box := Box{}
	defer(fn) {
		_ = box.value
	}
}
',
		'box', 'Box')
	assert c_code.contains('box = (Box){0};'), c_code
	assert !c_code.contains('box = {0};')
}