#! /bin/bash

# First figure out whether we are linking or not. We can tell by '-E', '-S', or '-c'.

echo ''
echo cc.sh "$@"
echo ''

linking=1
outfile=a.out

# Dear, getopts doesn't cut it for cc

linking=1
outfile='a.out'
last=''

args=("$@")

# Go through arguments, capture the -o and remove it, while trying to
# figure whether we are linking.

skip=0
nargs=()

for i in "${!args[@]}"; do
    # printf "arg[$i] = '%s'\\n" ${args[i]}
    if [ $skip == 1 ]; then
        skip=0
    else
        skip=0
        case ${args[i]} in
            -o)
                outfile=${args[$[$i + 1]]}
                skip=1
                ;;
            -E|-S|-c)
                linking=0
                nargs+=(${args[i]});
                ;;
            *)
                nargs+=(${args[i]});
                ;;
        esac
    fi
done

# When we are not generating an executable, we're done
if [ 0 == $linking ]; then
    exec emcc -sEXIT_RUNTIME=1 "$@"
fi

args=(${nargs[@]})

wasmfile="$outfile.wasm"
jsfile="$outfile.js"
workerjsfile="$outfile.worker.js"

args+=("-sFORCE_FILESYSTEM=1" "-o" "$outfile.js" "-lnodefs.js")

rm -f $wasmfile $jsfile

echo emcc ${args[@]}
emcc ${args[@]}

# if emcc failed, we're done, too.
if [ 0 != $? ]; then exit $?; fi

# Check that that outfile is produced
if [ ! -f "$wasmfile" ]; then
    echo === emcc failed to generate "$wasmfile"
    exit 1
fi
if [ ! -f "$jsfile" ]; then
    echo === emcc failed to generate "$jsfile"
    exit 1
fi

## Build the shell script

cat > "$outfile" <<FIN
#! /bin/bash

arguments=""
comma=""
for k in "\$@"; do
    arguments+="\$comma\\"\$(printf "%s" "\$k" | sed -e "s/\\\\(['\\"\\\\]\\\\)/\\\\\\\\\\\\1/g")\\""
    comma=", "
done

temp=\$(mktemp -d)

# echo === temp is \$temp

cat >\$temp/$(basename $outfile).js <<EOF
function tty_have_input(c) {
    Module.ccall('tty_have_input', // name of C function
                 'number', // return type
                 ['number'], // argument types
                 [c]); // arguments
}

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal: false
});

rl.on('line', (line) => {
    console.log(line);
    for (i = 0; i < line.length; i++)
        tty_have_input(line.charCodeAt(i));
    tty_have_input(10);
});

rl.on('close', () => {
    console.log("<<eof>>");
});

var tty_obuf = "";

function tyo(c) {
    process.stdout.write(String.fromCharCode(c));
}

function whostate(s) {
    //console.log("whostate " + s);
}

Module || (Module = { 
    arguments: [\$arguments],
    preRun: function () {
        //FS.mkdir("/tmp");
        //FS.mkdir("/usr");
        //FS.mkdir("/usr/joe");
        function mkdir(path) {
          console.log('mkdir ' + path);
          FS.mkdir(path);
        }
        var i;
        var home = "$HOME";
        for(i=1;i<home.length;i++)
          if(home.charAt(i)=='/')
            mkdir(home.substring(0,i));
        mkdir(home);
        FS.mount(NODEFS, { root: home }, home);
        FS.chdir("$(pwd)");
    }
 });
EOF
FIN

# transfer foo.js

cat >>"$outfile" <<FIN
uudecode -p >>\$temp/$(basename $outfile).js <<UUEND
FIN

uuencode -m "$jsfile" $(basename "$jsfile") >> "$outfile"
echo UUEND >> "$outfile"

# transfer foo.js

cat >>"$outfile" <<FIN
uudecode -p >\$temp/$(basename $outfile).worker.js <<UUEND
FIN

uuencode -m "$workerjsfile" $(basename "$workerjsfile") >> "$outfile"
echo UUEND >> "$outfile"

# transfer foo.wasm

cat >>"$outfile" <<FIN
uudecode -p >\$temp/$(basename $outfile).wasm <<UUEND
FIN

uuencode -m "$wasmfile" $(basename "$wasmfile") >> "$outfile"
echo UUEND >> "$outfile"


cat >>"$outfile" <<FIN
node --experimental-wasm-threads --experimental-wasm-bulk-memory \$temp/$(basename $outfile).js
ret=\$?
rm -f \$temp/$(basename $outfile).js
rm -f \$temp/$(basename $outfile).worker.js
rm -f \$temp/$(basename $outfile).wasm
rmdir \$temp
exit $ret

FIN

chmod +x "$outfile"