// Copyright (c) 2020-2024 Joe Conigliaro. 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
import v2.pref
import v2.builder

fn main() {
	compile_args, runtime_args := split_eval_runtime_args(os.args[1..])

	// Check for subcommands
	if compile_args.len > 0 && compile_args[0] == 'ast' {
		run_ast_command(compile_args[1..])
		return
	}
	if compile_args.len > 0 && compile_args[0] == 'test-self' {
		run_test_self()
		return
	}

	mut prefs := pref.new_preferences_from_args(compile_args)

	files := get_files(compile_args)
	if files.len == 0 {
		eprintln('At least 1 .v file expected')
		exit(1)
	}
	mut eval_runtime_args := [files[0]]
	eval_runtime_args << runtime_args
	prefs.eval_runtime_args = eval_runtime_args

	mut b := builder.new_builder(&prefs)
	b.build(files)

	// Auto-run test binaries after compilation (matching v1 behavior)
	if prefs.output_file == '' && is_test_file(files) && should_auto_run_test_binary(&prefs) {
		last := os.file_name(files.last())
		output_name := if last.ends_with('.vv2') {
			last.all_before_last('.vv2')
		} else {
			last.all_before_last('.v')
		}
		if os.exists(output_name) {
			ret := os.system('./' + output_name)
			os.rm(output_name) or {}
			c_file := output_name + '.c'
			if !prefs.keep_c && os.exists(c_file) {
				os.rm(c_file) or {}
			}
			exit(ret)
		}
	}
}

fn split_eval_runtime_args(args []string) ([]string, []string) {
	for i, arg in args {
		if arg == '--' {
			return args[..i], args[i + 1..]
		}
	}
	return args, []string{}
}

fn run_ast_command(args []string) {
	if args.len == 0 {
		eprintln('Usage: v2 ast <file.v>')
		eprintln('Dumps AST to <file>_ast.json and <file>_ast_transformed.json')
		exit(1)
	}

	// Find the vast2 tool relative to vexe
	vroot := os.dir(@VEXE)
	vast2_path := os.join_path(vroot, 'cmd', 'tools', 'vast2', 'vast2')

	// Build vast2 if it doesn't exist
	if !os.exists(vast2_path) {
		eprintln('Building vast2 tool...')
		vast2_source := os.join_path(vroot, 'cmd', 'tools', 'vast2', 'vast2.v')
		build_result := os.execute('${@VEXE} ${vast2_source}')
		if build_result.exit_code != 0 {
			eprintln('Failed to build vast2 tool:')
			eprintln(build_result.output)
			exit(1)
		}
	}

	// Run vast2 with the provided arguments
	cmd := '${vast2_path} ${args.join(' ')}'
	result := os.execute(cmd)
	print(result.output)
	if result.exit_code != 0 {
		exit(result.exit_code)
	}
}

fn is_test_file(files []string) bool {
	for file in files {
		if file.ends_with('_test.v') || file.ends_with('_test.vv2') {
			return true
		}
	}
	return false
}

fn should_auto_run_test_binary(prefs &pref.Preferences) bool {
	if prefs == unsafe { nil } {
		return true
	}
	if !prefs.can_run_target_binary_locally() {
		return false
	}
	return true
}

// get_files extracts source files from args, excluding options and their values
fn get_files(args []string) []string {
	return pref.source_files_from_args(args)
}

fn resolve_own_path() string {
	arg0 := os.args[0]
	if os.is_abs_path(arg0) {
		return arg0
	}
	return os.join_path(os.getwd(), arg0)
}

// detect_vroot walks up from `start` looking for a directory containing vlib/builtin.
fn detect_vroot(start string) string {
	mut dir := start
	if !os.is_abs_path(dir) {
		dir = os.join_path(os.getwd(), dir)
	}
	for _ in 0 .. 10 {
		if os.is_dir(os.join_path(dir, 'vlib', 'builtin')) {
			return dir
		}
		parent := os.dir(dir)
		if parent == dir {
			break
		}
		dir = parent
	}
	return dir
}

fn run_test_self() {
	t0 := time.now()
	// Resolve the v2 binary's own path. Cannot use @VEXE because when v1
	// compiles v2, @VEXE bakes in v1's path instead of v2's.
	vexe := resolve_own_path()
	// Walk up from the binary to find the repo root (directory containing vlib/builtin).
	// This allows running from subdirectories like cmd/v2/.
	vroot := detect_vroot(vexe)
	v2_dir := os.join_path(vroot, 'cmd', 'v2')

	mut all_test_files := []string{}

	// Builtin test files
	for name in ['array_test.v', 'string_test.v', 'map_test.v'] {
		all_test_files << os.join_path(vroot, 'vlib', 'builtin', name)
	}

	// Math test
	all_test_files << os.join_path(vroot, 'vlib', 'math', 'math_test.v')

	// Sumtype tests in cmd/v2/
	v2_files := os.ls(v2_dir) or { []string{} }
	for file in v2_files {
		if file.starts_with('test_sumtype') && file.ends_with('.v') {
			all_test_files << os.join_path(v2_dir, file)
		}
	}

	// Cleanc regression tests
	cleanc_tests_dir := os.join_path(vroot, 'vlib', 'v2', 'gen', 'cleanc', 'tests')
	cleanc_files := os.ls(cleanc_tests_dir) or { []string{} }
	for file in cleanc_files {
		if file.ends_with('.v') && file != 'run_tests.v' {
			all_test_files << os.join_path(cleanc_tests_dir, file)
		}
	}

	total := all_test_files.len
	mut passed := 0
	mut failed := 0
	mut failed_files := []string{}

	eprintln('---- v2 test-self: ${total} test files ----')

	for i, test_file in all_test_files {
		short_name := test_file.replace(vroot + '/', '')
		t1 := time.now()

		// Determine output binary path
		base := os.file_name(test_file).all_before_last('.v')
		out_bin := os.join_path(os.temp_dir(), 'v2_test_self_${base}')

		// Compile (use os.system to avoid pipe deadlocks with popen/GC)
		compile_cmd := '${vexe} -o ${out_bin} "${test_file}" > /dev/null 2>&1'
		compile_ret := os.system(compile_cmd)
		compile_ms := f64(time.since(t1)) / f64(time.millisecond)

		if compile_ret != 0 || !os.exists(out_bin) {
			failed++
			failed_files << short_name
			eprintln(' FAIL  [${i + 1:4}/${total}] C: ${compile_ms:7.1} ms  ${short_name}')
			os.rm(out_bin) or {}
			os.rm('${out_bin}.c') or {}
			continue
		}

		// Run the compiled binary
		t2 := time.now()
		run_ret := os.system(out_bin + ' > /dev/null 2>&1')
		run_ms := f64(time.since(t2)) / f64(time.millisecond)

		if run_ret != 0 {
			failed++
			failed_files << short_name
			eprintln(' FAIL  [${i + 1:4}/${total}] C: ${compile_ms:7.1} ms, R: ${run_ms:7.1} ms  ${short_name}')
		} else {
			passed++
			eprintln('OK    [${i + 1:4}/${total}] C: ${compile_ms:7.1} ms, R: ${run_ms:7.1} ms  ${short_name}')
		}

		os.rm(out_bin) or {}
		os.rm('${out_bin}.c') or {}
	}

	elapsed := time.since(t0)
	eprintln('------------------------------------------------------------------------')
	eprintln('${passed} passed, ${failed} failed, ${total} total  (${elapsed})')
	if failed_files.len > 0 {
		eprintln('Failed:')
		for f in failed_files {
			eprintln('  ${f}')
		}
	}
	// Always run the self-compilation chain, even when some tests fail.
	// Self-compilation chain: v2 -> v3 -> v4 -> v5
	eprintln('')
	eprintln('---- v2 self-compilation chain ----')

	v2_source := os.join_path(v2_dir, 'v2.v')
	backend := 'cleanc'
	tmpdir := os.temp_dir()
	v3_bin := os.join_path(tmpdir, 'v2_self_v3')
	v4_bin := os.join_path(tmpdir, 'v2_self_v4')
	v5_bin := os.join_path(tmpdir, 'v2_self_v5')

	steps := [
		[vexe, v3_bin, 'v2 -> v3'],
		[v3_bin, v4_bin, 'v3 -> v4'],
		[v4_bin, v5_bin, 'v4 -> v5'],
	]

	for step in steps {
		compiler := step[0]
		out := step[1]
		label := step[2]
		ts := time.now()
		cmd := '${compiler} -gc none -o ${out} -backend ${backend} "${v2_source}" > /dev/null 2>&1'
		ret := os.system(cmd)
		ms := f64(time.since(ts)) / f64(time.millisecond)
		if ret != 0 || !os.exists(out) {
			eprintln(' FAIL  ${label}  (${ms:.1} ms)')
			// Clean up
			for bin in [v3_bin, v4_bin, v5_bin] {
				os.rm(bin) or {}
				os.rm('${bin}.c') or {}
			}
			exit(1)
		}
		eprintln('OK    ${label}  (${ms:.1} ms)')
	}

	// Verify that v3 runs and produces expected output
	result := os.execute('${v3_bin} 2>&1')
	expected := 'At least 1 .v file expected'
	if !result.output.contains(expected) {
		eprintln("FAIL  v3 output check: expected '${expected}', got:")
		eprintln(result.output)
		for bin in [v3_bin, v4_bin, v5_bin] {
			os.rm(bin) or {}
			os.rm('${bin}.c') or {}
		}
		exit(1)
	}
	eprintln('OK    v3 output verified')

	// Clean up
	for bin in [v3_bin, v4_bin, v5_bin] {
		os.rm(bin) or {}
		os.rm('${bin}.c') or {}
	}

	total_elapsed := time.since(t0)
	eprintln('')
	if failed > 0 {
		eprintln('=== SELF-COMPILATION OK, but ${failed} test(s) failed ===')
		eprintln('Total time: ${total_elapsed}')
		exit(1)
	}
	eprintln('=== SELF-COMPILATION TEST PASSED ===')
	eprintln('Total time: ${total_elapsed}')
}