import os
import time
import flag
import strconv

struct Context {
mut:
    timeout  f64
    cmd_args []string
}

fn main() {
    mut fp := flag.new_flag_parser(os.args[1..])
    fp.application('v timeout')
    fp.version('0.0.2')
    fp.description('Run a command with a time limit. Example: `v timeout 0.3 v run examples/hello_world.v`')
    fp.arguments_description('timeout_in_seconds CMD [ARGS]')
    fp.skip_executable()
    fp.limit_free_args_to_at_least(2)!

    if fp.bool('help', `h`, false, 'Show this help screen.') {
        println(fp.usage())
        exit(0)
    }

    args := fp.finalize() or {
        eprintln('Argument error: ${err}')
        exit(125) // mimic the exit codes of `timeout` in coreutils
    }

    ctx := Context{
        timeout:  strconv.atof64(args[0]) or {
            eprintln('Invalid timeout: ${args[0]}')
            exit(125)
        }
        cmd_args: args[1..].clone()
    }

    mut cmd := ctx.cmd_args[0]
    if !os.exists(cmd) {
        cmd = os.find_abs_path_of_executable(cmd) or { cmd }
    }

    mut p := os.new_process(cmd)
    p.set_args(ctx.cmd_args[1..])
    p.run()
    if p.err != '' {
        eprintln('Cannot execute: ${ctx.cmd_args.join(' ')}')
        exit(if os.exists(ctx.cmd_args[0]) { 126 } else { 127 })
    }

    child_exit := chan int{}

    spawn fn (mut p os.Process, ch chan int) {
        p.wait()
        ch <- p.code
        ch.close()
    }(mut p, child_exit)

    mut exit_code := 0
    select {
        i64(ctx.timeout * time.second) {
            p.signal_term()
            time.sleep(2 * time.millisecond)
            if p.is_alive() {
                p.signal_kill()
            }
            p.wait()
            exit_code = 124 // timeout
        }
        code := <-child_exit {
            exit_code = code
        }
    }
    exit(exit_code)
}