module os

$if js_node {
    #var $fs = require('fs');
    #var $path = require('path');
    #var tty = require('tty')
}

pub const path_delimiter = get_path_delimiter()
pub const path_separator = get_path_separator()
pub const path_devnull = '/dev/null' // TODO

pub const args = []string{}

const executable_suffixes = ['']

fn get_path_delimiter() string {
    delimiter := ':'
    $if js_node {
        #delimiter.str = $path.delimiter
    }
    return delimiter
}

fn get_path_separator() string {
    separator := '/'
    $if js_node {
        #separator.str = $path.sep
    }
    return separator
}

fn init() {
    $if js_node {
        #$process.argv.forEach(function(val,index) { os__args.arr[index] = new string(val); })
    }
}

// real_path returns the full absolute path for fpath, with all relative ../../, symlinks and so on resolved.
// See http://pubs.opengroup.org/onlinepubs/9699919799/functions/realpath.html
// Also https://insanecoding.blogspot.com/2007/11/pathmax-simply-isnt.html
// and https://insanecoding.blogspot.com/2007/11/implementing-realpath-in-c.html
// Note: this particular rabbit hole is *deep* ...
pub fn real_path(fpath string) string {
    $if js_node {
        mut res := ''
        #res = new string( $fs.realpathSync(fpath))

        return res
    } $else {
        return fpath
    }
}

// flush will flush the stdout buffer.
pub fn flush() {
    $if js_node {
        #$process.stdout.write('')
    }
}

pub fn getpid() int {
    res := 0
    #res.val = $process.pid

    return res
}

// chmod change file access attributes of `path` to `mode`.
// Octals like `0o600` can be used.
pub fn chmod(path string, mode int) ! {
    $if js_node {
        #try {
        #$fs.chmodSync(''+path,mode.valueOf())
        #} catch (error) {
        #return error_with_code(new string("chmod failed: " + error.message),new int(error.code))
        #}
    } $else {
        return error('os.chmod() is available only for NodeJS')
    }
}

// chown changes the owner and group attributes of `path` to `owner` and `group`.
// Octals like `0o600` can be used.
pub fn chown(path string, owner int, group int) ! {
    $if js_node {
        #try {
        #$fs.chownSync(''+path,owner.valueOf(),group.valueOf())
        #} catch (error) { return error_with_code(new string("chown failed: " + error.message),new int(error.code)) }
    } $else {
        return error('os.chown() is available only for NodeJS')
    }
}

pub fn temp_dir() string {
    mut res := ''
    $if js_node {
        #res = new string($os.tmpdir())
    }
    return res
}

pub fn home_dir() string {
    mut res := ''
    $if js_node {
        #res = new string($os.homedir())
    }
    return res
}

// join_path returns a path as string from input string parameter(s).
pub fn join_path(base string, dirs ...string) string {
    mut result := []string{}
    result << base.trim_right('\\/')
    for d in dirs {
        result << d
    }
    mut path_sep := ''
    #path_sep = $path.sep;

    res := result.join(path_sep)
    return res
}

pub fn join_path_single(base string, elem string) string {
    // TODO: deprecate this
    return join_path(base, elem)
}

pub fn execute(cmd string) Result {
    mut exit_code := 0
    mut stdout := ''
    #let commands = cmd.str.split(' ');
    #let output = $child_process.spawnSync(commands[0],commands.slice(1,commands.length));
    #exit_code = new int(output.status)
    #stdout = new string(output.stdout + '')

    return Result{
        exit_code: exit_code
        output:    stdout
    }
}

// exec starts the specified command with arguments, waits for it to complete, and returns its output.
pub fn exec(args []string) Result {
    if args.len == 0 {
        return Result{
            exit_code: -1
            output:    'exec requires at least one argument'
        }
    }
    mut exit_code := 0
    mut stdout := ''
    #let commands = args.arr.map((x) => x.valueOf() + '');
    #let output = $child_process.spawnSync(commands[0], commands.slice(1, commands.length));
    #exit_code = new int(output.status === null ? -1 : output.status)
    #stdout = new string((output.stdout ? output.stdout + '' : '') + (output.stderr ? output.stderr + '' : ''))

    return Result{
        exit_code: exit_code
        output:    stdout
    }
}

pub fn system(cmd string) int {
    exit_code := 0
    #let commands = cmd.str.split(' ');
    #exit_code.val = $child_process.execSync(commands[0],commands.slice(1,commands.length));

    return exit_code
}

pub fn is_atty(fd int) int {
    res := 0
    #res.val = +tty.isatty(fd.val)

    return res
}

pub fn glob(patterns ...string) ![]string {
    panic('not yet implemented')
    return error('not yet implemented')
}

pub fn write_file_array(path string, buffer array) ! {
    mut f := create(path)!
    f.write_array(buffer)!
    f.close()
}

pub fn chdir(s string) ! {
    #try { $process.chdir(s.str); } catch (e) { return error(new string('' + s)) }
}

pub fn file_last_mod_unix(path string) int {
    mtime := 0
    #mtime.val = Math.floor($fs.lstatSync(path.str).mtime.getTime() / 1000)

    return mtime
}

pub fn ensure_folder_is_writable(path string) ! {
    fpath := join_path(path, 'some_newfile')
    #try { $fs.writeFileSync(fpath); $fs.unlinkSync(fpath) } catch(e) { return error(new string('could not write to ' + path)) }

    _ := fpath
}