module main

// This example shows how to communicate with a child process (`bash` in this case), by sending
// commands to its stdin pipe, and reading responses from its stdout and stderr pipes.
// Note, you can use `if p.is_pending(.stdout) {` and `if p.is_pending(.stderr) {`, to check if
// there is available data in the pipes, without having to block in your main loop, if the data
// is missing or just not available yet.
import os
import time

const tmp_folder = os.join_path(os.temp_dir(), 'process_folder')

const max_txt_files = 20

fn exec(cmd string) (string, int, string) {
    mut out := []string{}
    mut er := []string{}
    mut rc := 0

    mut p := os.new_process('/bin/bash')
    p.set_redirect_stdio()
    p.run()

    p.stdin_write('echo "START         " && sleep 0.1 && ${cmd};\n')
    p.stdin_write('ECODE=\$?;\n')
    p.stdin_write('sleep 0.1;\n')
    p.stdin_write('exit \$ECODE;\n')

    // Note, that you can also ensure that `bash` will exit, when the command finishes,
    // by closing its stdin pipe. In the above example, that is not needed however, since
    // the last `exit` command, will make it quit as well.
    // os.fd_close(p.stdio_fd[0])

    for p.is_alive() {
        if data := p.pipe_read(.stderr) {
            eprintln('p.pipe_read .stderr, len: ${data.len:4} | data: `${data#[0..10]}`...')
            er << data
        }
        if data := p.pipe_read(.stdout) {
            eprintln('p.pipe_read .stdout, len: ${data.len:4} | data: `${data#[0..10]}`...')
            out << data
        }
        // avoid a busy loop, by sleeping a bit between each iteration
        time.sleep(2 * time.millisecond)
    }

    // the process finished, slurp all the remaining data in the pipes:
    out << p.stdout_slurp()
    er << p.stderr_slurp()
    p.close()
    p.wait()

    if p.code > 0 {
        eprintln('----------------------------------------------------------')
        eprintln('COMMAND: ${cmd}')
        eprintln('STDOUT:\n${out}')
        eprintln('STDERR:\n${er}')
        eprintln('----------------------------------------------------------')
        rc = 1
    }

    return out.join(''), rc, er.join('')
}

fn main() {
    mut out := ''
    mut er := ''
    mut ecode := 0

    // prepare some files in a temporary folder
    defer {
        os.rmdir_all(tmp_folder) or {}
    }
    os.mkdir_all(tmp_folder) or {}
    for i in 0 .. max_txt_files {
        os.write_file(os.join_path(tmp_folder, '${i}.txt'), '${i}\n${i}\n')!
    }

    out, ecode, er =
        exec("find ${os.quoted_path(tmp_folder)} ; sleep 0.1; find ${os.quoted_path(tmp_folder)} ; echo '******'")
    assert out.ends_with('******\n')
    assert er == ''

    out, ecode, er = exec('echo to stdout')
    assert out.contains('to stdout')
    assert er == ''

    out, ecode, er = exec('echo to stderr 1>&2')
    assert out.starts_with('START')
    assert er.contains('to stderr')

    out, ecode, er = exec('ls /sssss')
    assert out.starts_with('START')
    assert er != ''
    assert ecode > 0 // THIS STILL GIVES AN ERROR !

    println('test ok stderr & stdout is indeed redirected, ecode: ${ecode}')
}