// vtest build: !(os_id_ubuntu? && musl?) && !sanitized_job?
import os

const vexe = @VEXE
const gcc_path = os.find_abs_path_of_executable('gcc') or { '' }
const cdefs_h_32bit_exists = os.exists('/usr/include/i386-linux-gnu/sys/cdefs.h')

fn separator() {
	eprintln('-'.repeat(30))
}

fn test_trace_fns() {
	os.chdir(@VEXEROOT)!
	folder := os.join_path('vlib', 'v', 'tests', 'testdata', 'trace_calls')
	fpath := os.join_path(folder, 'single_println.vv')
	should_match_fpath := os.join_path(folder, 'single_println.vv.must_match.simple')
	assert run_trace_fns(fpath, 'println') == 1
	assert run_trace_fns(fpath, '_vinit') == 1
	assert run_trace_fns(fpath, 'println,main.main') == 2
	assert run_trace_fns(fpath, 'builtin') > 3
	eprintln('> `-trace-calls -trace-fns PATTERNS` works')
	separator()
}

fn test_tracing() {
	os.chdir(@VEXEROOT)!
	folder := os.join_path('vlib', 'v', 'tests', 'testdata', 'trace_calls')
	files := os.walk_ext(folder, '.vv')
	for fpath in files {
		should_match_fpath := '${fpath}.must_match'
		if !os.exists(should_match_fpath) {
			eprintln('> skipping ${fpath}, because ${should_match_fpath} does not exist.')
			continue
		}
		run_single_program(fpath, should_match_fpath, '', '64bit')
		if cdefs_h_32bit_exists && gcc_path != '' {
			// try running the same programs, compiled in 32bit mode too, if gcc is available:
			run_single_program(fpath, should_match_fpath, '-cc gcc -m32 -gc none', '32bit')
		} else {
			eprintln('> skipping -m32 compilation since either 32bit headers are not installed, or you do not have gcc installed')
		}
		separator()
	}
}

struct CmdOutput {
	cmd    string
	output string
}

fn run(fpath string, compiler_opts string, label string) CmdOutput {
	cmd := '${os.quoted_path(vexe)} ${compiler_opts} -no-skip-unused -trace-calls run ${os.quoted_path(fpath)}'
	res := os.execute(cmd)
	if res.exit_code != 0 {
		eprintln('> ${label} compilation output:\n${res.output}')
		assert res.exit_code == 0, 'compilation of ${fpath} failed'
	}
	return CmdOutput{cmd, res.output}
}

fn run_trace_fns(fpath string, patterns string) int {
	// ignore the header line and the final output `hi` line:
	return run(fpath, '-trace-fns ${patterns}', 'trace_fns_only_println').output.split_into_lines().len - 2
}

fn run_single_program(fpath string, should_match_fpath string, compiler_opts string, label string) {
	c := run(fpath, compiler_opts, label)
	lines := os.read_lines(should_match_fpath) or {
		assert false, '${should_match_fpath} should be readable'
		return
	}
	if lines.len == 0 {
		assert false, '${should_match_fpath} should contain at least one line/glob match pattern'
	}
	mut matched := false
	for line in lines {
		if c.output.match_glob(line) {
			matched = true
			println('> ${label} trace output of ${fpath} matches line pattern: ${line}')
			continue
		} else {
			eprintln('-----------------------------------')
			eprintln(c.output)
			eprintln('-----------------------------------')
			assert false, '> trace output of ${fpath} DID NOT match the line pattern: `${line}`, run cmd:\n${c.cmd}'
		}
	}
}