import os
import time

const vexe = os.getenv('VEXE')
const vroot = os.dir(vexe)
const tfolder = os.join_path(os.vtmp_dir(), 'os_process_tests')
const test_os_process = os.join_path(tfolder, 'test_os_process.exe')
const test_os_process_source = os.join_path(vroot, 'cmd/tools/test_os_process.v')
const echo_process_exe_filename = os.join_path(tfolder, 'echo.exe')
const echo_process_source_filename = os.join_path(tfolder, 'echo.v')
const delayed_output_exe_filename = os.join_path(tfolder, 'delayed_output.exe')
const delayed_output_source_filename = os.join_path(tfolder, 'delayed_output.v')
const utf16le_output_exe_filename = os.join_path(tfolder, 'utf16le_output.exe')
const utf16le_output_source_filename = os.join_path(tfolder, 'utf16le_output.v')
const stdin_exit_exe_filename = os.join_path(tfolder, 'stdin_exit.exe')
const stdin_exit_source_filename = os.join_path(tfolder, 'stdin_exit.v')
const argv_echo_exe_filename = os.join_path(tfolder, 'argv_echo.exe')
const argv_echo_source_filename = os.join_path(tfolder, 'argv_echo.v')
const echo_process_source_code = '
module main
import io
import os

fn main() {
	unbuffer_stdout()
	mut reader := io.new_buffered_reader(reader: os.stdin(), cap: 1)
	for {
		line := reader.read_line()!
		println(line)
		eprintln(line)
	}
}
'

const delayed_output_source_code = '
module main
import time

fn main() {
	unbuffer_stdout()
	time.sleep(500 * time.millisecond)
	println("late")
	time.sleep(300 * time.millisecond)
}
'

const utf16le_output_source_code = '
module main
import os

fn main() {
	payload := [u8(`O`), 0, `K`, 0, u8(10), 0]
	mut out := os.stdout()
	out.write(payload) or { panic(err) }
}
'

const stdin_exit_source_code = '
module main
import os

fn main() {
	_ = os.get_raw_line()
	exit(7)
}
'

const argv_echo_source_code = '
module main
import os

fn main() {
	for arg in os.args[1..] {
		println(arg)
	}
}
'

const echo_wait_timeout = 5 // seconds

fn testsuite_begin() {
	os.rmdir_all(tfolder) or {}
	os.mkdir_all(tfolder)!
	if os.getenv('WINE_TEST_OS_PROCESS_EXE') != '' {
		// Make it easier to run the test under wine emulation, by just
		// prebuilding the executable with:
		//   v -os windows -o x.exe cmd/tools/test_os_process.v
		//   WINE_TEST_OS_PROCESS_EXE=x.exe ./v -os windows vlib/os/process_test.v
		os.cp(os.getenv('WINE_TEST_OS_PROCESS_EXE'), test_os_process)!
	} else {
		os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(test_os_process)} ${os.quoted_path(test_os_process_source)}')
	}
	assert os.exists(test_os_process)

	os.write_file(echo_process_source_filename, echo_process_source_code)!
	os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(echo_process_exe_filename)} ${os.quoted_path(echo_process_source_filename)}')
	assert os.exists(echo_process_exe_filename)

	os.write_file(delayed_output_source_filename, delayed_output_source_code)!
	os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(delayed_output_exe_filename)} ${os.quoted_path(delayed_output_source_filename)}')
	assert os.exists(delayed_output_exe_filename)

	os.write_file(utf16le_output_source_filename, utf16le_output_source_code)!
	os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(utf16le_output_exe_filename)} ${os.quoted_path(utf16le_output_source_filename)}')
	assert os.exists(utf16le_output_exe_filename)

	os.write_file(stdin_exit_source_filename, stdin_exit_source_code)!
	os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(stdin_exit_exe_filename)} ${os.quoted_path(stdin_exit_source_filename)}')
	assert os.exists(stdin_exit_exe_filename)

	os.write_file(argv_echo_source_filename, argv_echo_source_code)!
	os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(argv_echo_exe_filename)} ${os.quoted_path(argv_echo_source_filename)}')
	assert os.exists(argv_echo_exe_filename)
}

fn testsuite_end() {
	os.rmdir_all(tfolder) or {}
}

fn test_getpid() {
	eprintln(@FN)
	pid := os.getpid()
	eprintln('current pid: ${pid}')
	assert pid != 0
}

fn test_set_work_folder() {
	eprintln(@FN)
	new_work_folder := os.real_path(os.temp_dir())
	parent_working_folder := os.getwd()
	dump(new_work_folder)
	dump(parent_working_folder)
	if new_work_folder == parent_working_folder {
		eprintln('... skipping ${@METHOD} because the working folder is the temporary one')
		return
	}
	mut p := os.new_process(test_os_process)
	p.set_args(['-show_wd', '-target', 'stdout'])
	p.set_work_folder(new_work_folder)
	p.set_redirect_stdio()
	p.wait()
	assert p.code == 0
	output := p.stdout_slurp().trim_space()
	p.close()
	$if trace_process_output ? {
		eprintln('p output: "${output}"')
	}
	child_work_folder := output.find_between('stdout, WORK_DIR=', '\n').trim_space()
	dump(child_work_folder)
	assert child_work_folder == new_work_folder
	new_parent_work_folder := os.getwd()
	dump(new_parent_work_folder)
	assert new_parent_work_folder == parent_working_folder
	assert new_parent_work_folder != child_work_folder
}

fn test_set_environment() {
	eprintln(@FN)
	mut p := os.new_process(test_os_process)
	p.set_args(['-show_env', '-target', 'stdout'])
	p.set_environment({
		'V_OS_TEST_PORT': '1234567890'
	})
	p.set_redirect_stdio()
	p.wait()
	assert p.code == 0
	output := p.stdout_slurp().trim_space()
	p.close()
	$if trace_process_output ? {
		eprintln('p output: "${output}"')
	}
	assert output.contains('V_OS_TEST_PORT=1234567890'), output
}

fn test_new_process_uses_exact_executable_path_when_folder_contains_spaces() {
	$if !windows {
		return
	}
	eprintln(@FN)
	spaced_dir := os.join_path(tfolder, 'spawn path with spaces')
	os.rmdir_all(spaced_dir) or {}
	os.mkdir_all(spaced_dir)!
	spaced_exe := os.join_path(spaced_dir, 'test os process.exe')
	os.cp(test_os_process, spaced_exe)!

	stale_source := os.join_path(tfolder, 'spawn.v')
	stale_exe := os.join_path(tfolder, 'spawn.exe')
	os.write_file(stale_source, 'fn main() {\n\tprintln("stale-prefix-exe")\n}\n')!
	assert os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(stale_exe)} ${os.quoted_path(stale_source)}') == 0

	mut p := os.new_process(spaced_exe)
	p.set_args(['-show_env', '-target', 'stdout'])
	p.set_environment({
		'V_OS_TEST_PORT': 'exact_path'
	})
	p.set_redirect_stdio()
	p.wait()
	assert p.code == 0
	output := p.stdout_slurp().trim_space()
	errors := p.stderr_slurp().trim_space()
	p.close()
	assert output.contains('V_OS_TEST_PORT=exact_path'), 'stdout:\n${output}\nstderr:\n${errors}'
	assert !output.contains('stale-prefix-exe'), output
}

fn test_new_process_passes_spaced_path_args_on_windows() {
	$if !windows {
		return
	}
	eprintln(@FN)
	file_arg := os.join_path(tfolder, 'path with spaces', 'child file.txt')
	dir_arg := os.join_path(tfolder, 'path with spaces') + '\\'
	quoted_arg := 'value with "quotes"'
	mut p := os.new_process(argv_echo_exe_filename)
	p.set_args([file_arg, dir_arg, quoted_arg, 'marker'])
	p.set_redirect_stdio()
	p.wait()
	assert p.code == 0
	output := p.stdout_slurp().trim_space()
	errors := p.stderr_slurp().trim_space()
	p.close()
	lines := output.split_into_lines()
	assert lines.len == 4, 'stdout:\n${output}\nstderr:\n${errors}'
	assert lines[0] == file_arg
	assert lines[1] == dir_arg
	assert lines[2] == quoted_arg
	assert lines[3] == 'marker'
}

fn test_new_process_uses_path_for_bare_command_names() {
	$if windows {
		return
	}
	eprintln(@FN)
	original_path := os.getenv('PATH')
	defer {
		os.setenv('PATH', original_path, true)
	}
	path_dir := os.join_path(tfolder, 'path_bin')
	os.rmdir_all(path_dir) or {}
	os.mkdir_all(path_dir)!
	path_exe := os.join_path(path_dir, 'process_from_path.exe')
	os.cp(test_os_process, path_exe)!
	os.setenv('PATH', '${path_dir}${os.path_delimiter}${original_path}', true)
	mut p := os.new_process('process_from_path.exe')
	p.set_args(['-exitcode', '7'])
	p.set_work_folder(os.real_path(os.temp_dir()))
	p.wait()
	assert p.status == .exited
	assert p.code == 7
	p.close()
}

fn test_run() {
	eprintln(@FN)
	mut p := os.new_process(test_os_process)
	p.set_args(['-timeout_ms', '150', '-period_ms', '50'])
	p.run()
	assert p.status == .running
	assert p.pid > 0
	assert p.pid != os.getpid()
	mut i := 0
	for {
		if !p.is_alive() {
			break
		}
		$if trace_process_output ? {
			os.system('ps -opid= -oppid= -ouser= -onice= -of= -ovsz= -orss= -otime= -oargs= -p ${p.pid}')
		}
		time.sleep(50 * time.millisecond)
		i++
	}
	p.wait()
	assert p.code == 0
	assert p.status == .exited

	eprintln('polling iterations: ${i}')
	assert i < 50
	p.close()
}

fn test_wait() {
	eprintln(@FN)
	mut p := os.new_process(test_os_process)
	assert p.status != .exited
	p.wait()
	assert p.status == .exited
	assert p.code == 0
	assert p.pid != os.getpid()
	p.close()
}

fn test_slurping_output() {
	eprintln(@FN)
	mut p := os.new_process(test_os_process)
	p.set_args(['-timeout_ms', '600', '-period_ms', '50'])
	p.set_redirect_stdio()
	assert p.status != .exited
	p.wait()
	assert p.status == .exited
	assert p.code == 0
	output := p.stdout_slurp().trim_space()
	errors := p.stderr_slurp().trim_space()
	p.close()
	$if trace_process_output ? {
		eprintln('---------------------------')
		eprintln('p output: "${output}"')
		eprintln('p errors: "${errors}"')
		eprintln('---------------------------')
	}
	assert output.contains('stdout, 1'), output
	assert output.contains('stdout, 2'), output
	assert output.contains('stdout, 3'), output
	assert output.contains('stdout, 4'), output
	assert errors.contains('stderr, 1'), errors
	assert errors.contains('stderr, 2'), errors
	assert errors.contains('stderr, 3'), errors
	assert errors.contains('stderr, 4'), errors
}

fn echo(mut p os.Process, echo_string string) {
	// append `\n`, as `echo.exe` use `read_line()`
	p.stdin_write(echo_string + '\n')
	mut got_echo_back := false
	mut echo_back := ''
	mut timeout := 0
	for p.is_alive() && timeout < echo_wait_timeout * 1000 / 50 {
		echo_back = p.stdout_read()
		if echo_back.len > 0 {
			got_echo_back = true
			break
		}
		time.sleep(50 * time.millisecond)
		timeout++
	}
	assert got_echo_back
	assert echo_back.trim_space() == echo_string.trim_space()
}

fn test_stdin_write() {
	eprintln(@FN)
	echo_exe := $if windows { echo_process_exe_filename } $else { os.find_abs_path_of_executable('cat') or {
			'/bin/cat'} }
	mut p := os.new_process(echo_exe)
	p.set_redirect_stdio()
	assert p.status != .exited
	p.run()
	echo(mut p, 'hello')
	echo(mut p, 'world')
	p.signal_kill()
	p.close()
}

fn test_close_before_wait_preserves_exit_code() {
	eprintln(@FN)
	mut p := os.new_process(stdin_exit_exe_filename)
	p.set_redirect_stdio()
	p.run()
	p.stdin_write('hello\n')
	p.close()
	p.wait()
	assert p.status == .exited
	assert p.code == 7
	p.close()
}

fn test_stdout_read_returns_immediately_when_no_data_is_pending() {
	eprintln(@FN)
	mut p := os.new_process(delayed_output_exe_filename)
	p.set_redirect_stdio()
	p.run()
	defer {
		if p.is_alive() {
			p.signal_kill()
		}
		p.close()
	}
	mut sw := time.new_stopwatch()
	output := p.stdout_read()
	elapsed_ms := sw.elapsed().milliseconds()
	assert output == ''
	assert elapsed_ms < 300, 'stdout_read blocked for ${elapsed_ms}ms'
	p.wait()
	assert p.stdout_slurp().contains('late')
}

fn test_pipe_read_while_process_is_alive() {
	eprintln(@FN)
	mut p := os.new_process(test_os_process)
	p.set_args(['-timeout_ms', '600', '-period_ms', '50'])
	p.set_redirect_stdio()
	p.run()
	mut stdout_output := ''
	mut stderr_output := ''
	mut timeout := 0
	for p.is_alive() && timeout < echo_wait_timeout * 1000 / 20 {
		if out := p.pipe_read(.stdout) {
			stdout_output += out
		}
		if err := p.pipe_read(.stderr) {
			stderr_output += err
		}
		if stdout_output.len > 0 && stderr_output.len > 0 {
			break
		}
		time.sleep(20 * time.millisecond)
		timeout++
	}
	p.wait()
	p.close()
	assert stdout_output.contains('stdout, start'), stdout_output
	assert stderr_output.contains('stderr, start'), stderr_output
}

fn test_pipe_read_returns_none_after_eof() {
	eprintln(@FN)
	mut p := os.new_process(test_os_process)
	p.set_args(['-timeout_ms', '120', '-period_ms', '50'])
	p.set_redirect_stdio()
	p.wait()
	assert p.code == 0
	_ = p.stdout_slurp()
	_ = p.stderr_slurp()
	assert !p.is_pending(.stdout)
	assert !p.is_pending(.stderr)
	if out := p.pipe_read(.stdout) {
		assert false, 'expected none after stdout EOF, got `${out}`'
	}
	if err := p.pipe_read(.stderr) {
		assert false, 'expected none after stderr EOF, got `${err}`'
	}
	p.close()
}

fn test_slurping_utf16le_output_on_windows() {
	if os.user_os() != 'windows' {
		return
	}
	mut p := os.new_process(utf16le_output_exe_filename)
	p.set_redirect_stdio()
	p.wait()
	assert p.code == 0
	output := p.stdout_slurp()
	errors := p.stderr_slurp()
	p.close()
	assert output == 'OK\n', output
	assert errors == ''
}