import os
import time

const vexe = @VEXE
const source_run_poll_interval = 50 * time.millisecond
const source_run_timeout_ticks = 600

struct SourceRunResult {
	code   int
	output string
}

fn run_source_with_timeout(source_name string, source string) !SourceRunResult {
	base_dir := os.join_path(os.vtmp_dir(), '${source_name}_${os.getpid()}')
	source_path := os.join_path(base_dir, '${source_name}.v')
	os.rmdir_all(base_dir) or {}
	os.mkdir_all(base_dir)!
	defer {
		os.rmdir_all(base_dir) or {}
	}
	os.write_file(source_path, source)!
	mut p := os.new_process(vexe)
	p.set_args(['run', source_path])
	p.set_redirect_stdio()
	// `v run` forks a grandchild for the compiled binary. On timeout, killing only the
	// child V leaves that grandchild alive holding the stdout/stderr pipe ends, which
	// makes stdout_slurp() block forever waiting for EOF (notably on musl, where the
	// nested rwlock simply hangs instead of returning EDEADLK). Kill the whole pgroup.
	p.use_pgroup = true
	p.run()
	mut timeout_ticks := 0
	for p.is_alive() && timeout_ticks < source_run_timeout_ticks {
		time.sleep(source_run_poll_interval)
		timeout_ticks++
	}
	if p.is_alive() {
		p.signal_pgkill()
		p.wait()
		stdout := p.stdout_slurp()
		stderr := p.stderr_slurp()
		p.close()
		return error('timed out\nstdout:\n${stdout}\nstderr:\n${stderr}')
	}
	p.wait()
	stdout := p.stdout_slurp()
	stderr := p.stderr_slurp()
	code := p.code
	p.close()
	return SourceRunResult{
		code:   code
		output: stdout + stderr
	}
}

fn test_nested_shared_lock_fails_without_hanging() {
	$if windows {
		return
	}
	source := [
		'module main',
		'',
		'fn main() {',
		'\tshared connections := []int{}',
		'\tlock_function(shared connections)',
		'\tlock connections {',
		"\t\tprintln('unreachable')",
		'\t}',
		'}',
		'',
		'fn lock_function(shared connections []int) {',
		'\tnested_lock_function := fn [shared connections] () {',
		'\t\tlock connections {',
		"\t\t\tprintln('unreachable nested')",
		'\t\t}',
		'\t}',
		'\tlock connections {',
		'\t\tnested_lock_function()',
		'\t}',
		'}',
	].join_lines()
	result := run_source_with_timeout('shared_nested_lock_runtime', source) or {
		assert false, 'nested shared lock hung\n${err}'
		return
	}
	assert result.code != 0, 'expected nested shared lock failure, got output:\n${result.output}'
	assert result.output.contains('Resource deadlock avoided'), result.output
}

fn test_shared_generic_heap_method_call_does_not_hang() {
	source := [
		'module main',
		'',
		'@[heap]',
		'struct Topic[T] {',
		'mut:',
		'\tlist List[T]',
		'}',
		'',
		'@[heap]',
		'struct List[T] {',
		'mut:',
		'\tnode ?&Node[T]',
		'}',
		'',
		'@[heap]',
		'struct Node[T] {',
		'mut:',
		'\tdata T',
		'\tnext ?&Node[T]',
		'}',
		'',
		'fn Topic.new[T]() Topic[T] {',
		'\treturn Topic[T]{}',
		'}',
		'',
		'fn (mut l List[T]) push(val T) {',
		'\tmut node := Node[T]{',
		'\t\tdata: val',
		'\t}',
		'\tl.node = &node',
		'}',
		'',
		'fn (shared t Topic[T]) add(mut data T) {',
		'\tlock t {',
		'\t\tt.list.push(data)',
		'\t}',
		'}',
		'',
		'fn main() {',
		'\tshared topic := Topic.new[string]()',
		"\tmut data := 'something'",
		'\ttopic.add(mut data)',
		"\tprintln('done')",
		'}',
	].join_lines()
	result := run_source_with_timeout('shared_generic_heap_method_call', source) or {
		assert false, 'shared generic heap method call hung\n${err}'
		return
	}
	assert result.code == 0, result.output
	assert result.output.contains('done'), result.output
}