import os
import time

const vexe = @VEXE
const vroot = os.dir(vexe)
const tdir = os.join_path(os.vtmp_dir(), 'vwatch_test_24571')
const tsource_dir = os.join_path(tdir, 'src')
const toutput_dir = os.join_path(tdir, 'out')

fn testsuite_begin() {
    os.rmdir_all(tdir) or {}
    os.mkdir_all(tsource_dir)!
    os.mkdir_all(toutput_dir)!
}

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

fn test_watch_keeps_backend_flag_intact() {
    source_path := os.join_path(tsource_dir, 'hello.v')
    output_path := os.join_path(toutput_dir, 'hello.js')
    os.write_file(source_path, "fn main() {\n\tprintln('Hello world')\n}\n")!

    mut process := os.new_process(vexe)
    process.set_work_folder(vroot)
    process.set_redirect_stdio()
    process.use_pgroup = true
    process.set_args(['watch', '-backend', 'js_browser', '-output', output_path, source_path])
    process.run()

    for _ in 0 .. 300 {
        if os.exists(output_path) || !process.is_alive() {
            break
        }
        time.sleep(100 * time.millisecond)
    }
    if process.is_alive() {
        process.signal_pgkill()
    }
    process.wait()
    output := process.stdout_slurp() + process.stderr_slurp()
    process.close()

    assert os.exists(output_path), output
    assert output.contains(' -backend js_browser '), output
    assert !output.contains('-baend'), output
    assert !output.contains('Unknown argument `-baend`'), output
}

// Regression test for https://github.com/vlang/v/issues/27463 :
// `v watch run main.v` should recompile and rerun the program, when its source changes.
fn test_watch_run_reloads_on_source_change() {
    source_path := os.join_path(tsource_dir, 'reload.v')
    marker_path := os.join_path(toutput_dir, 'reload_marker.txt')
    os.rm(marker_path) or {}
    write_versioned_source(source_path, 'V1')!

    mut process := os.new_process(vexe)
    process.set_work_folder(vroot)
    process.set_redirect_stdio()
    process.use_pgroup = true
    // the marker_path argument is passed through to the compiled and run program (see write_versioned_source):
    process.set_args(['watch', 'run', source_path, marker_path])
    process.run()

    // wait for the first compile+run to write the marker file:
    first_run_done := wait_for_marker(marker_path, 'V1')

    // os.file_last_mod_unix has a 1 second resolution, so make sure the edit lands in a later second,
    // otherwise the change detection loop can not notice that the source file was modified at all:
    time.sleep(1500 * time.millisecond)
    write_versioned_source(source_path, 'V2')!

    // the watcher should detect the change, recompile, and rerun, updating the marker to V2:
    reloaded := wait_for_marker(marker_path, 'V2')

    if process.is_alive() {
        process.signal_pgkill()
    }
    process.wait()
    output := process.stdout_slurp() + process.stderr_slurp()
    process.close()

    assert first_run_done, 'the watched program was never compiled and run\n${output}'
    assert reloaded, 'the watcher did not recompile and rerun after the source file changed\n${output}'
}

fn write_versioned_source(source_path string, version string) ! {
    os.write_file(source_path,
        "import os\nfn main() {\n\tos.write_file(os.args[1], '${version}') or { panic(err) }\n}\n")!
}

fn wait_for_marker(marker_path string, expected string) bool {
    for _ in 0 .. 300 {
        content := os.read_file(marker_path) or { '' }
        if content == expected {
            return true
        }
        time.sleep(100 * time.millisecond)
    }
    return false
}