import os
import rand

const vexe = @VEXE

struct Foo {
mut:
	a int
}

fn Foo.new_non_ref() Foo {
	return Foo{}
}

fn Foo.new_ref() &Foo {
	return &Foo{}
}

fn get_map_non_ref() map[int]int {
	return {
		0: 0
	}
}

fn get_map_ref() &map[int]int {
	return &{
		0: 0
	}
}

fn get_array() []int {
	return [0]
}

fn test_assign_from_call_expr() {
	shared foo1 := Foo.new_non_ref()
	rlock foo1 {
		assert foo1.a == 0
	}

	shared foo2 := Foo.new_ref()
	rlock foo2 {
		assert foo2.a == 0
	}

	shared map1 := get_map_non_ref()
	rlock map1 {
		assert map1[0] == 0
	}

	shared map2 := get_map_ref()
	rlock map2 {
		assert map2[0] == 0
	}

	shared arr := get_array()
	rlock arr {
		assert arr[0] == 0
	}
}

fn get_int_array(arr [3]int) []int {
	return [arr[0], arr[1], arr[2]]
}

fn get_foo_array(arr [3]Foo) []Foo {
	return [arr[0], arr[1], arr[2]]
}

fn test_assign_from_call_expr_with_fixed_array() {
	shared arr_int := get_int_array([1, 2, 3]!)
	lock arr_int {
		assert arr_int == [1, 2, 3]
	}

	shared arr_foo := get_foo_array([Foo.new_non_ref(), Foo.new_non_ref(),
		Foo.new_non_ref()]!)
	lock arr_foo {
		assert arr_foo == [Foo.new_non_ref(), Foo.new_non_ref(),
			Foo.new_non_ref()]
	}
}

fn test_re_assign_array() {
	shared arr := [1, 2, 3]
	lock arr {
		arr[0] = 0
		assert arr == [0, 2, 3]
		arr = [0, 0, 0]
		assert arr == [0, 0, 0]
	}
}

fn test_re_assign_struct() {
	shared st := Foo{}
	lock st {
		st.a = 1
		assert st.a == 1
		st = Foo{2}
		assert st.a == 2
	}
}

fn test_re_assign_map() {
	shared m := map[int]int{}
	lock m {
		m[0] = 0
		assert m[0] == 0
		m = {
			0: 1
		}
		assert m[0] == 1
	}
}

struct SharedAssignStructA {
	commands []string
}

struct SharedAssignStructB {
	s SharedAssignStructA
}

fn test_assign_from_pointer_ident_with_nested_struct() {
	mut src := &SharedAssignStructB{}
	shared shared_copy := src
	shared spread_copy := SharedAssignStructB{
		...src
	}
	rlock shared_copy, spread_copy {
		assert shared_copy.s.commands == []string{}
		assert spread_copy.s.commands == []string{}
	}
}

fn test_assign_from_pointer_ident_emits_shared_copy_in_c_output() {
	tmp_dir := os.join_path(os.vtmp_dir(), 'shared_assign_cgen_${rand.ulid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'main.v')
	c_path := os.join_path(tmp_dir, 'main.c')
	source := [
		'module main',
		'',
		'struct StructA {',
		'\tcommands []string',
		'}',
		'',
		'struct StructB {',
		'\ts StructA',
		'}',
		'',
		'fn main() {',
		'\tmut src := &StructB{}',
		'\tshared copy := src',
		'\trlock copy {',
		'\t\tprintln(copy.s)',
		'\t}',
		'}',
	].join_lines()
	os.write_file(source_path, source) or { panic(err) }
	res :=
		os.execute('${os.quoted_path(vexe)} -o ${os.quoted_path(c_path)} ${os.quoted_path(source_path)}')
	assert res.exit_code == 0, res.output
	csrc := os.read_file(c_path) or { panic(err) }
	assert csrc.contains('__shared__main__StructB* copy = (__shared__main__StructB*)__dup__shared__main__StructB')
	assert csrc.contains('*src}, sizeof(__shared__main__StructB))')
	assert !csrc.contains('__shared__main__StructB* copy = src;')
}