#!/usr/bin/env bash
set -eu

ENTRY_POINT_FILE=
ENTRY_POINT_DIR=
COMMAND_SCRIPT_FILE=
COMMAND_SCRIPT_DIR=

DOCKER=$(command -v docker)
if [ -z "${DOCKER}" ] ; then
    echo "Docker was not found in your PATH.  Aborting."
    exit 1
fi

cleanup()
{
    if [ -n "$ENTRY_POINT_DIR" ] ; then
        rm -f "$ENTRY_POINT_FILE"
        rmdir "$ENTRY_POINT_DIR"
    fi
    if [ -n "$COMMAND_SCRIPT_DIR" ] ; then
        rm -f "$COMMAND_SCRIPT_FILE"
        rmdir "$COMMAND_SCRIPT_DIR"
    fi
}
trap "cleanup" EXIT

usage()
{
    cat<<EOF
Usage: $0 [PROJDIR] [--script SCRIPT | -- COMMAND]

If provided, PROJDIR specifies the root of the source directory for the 
project you want to compile.  This will be mapped into the container under
"/home/$USER/src".

By default, the shell is run in interactive mode.  It can be run in
non-interactive mode by "--", followed by a command.  If the command references
any custom scripts, they should be relative to PROJDIR so that they can be
found inside the container.

To rebuild the image, run "./scripts/dev-shell --rebuild ."
EOF
    exit 1
}

abort()
{
    MSG="$1"
    echo "ERROR: $MSG"
    exit 1
}

check-err()
{
    CODE=$?
    MSG="$1"
    if [ $CODE -ne 0 ] ; then
        abort "$MSG"
    fi
}

get-script-dir()
{
    SCRIPT_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]:-$0}"; )" &> /dev/null && pwd 2> /dev/null; )";
    echo $SCRIPT_DIR
}

# Returns 0 if the script is running from inside the singlestore-wasm-toolkit 
# repository.
running-in-repo()
{
    SCRIPT_DIR=$(get-script-dir)
    [ -f "$SCRIPT_DIR/../docker/Dockerfile-shell" ]
}

# Main ########################################################################

REBUILD=0
PULL=0
while [ $# -gt 0 ] ; do
    case "$1" in
        -h|--help)
            usage
            ;;
        --pull)
            PULL=1
            ;;
        --rebuild)
            REBUILD=1
            ;;
        -*)
            usage
            ;;
        *)
            break
            ;;
    esac
    shift
done

PROJ_DIR="${1:-}"
if [ -n "${PROJ_DIR}" ] ; then
    PROJ_DIR="$(cd "${PROJ_DIR}" && pwd -P)"
    if [ ! -d "${PROJ_DIR}" ] ; then
        abort "Specified project directory '${PROJ_DIR}' does not exist."
    fi
fi
shift

NONINTERACTIVE=0
SCRIPT=
if [ $# -gt 0 ] ; then
    case "$1" in
        --script|-s)
            shift
            NONINTERACTIVE=1
            SCRIPT="$1"
            ;;
        --)
            NONINTERACTIVE=1
            ;;
        *)
            usage
            ;;
    esac
    shift
fi
[ -n "$SCRIPT" -a $# -gt 0 ] && usage

COMMAND_SCRIPT_DIR_OPT=
RUNME=
if [ $NONINTERACTIVE -eq 1 ] ; then
    COMMAND_SCRIPT_DIR=`mktemp -d`
    COMMAND_SCRIPT_FILE="$COMMAND_SCRIPT_DIR/runme.sh"
    COMMAND_SCRIPT_DIR_OPT="-v ${COMMAND_SCRIPT_DIR}:/command"
    RUNME="/command/`basename $COMMAND_SCRIPT_FILE`"
    
    echo ". ~/.profile" > $COMMAND_SCRIPT_FILE

    if [ -n "$SCRIPT" ] ; then
        cat "$SCRIPT" >> "$COMMAND_SCRIPT_FILE"
    else
        echo "$@" >> "$COMMAND_SCRIPT_FILE"
    fi
fi

MAP_REPO_DIR_OPT=
if running-in-repo ; then
    SCRIPT_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]:-$0}"; )" &> /dev/null && pwd 2> /dev/null; )";
    REPO_DIR="$(dirname "${SCRIPT_DIR}")"
    if [ $REBUILD = 1 ] ; then
        pushd "${REPO_DIR}" > /dev/null
        "${DOCKER}" build \
            -f "docker/Dockerfile-shell" \
            -t "ghcr.io/singlestore-labs/singlestore-wasm-toolkit-shell:latest" \
            .
        check-err "Failed to build new docker image."
        popd > /dev/null
    fi
    MAP_REPO_DIR_OPT="-v ${REPO_DIR}:/opt/singlestore-wasm-toolkit"
else
    if [ $REBUILD = 1 ] ; then
        abort "Cannot rebuild image unless running from repository."
    fi
fi

MAP_PROJ_DIR_OPT=
SET_WORK_DIR_OPT="-w /home/$USER"
if [ -n "${PROJ_DIR}" ] ; then
    MAP_PROJ_DIR_OPT="-v ${PROJ_DIR}:/home/$USER/src"
    SET_WORK_DIR_OPT="-w /home/$USER/src"
fi

PULL_OPT=
if [ $PULL -eq 1 ] ; then
    PULL_OPT="--pull always"
fi

ENTRY_POINT_DIR_OPT=/entry
if [ -n "$ENTRY_POINT_DIR" ] ; then
    ENTRY_POINT_DIR_OPT="$ENTRY_POINT_DIR:$ENTRY_POINT_DIR_OPT"
fi
ENTRY_POINT_DIR_OPT="-v $ENTRY_POINT_DIR_OPT"

INTERACTIVE_OPT="-it"
if [ $NONINTERACTIVE -eq 1 ] ; then
    INTERACTIVE_OPT=
fi

"${DOCKER}" run ${PULL_OPT} ${INTERACTIVE_OPT} --rm \
    ${ENTRY_POINT_DIR_OPT} \
    ${MAP_REPO_DIR_OPT} \
    ${MAP_PROJ_DIR_OPT} \
    ${SET_WORK_DIR_OPT} \
    ${COMMAND_SCRIPT_DIR_OPT} \
    ghcr.io/singlestore-labs/singlestore-wasm-toolkit-shell:latest \
    /entry/dev-shell-init $(id -u) $(id -g) $(id -un) $(id -gn) "$RUNME"

check-err "Failed to run docker image."