#! /usr/bin/env bash

set -e

if ! which docker > /dev/null 2>&1 ; then
    echo "Docker does not seem to be installed."
    exit 1
fi

if ! which docker-compose > /dev/null 2>&1 ; then
    echo "Docker-compose does not seem to be installed."
    exit 1
fi

docker_version="$(docker version -f "{{ .Server.Version }}")"
docker_major="$(echo "$docker_version" | cut -d . -f 1)"
docker_minor="$(echo "$docker_version" | cut -d . -f 2)"

if ([ "$docker_major" -gt 1 ] ||
    ( [ "$docker_major" -eq 1 ] && [ "$docker_minor" -ge 13 ] )) ; then
    docker_1_13=true
else
    docker_1_13=false
fi

current_dir="$(pwd -P)"
src_dir="$(cd "$(dirname "$0")" && echo "$current_dir/")"
cd "$src_dir"

update_compose_file() {

    update_active_protocol_version

    if [ "$#" -ge 2 ] && [ "$1" = "--rpc-port" ] ; then
        export_rpc="
      - \"$2:8732\""
        shift 2
    fi

    cat > "$docker_compose_yml" <<EOF
version: "2"

volumes:
  node_data:
  client_data:

services:

  node:
    image: $docker_image
    hostname: node
    command: tezos-node --net-addr :$port $@
    ports:
      - "$port:$port"$export_rpc
    expose:
      - "8732"
    volumes:
      - node_data:/var/run/tezos/node
      - client_data:/var/run/tezos/client
    restart: on-failure

EOF

for proto in $(cat "$active_protocol_versions") ; do

    cat >> "$docker_compose_yml" <<EOF
  baker-$proto:
    image: $docker_image
    hostname: baker-$proto
    environment:
      - PROTOCOL=$proto
    command: tezos-baker --max-priority 128
    links:
      - node
    volumes:
      - node_data:/var/run/tezos/node:ro
      - client_data:/var/run/tezos/client
    restart: on-failure

  endorser-$proto:
    image: $docker_image
    hostname: endorser-$proto
    environment:
      - PROTOCOL=$proto
    command: tezos-endorser
    links:
      - node
    volumes:
      - client_data:/var/run/tezos/client
    restart: on-failure

  accuser-$proto:
    image: $docker_image
    hostname: accuser-$proto
    environment:
      - PROTOCOL=$proto
    command: tezos-accuser
    links:
      - node
    volumes:
      - client_data:/var/run/tezos/client
    restart: on-failure

EOF

done

}

call_docker_compose() {
    docker-compose -f "$docker_compose_yml" -p "$docker_compose_name" "$@"
}

exec_docker() {
    if [ -t 0 ] && [ -t 1 ] && [ -t 2 ] && [ -z "$ALPHANET_EMACS" ]; then
        local interactive_flags="-it"
    else
        local interactive_flags="-t"
    fi
    local node_container="$(container_name "$docker_node_container")"
    declare -a container_args=();
    tmpdir="/tmp"
    for arg in "$@"; do
        if [[ "$arg" == 'container:'* ]]; then
            local_path="${arg#container:}"
            if [[ "$local_path" != '/'* ]]; then
                local_path="$current_dir/$local_path"
            fi
            file_name=$(basename "${local_path}")
            docker_path="$tmpdir/$file_name"
            docker cp "${local_path}" "$node_container:${docker_path}"
            docker exec "$interactive_flags" "$node_container" sudo chown tezos "${docker_path}"
            container_args+=("file:$docker_path");
        else
            container_args+=("${arg}");
        fi
    done
    docker exec "$interactive_flags" -e 'TEZOS_CLIENT_UNSAFE_DISABLE_DISCLAIMER' "$node_container" "${container_args[@]}"
}

## Container ###############################################################

update_active_protocol_version() {
    docker run --entrypoint /bin/cat "$docker_image" \
           /usr/local/share/tezos/active_protocol_versions > "$active_protocol_versions"
}

may_update_active_protocol_version() {
    if [ ! -f "$active_protocol_versions" ] ; then
        update_active_protocol_version
    fi
}

pull_image() {
    if [ "$TEZOS_ALPHANET_DO_NOT_PULL" = "yes" ] \
           || [ "$ALPHANET_EMACS" ] \
           || [ "$docker_image" = "$(echo $docker_image | tr -d '/')" ] ; then
        return ;
    fi
    docker pull "$docker_image"
    update_active_protocol_version
    date "+%s" > "$docker_pull_timestamp"
}

may_pull_image() {
    if [ ! -f "$docker_pull_timestamp" ] \
         || [ 3600 -le $(($(date "+%s") - $(cat $docker_pull_timestamp))) ]; then
        pull_image
    fi
}

uptodate_container() {
    running_image=$(docker inspect \
                           --format="{{ .Image }}" \
                           --type=container "$(container_name "$1")")
    latest_image=$(docker inspect \
                          --format="{{ .Id }}" \
                          --type=image "$docker_image")
    [ "$latest_image" = "$running_image" ]
}

uptodate_containers() {
    container=$1
    if [ ! -z "$container" ]; then
        shift 1
        uptodate_container $container && uptodate_containers $@
    fi
}

assert_container() {
    call_docker_compose up --no-start
}

container_name() {
    local name="$(docker ps --filter "name=$1" --format "{{.Names}}")"
    if [ -n "$name" ]; then echo "$name"; else echo "$1"; fi
}

## Node ####################################################################

check_node_volume() {
    docker volume inspect "$docker_node_volume" > /dev/null 2>&1
}

clear_node_volume() {
    if check_node; then
        echo -e "\033[31mCannot clear data while the node is running.\033[0m"
        exit 1
    fi
    if check_node_volume ; then
        docker volume rm "$docker_node_volume" > /dev/null
        echo -e "\033[32mThe chain data has been removed from the disk.\033[0m"
    else
        echo -e "\033[32mNo remaining data to be removed from the disk.\033[0m"
    fi
}

check_node() {
    res=$(docker inspect \
                 --format="{{ .State.Running }}" \
                 --type=container "$(container_name "$docker_node_container")" 2>/dev/null || echo false)
    [ "$res" = "true" ]
}

assert_node() {
    if ! check_node; then
        echo -e "\033[31mNode is not running!\033[0m"
        exit 0
    fi
}

warn_node_uptodate() {
    if ! uptodate_container "$docker_node_container"; then
        echo -e "\033[33mThe current node is not the latest available.\033[0m"
    fi
}

assert_node_uptodate() {
    may_pull_image
    assert_node
    if ! uptodate_container "$docker_node_container"; then
        echo -e "\033[33mThe current node is not the latest available.\033[0m"
        exit 1
    fi
}

status_node() {
    may_pull_image
    if check_node; then
        echo -e "\033[32mNode is running\033[0m"
        warn_node_uptodate
    else
        echo -e "\033[33mNode is not running\033[0m"
    fi
}

start_node() {
    pull_image
    if check_node; then
        echo -e "\033[31mNode is already running\033[0m"
        exit 1
    fi
    update_compose_file "$@"
    call_docker_compose up --no-start
    call_docker_compose start node
    echo -e "\033[32mThe node is now running.\033[0m"
}

log_node() {
    may_pull_image
    assert_node_uptodate
    call_docker_compose logs -f node
}

stop_node() {
    if ! check_node; then
        echo -e "\033[31mNo node to kill!\033[0m"
        exit 1
    fi
    echo -e "\033[32mStopping the node...\033[0m"
    call_docker_compose stop node
}


## Baker ###################################################################

check_baker() {
    update_active_protocol_version
    bakers="$(sed s/^/baker-/g "$active_protocol_versions")"
    docker_baker_containers="$(sed "s/^\(.*\)$/${docker_compose_name}_baker-\1_1/g" "$active_protocol_versions")"
    res=$(docker inspect \
                 --format="{{ .State.Running }}" \
                 --type=container "$(container_name "$docker_baker_containers")" 2>/dev/null || echo false)
    [ "$res" = "true" ]
}

assert_baker() {
    if ! check_baker; then
        echo -e "\033[31mBaker is not running!\033[0m"
        exit 0
    fi
}

assert_baker_uptodate() {
    assert_baker
    if ! uptodate_containers $docker_baker_containers; then
        echo -e "\033[33mThe current baker is not the latest available.\033[0m"
        exit 1
    fi
}

status_baker() {
    if check_baker; then
        echo -e "\033[32mBaker is running\033[0m"
        may_pull_image
        if ! uptodate_containers $docker_baker_containers; then
            echo -e "\033[33mThe current baker is not the latest available.\033[0m"
        fi
    else
        echo -e "\033[33mBaker is not running\033[0m"
    fi
}

start_baker() {
    if check_baker; then
        echo -e "\033[31mBaker is already running\033[0m"
        exit 1
    fi
    pull_image
    assert_node_uptodate
    call_docker_compose start $bakers
    echo -e "\033[32mThe baker is now running.\033[0m"
}

log_baker() {
    may_pull_image
    assert_baker_uptodate
    call_docker_compose logs -f $bakers
}

stop_baker() {
    if ! check_baker; then
        echo -e "\033[31mNo baker to kill!\033[0m"
        exit 1
    fi
    echo -e "\033[32mStopping the baker...\033[0m"
    call_docker_compose stop $bakers
}

## Endorser ###################################################################

check_endorser() {
    update_active_protocol_version
    endorsers="$(sed s/^/endorser-/g "$active_protocol_versions")"
    docker_endorser_containers="$(sed "s/^\(.*\)$/${docker_compose_name}_endorser-\1_1/g" "$active_protocol_versions")"
    res=$(docker inspect \
                 --format="{{ .State.Running }}" \
                 --type=container "$(container_name "$docker_endorser_containers")" 2>/dev/null || echo false)
    [ "$res" = "true" ]
}

assert_endorser() {
    if ! check_endorser; then
        echo -e "\033[31mEndorser is not running!\033[0m"
        exit 0
    fi
}

assert_endorser_uptodate() {
    assert_endorser
    if ! uptodate_containers $docker_endorser_containers; then
        echo -e "\033[33mThe current endorser is not the latest available.\033[0m"
        exit 1
    fi
}

status_endorser() {
    if check_endorser; then
        echo -e "\033[32mEndorser is running\033[0m"
        may_pull_image
        if ! uptodate_containers $docker_endorser_containers; then
            echo -e "\033[33mThe current endorser is not the latest available.\033[0m"
        fi
    else
        echo -e "\033[33mEndorser is not running\033[0m"
    fi
}

start_endorser() {
    if check_endorser; then
        echo -e "\033[31mEndorser is already running\033[0m"
        exit 1
    fi
    pull_image
    assert_node_uptodate
    call_docker_compose start $endorsers
    echo -e "\033[32mThe endorser is now running.\033[0m"
}

log_endorser() {
    may_pull_image
    assert_endorser_uptodate
    call_docker_compose logs -f $endorsers
}

stop_endorser() {
    if ! check_endorser; then
        echo -e "\033[31mNo endorser to kill!\033[0m"
        exit 1
    fi
    echo -e "\033[32mStopping the endorser...\033[0m"
    call_docker_compose stop $endorsers
}

## Accuser ###################################################################

check_accuser() {
    update_active_protocol_version
    accusers="$(sed s/^/accuser-/g "$active_protocol_versions")"
    docker_accuser_containers="$(sed "s/^\(.*\)$/${docker_compose_name}_accuser-\1_1/g" "$active_protocol_versions")"
    res=$(docker inspect \
                 --format="{{ .State.Running }}" \
                 --type=container "$(container_name "$docker_accuser_containers")" 2>/dev/null || echo false)
    [ "$res" = "true" ]
}

assert_accuser() {
    if ! check_accuser; then
        echo -e "\033[31mAccuser is not running!\033[0m"
        exit 0
    fi
}

assert_accuser_uptodate() {
    assert_accuser
    if ! uptodate_containers $docker_accuser_containers; then
        echo -e "\033[33mThe current accuser is not the latest available.\033[0m"
        exit 1
    fi
}

status_accuser() {
    if check_accuser; then
        echo -e "\033[32mAccuser is running\033[0m"
        may_pull_image
        if ! uptodate_containers $docker_accuser_containers; then
            echo -e "\033[33mThe current accuser is not the latest available.\033[0m"
        fi
    else
        echo -e "\033[33mAccuser is not running\033[0m"
    fi
}

start_accuser() {
    if check_accuser; then
        echo -e "\033[31mAccuser is already running\033[0m"
        exit 1
    fi
    pull_image
    assert_node_uptodate
    call_docker_compose start $accusers
    echo -e "\033[32mThe accuser is now running.\033[0m"
}

log_accuser() {
    may_pull_image
    assert_accuser_uptodate
    call_docker_compose logs -f $accusers
}

stop_accuser() {
    if ! check_accuser; then
        echo -e "\033[31mNo accuser to kill!\033[0m"
        exit 1
    fi
    echo -e "\033[32mStopping the accuser...\033[0m"
    call_docker_compose stop $accusers
}

## Misc ####################################################################

run_client() {
    assert_node_uptodate
    exec_docker "tezos-client" "$@"
}

run_admin_client() {
    assert_node_uptodate
    exec_docker "tezos-admin-client" "$@"
}

run_shell() {
    assert_node_uptodate
    if [ $# -eq 0 ]; then
        exec_docker /bin/sh
    else
        exec_docker /bin/sh -c "$@"
    fi
}

display_head() {
    assert_node_uptodate
    exec_docker tezos-client rpc get /chains/main/blocks/head/header
}

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

start() {
    pull_image
    update_compose_file "$@"
    call_docker_compose up -d --remove-orphans
    warn_script_uptodate
}

stop() {
    call_docker_compose down
}

kill_() {
    call_docker_compose kill
    stop
}

status() {
    status_node
    status_baker
    status_endorser
    warn_script_uptodate verbose
}

warn_script_uptodate() {
    if [[ $ALPHANET_EMACS ]]; then
       return
    fi
    docker run --entrypoint /bin/cat "$docker_image" \
       "/usr/local/share/tezos/alphanet.sh" > ".alphanet.sh.new"
    if ! diff .alphanet.sh.new  "$0" >/dev/null 2>&1 ; then
        echo -e "\033[33mWarning: the container contains a new version of 'alphanet.sh'.\033[0m"
        echo -e "\033[33mYou might run '$0 update_script' to synchronize.\033[0m"
    elif [ "$1" = "verbose" ] ; then
        echo -e "\033[32mThe script is up to date.\033[0m"
    fi
    rm .alphanet.sh.new
}

update_script() {
    docker run --entrypoint /bin/cat "$docker_image" \
       "/usr/local/share/tezos/alphanet.sh" > ".alphanet.sh.new"
    if ! diff .alphanet.sh.new  "$0" >/dev/null 2>&1 ; then
        mv .alphanet.sh.new "$0"
        echo -e "\033[32mThe script has been updated.\033[0m"
    else
        rm .alphanet.sh.new
        echo -e "\033[32mThe script is up to date.\033[0m"
    fi
}

usage() {
    echo "Usage: $0 [GLOBAL_OPTIONS] <command> [OPTIONS]"
    echo "  Main commands:"
    echo "    $0 start [--rpc-port <int>] [OPTIONS]"
    echo "       Launch a full Tezos alphanet node in a docker container"
    echo "       automatically generating a new network identity."
    echo "       OPTIONS (others than --rpc-port) are directly passed to the"
    echo "       Tezos node, see '$0 shell tezos-node config --help'"
    echo "       for more details."
    echo "       By default, the RPC port is not exported outside the docker"
    echo "       container. WARNING: when exported some RPCs could be harmful"
    echo "       (e.g. 'inject_block', 'force_validation', ...), it is"
    echo "       advised not to export them publicly."
    echo "    $0 <stop|kill>"
    echo "       Friendly or brutally stop the node."
    echo "    $0 restart"
    echo "       Friendly stop the node, fetch the latest docker image and "
    echo "       update this script, then start the node again."
    echo "       The blockchain data are preserved."
    echo "    $0 clear"
    echo "       Remove all the blockchain data from the disk (except"
    echo "       for secret keys and other configuration backup)."
    echo "    $0 status"
    echo "       Check that the running node is running and up to date."
    echo "       Upgrade is automatically done by the start command."
    echo "    $0 head"
    echo "       Display info about the current head of the blockchain."
    echo "    $0 client <COMMAND>"
    echo "       Pass a command to the tezos client."
    echo "    $0 update_script"
    echo "       Replace 'alphanet.sh' with the one found in the docker image."
    echo "  Advanced commands:"
    echo "    $0 node <start|stop|status|log>"
    echo "    $0 baker <start|stop|status|log>"
    echo "    $0 endorser <start|stop|status|log>"
    echo "    $0 shell"
    echo "Node configuration backup directory: $data_dir"
    echo "Global options are currently limited to:"
    echo "  --port <int>"
    echo "      change public the port Tezos node"
    echo "Container prefix:"
    echo "    container:<FILE>"
    echo "      can be used anywhere 'file:<FILE>' is permitted in client commands."
    echo "      It will cause the referenced file to be copied into the docker conainer."
    echo "      Files will be renamed, which may make errors difficult to read"
}

## Dispatch ################################################################

if [ "$#" -ge 2 ] && [ "$1" = "--port" ] ; then
    port="$2"
    suffix="$port"
    shift 2
fi

command="$1"
if [ "$#" -eq 0 ] ; then usage ; exit 1;  else shift ; fi

case $(basename "$0") in
    localnet.sh)
        docker_base_dir="$HOME/.tezos-localnet"
        docker_image=tezos:latest
        docker_compose_base_name=localnet
        default_port=14732
        ;;
    zeronet.sh)
        docker_base_dir="$HOME/.tezos-zeronet"
        docker_image=tezos/tezos:zeronet
        docker_compose_base_name=zeronet
        default_port=19732
        ;;
    betanet.sh)
        if [ -d "$HOME/.tezos-mainnet" ] ; then
            echo 'You already upgraded, please only use `mainnet.sh` now.'
            exit 1
        else
            echo 'A new script `mainnet.sh` is now available.'
            echo 'The current `betanet.sh` still works, but we recommend that you upgrade.'
        fi
        docker_base_dir="$HOME/.tezos-betanet"
        docker_image=tezos/tezos:mainnet
        docker_compose_base_name=betanet
        default_port=9732
        ;;
    mainnet.sh)
        if [ -d "$HOME/.tezos-betanet" ] ; then
            echo 'Folder "'$HOME'/.tezos-betanet" detected.'
            echo 'To upgrade to the mainnet script, execute the following commands.'
            echo '  `betanet.sh stop`'
            echo 'Make sure that your node is stopped using `docker ps`.'
            echo '  `mv "'$HOME'/.tezos-betanet" "'$HOME'/.tezos-mainnet"`'
            echo '  `mainnet.sh start`'
            exit 1
        fi
        docker_base_dir="$HOME/.tezos-mainnet"
        docker_image=tezos/tezos:mainnet
        docker_compose_base_name=mainnet
        default_port=9732
        ;;
    *)
        docker_base_dir="$HOME/.tezos-alphanet"
        docker_image=tezos/tezos:alphanet
        docker_compose_base_name="alphanet"
        default_port=9732
        ;;
esac

if [ -n "$suffix" ] ; then
    mkdir -p "$docker_base_dir"
    echo "$port" > "$docker_base_dir/default_port"
elif [ -f "$docker_base_dir/default_port" ]; then
    port=$(cat "$docker_base_dir/default_port")
    suffix="$port"
else
    port=$default_port
fi

docker_dir="$docker_base_dir$suffix"
docker_compose_yml="$docker_dir/docker-compose.yml"
docker_pull_timestamp="$docker_dir/docker_pull.timestamp"
active_protocol_versions="$docker_dir/active_protocol_versions"
docker_compose_name="$docker_compose_base_name$suffix"

docker_node_container=${docker_compose_name}_node_1

docker_node_volume=${docker_compose_name}_node_data
docker_client_volume=${docker_compose_name}_client_data

mkdir -p "$docker_dir"

case "$command" in

    ## Main

    start)
        start "$@"
        ;;
    restart)
        stop
        update_script
        export TEZOS_ALPHANET_DO_NOT_PULL=yes
        exec "$0" start "$@"
        ;;
    clear)
        clear_node_volume
        ;;
    status)
        status
        ;;
    stop)
        stop
        ;;
    kill)
        kill_
        ;;

    ## Node

    node)
        subcommand="$1"
        if [ "$#" -eq 0 ] ; then usage ; exit 1;  else shift ; fi
        case "$subcommand" in
            start)
                start_node "$@"
                ;;
            status)
                status_node
                ;;
            log)
                log_node
                ;;
            stop)
                stop_node
                ;;
            *)
                usage
                exit 1
        esac ;;
    ## Baker

    baker)
        subcommand="$1"
        if [ "$#" -eq 0 ] ; then usage ; exit 1;  else shift ; fi
        case "$subcommand" in
            status)
                status_baker
                ;;
            start)
                start_baker
                ;;
            log)
                log_baker
                ;;
            stop)
                stop_baker
                ;;
            *)
                usage
                exit 1
        esac ;;

    ## Endorser

    endorser)
        subcommand="$1"
        if [ "$#" -eq 0 ] ; then usage ; exit 1;  else shift ; fi
        case "$subcommand" in
            status)
                status_endorser
                ;;
            start)
                start_endorser
                ;;
            log)
                log_endorser
                ;;
            stop)
                stop_endorser
                ;;
            *)
                usage
                exit 1
        esac ;;

    ## Accuser

    accuser)
        subcommand="$1"
        if [ "$#" -eq 0 ] ; then usage ; exit 1;  else shift ; fi
        case "$subcommand" in
            status)
                status_accuser
                ;;
            start)
                start_accuser
                ;;
            log)
                log_accuser
                ;;
            stop)
                stop_accuser
                ;;
            *)
                usage
                exit 1
        esac ;;

    ## Misc.

    head)
        display_head
        ;;
    shell)
        run_shell "$@"
        ;;
    client)
        run_client "$@"
        ;;
    admin-client)
        run_admin_client "$@"
        ;;
    check_script)
        warn_script_uptodate verbose
        ;;
    update_script)
        update_script
        ;;
    *)
        usage
        exit 1
        ;;
esac