// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module main

import os
import time

fn main() {
	t0 := time.now()

	// Build v2 compiler
	println('[*] Building v2...')
	vroot := os.dir(@VEXE)
	v2_source := os.join_path(vroot, 'cmd', 'v2', 'v2.v')
	v2_binary := os.join_path(vroot, 'cmd', 'v2', 'v2')
	build_res := os.execute('${@VEXE} -gc none -cc cc ${v2_source} -o ${v2_binary}')
	if build_res.exit_code != 0 {
		eprintln('Error: Failed to build v2')
		eprintln(build_res.output)
		exit(1)
	}

	// Determine backends from command line args.
	// If none are provided, run the default backend set.
	mut backends := []string{}
	if os.args.contains('cleanc') {
		backends << 'cleanc'
	}
	if os.args.contains('c') {
		backends << 'c'
	}
	if os.args.contains('arm64') {
		backends << 'arm64'
	}
	if os.args.contains('x64') {
		backends << 'x64'
	}
	if backends.len == 0 {
		backends = ['cleanc', 'c', 'arm64']
	}

	// Parse test file from args or default to test.v
	// Support: ./test_ssa_backends arm64 path/to/file.v
	mut input_file := 'test.v'
	for arg in os.args {
		if arg.ends_with('.v') && arg != @FILE {
			input_file = arg
			break
		}
	}
	if !os.exists(input_file) {
		eprintln('Error: ${input_file} not found')
		exit(1)
	}

	// Derive output binary name from input file
	base_name := os.file_name(input_file).replace('.v', '')
	ref_output_path := './.${base_name}_ref.out.tmp'
	gen_output_path := './.${base_name}_gen.out.tmp'

	// Get expected output: use .out file if --skip-builtin, otherwise run reference compiler
	mut expected_out := ''
	out_file := input_file.replace('.v', '.out')
	if os.args.contains('--skip-builtin') && os.exists(out_file) {
		println('[*] Using expected output from ${out_file}')
		expected_out = os.read_file(out_file) or { '' }.trim_space().replace('\r\n', '\n')
	} else {
		// Run Reference (v run test.v)
		println('[*] Running reference: ${@VEXE} -enable-globals run ${input_file}...')
		os.rm(ref_output_path) or {}
		ref_cc := if os.user_os() == 'macos' { '-cc cc ' } else { '' }
		ref_cmd := '${@VEXE} -gc none ${ref_cc}-n -w -enable-globals run ${input_file} > ${ref_output_path} 2>&1'
		ref_res := os.execute(ref_cmd)
		ref_out := os.read_file(ref_output_path) or { '' }
		os.rm(ref_output_path) or {}
		if ref_res.exit_code != 0 {
			eprintln('Error: Reference run failed')
			eprintln(ref_out)
			exit(1)
		}
		// Normalize newlines
		expected_out = ref_out.trim_space().replace('\r\n', '\n')
	}

	mut had_failures := false
	for backend in backends {
		backend_t0 := time.now()

		// Run v2 with selected backend
		println('[*] Running v2 -backend ${backend} ${input_file}...')
		mut backend_flags := '-gc none -backend ${backend}'
		if backend in ['arm64', 'x64'] {
			if os.args.contains('-prod') {
				backend_flags += ' -prod'
			} else if os.args.contains('-O0') {
				backend_flags += ' -O0'
			}
		}
		if backend == 'cleanc' {
			// cleanc needs full per-run codegen for this suite right now.
			backend_flags += ' -nomarkused -nocache'
		}
		if os.args.contains('--skip-builtin') && !backend_flags.contains('--skip-builtin') {
			backend_flags += ' --skip-builtin'
		}
		v2_cmd := '${v2_binary} ${backend_flags} ${input_file} -o ${base_name}'
		v2_res := os.execute(v2_cmd)
		if v2_res.exit_code != 0 {
			eprintln('Error: v2 compilation failed for backend ${backend}')
			eprintln(v2_res.output)
			had_failures = true
			continue
		}
		println(v2_res.output)
		println('compilation took ${time.since(backend_t0)}')

		// Save the v2-produced binary before running another backend (which would overwrite it)
		saved_binary := './${base_name}_${backend}_v2'
		os.rm(saved_binary) or {}
		if os.user_os() == 'windows' {
			os.rm('${saved_binary}.exe') or {}
		}
		os.cp('./${base_name}', saved_binary) or {
			eprintln('Error: Failed to save v2 binary for backend ${backend}')
			had_failures = true
			continue
		}

		// Run generated binary
		println('[*] Running generated binary (${backend})...')
		mut cmd := saved_binary
		if os.user_os() == 'windows' {
			cmd = '${saved_binary}.exe'
		}
		os.rm(gen_output_path) or {}
		// 60s timeout to catch infinite loops in ARM64-generated code
		has_timeout := os.exists('/opt/homebrew/bin/timeout') || os.exists('/usr/bin/timeout')
		has_gtimeout := os.exists('/opt/homebrew/bin/gtimeout') || os.exists('/usr/bin/gtimeout')
		timeout_cmd := if has_timeout {
			'timeout'
		} else if has_gtimeout {
			'gtimeout'
		} else {
			''
		}
		gen_cmd := if timeout_cmd != '' {
			'${timeout_cmd} 60 ${cmd} > ${gen_output_path} 2>&1'
		} else {
			'${cmd} > ${gen_output_path} 2>&1'
		}
		gen_res := os.execute(gen_cmd)
		gen_out := os.read_file(gen_output_path) or { '' }
		os.rm(gen_output_path) or {}
		if gen_res.exit_code != 0 {
			if gen_res.exit_code == 124 || gen_res.exit_code == 142 || gen_res.exit_code == 14 {
				eprintln('Error: Execution timed out (infinite loop detected) for backend ${backend}')
				had_failures = true
				continue
			}
			println('Warning: Binary exited with code ${gen_res.exit_code}')
		}

		// Strip terminal control characters that script command may prepend
		mut cleaned := gen_out.replace('\r\n', '\n').replace('\x04', '').replace('\x08', '')
		// Remove "^D" literal string that macOS script may add
		if cleaned.starts_with('^D') {
			cleaned = cleaned[2..]
		}
		actual_out := cleaned.trim_space()

		// Compare
		if expected_out == actual_out {
			println('\n[SUCCESS] Backend ${backend}: outputs match!')
			continue
		}

		had_failures = true
		println('\n[FAILURE] Backend ${backend}: outputs differ')
		expected_lines := expected_out.split('\n')
		actual_lines := actual_out.split('\n')

		// Find first differing line
		mut first_diff := -1
		max_lines := if expected_lines.len > actual_lines.len {
			expected_lines.len
		} else {
			actual_lines.len
		}
		for i in 0 .. max_lines {
			exp := if i < expected_lines.len { expected_lines[i] } else { '<missing>' }
			act := if i < actual_lines.len { actual_lines[i] } else { '<missing>' }
			if exp != act {
				first_diff = i
				break
			}
		}

		if first_diff >= 0 {
			context := 2
			start := if first_diff > context { first_diff - context } else { 0 }
			end := if first_diff + context + 1 < max_lines {
				first_diff + context + 1
			} else {
				max_lines
			}

			println('\nExpected (reference compiler):')
			for i in start .. end {
				line := if i < expected_lines.len { expected_lines[i] } else { '<missing>' }
				println('${i + 1}: ${line}')
			}

			println('\nGot (v2 ${backend}):')
			for i in start .. end {
				line := if i < actual_lines.len { actual_lines[i] } else { '<missing>' }
				println('${i + 1}: ${line}')
			}
		}
	}

	if had_failures {
		println('\n[FAILURE] One or more backends failed')
		exit(1)
	} else {
		println('\n[SUCCESS] All requested backends passed')
	}
	println('total time ${time.since(t0)}')
}