#!/bin/bash
set -e

cd $(dirname $0)/..

source scripts/build-common

HOST_ARCH=${HOST_ARCH:-amd64}
ARCH=${ARCH:-amd64}

declare -A qemuarch=( ["amd64"]="x86_64" ["arm"]="arm" ["arm64"]="aarch64" )
declare -A ttycons=( ["amd64"]="ttyS0" ["arm"]="ttyAMA0" ["arm64"]="ttyAMA0" )
declare -A machine=( ["amd64"]="" ["arm"]="-M virt" ["arm64"]="-M virt" )
declare -A cpu=( ["amd64"]="" ["arm"]="-cpu cortex-a8" ["arm64"]="-cpu cortex-a57" )
declare -A network=(
    ["amd64"]="-net nic,vlan=0,model=virtio -net user,vlan=0,hostfwd=tcp::2222-:22,hostname=rancher-dev"
    ["arm"]="-netdev user,id=unet,hostfwd=tcp::2222-:22,hostname=rancher-dev -device virtio-net-device,netdev=unet"
)
network["arm64"]=${network["arm"]}

hd_amd64() {
    echo "-drive if=virtio,file=$1"
}
hd_arm() {
    echo "-drive if=none,id=hd0,file=$1 -device virtio-blk-device,drive=hd0"
}
declare -A hd=( ["amd64"]="hd_amd64" ["arm"]="hd_arm" ["arm64"]="hd_arm" )

cd_amd64() {
    echo "-hdc $1"
}
cd_arm() {
    echo "-drive if=none,id=cd0,file=$1 -device virtio-blk-device,drive=cd0"
}
declare -A cd=( ["amd64"]="cd_amd64" ["arm"]="cd_arm" ["arm64"]="cd_arm" )

BASE=$(pwd)
UNAME=$(uname)

KERNEL=${BASE}/dist/artifacts/vmlinuz
INITRD=${BASE}/dist/artifacts/initrd

QEMU=1
FORMAT=1
RM_USR=1
REBUILD=1

while [ "$#" -gt 0 ]; do
    case $1 in
        --append)
            shift 1
            QEMU_APPEND="${QEMU_APPEND} $1"
            ;;
        --name)
            shift 1
            NAME="$1"
            ;;
        --cloud-config)
            shift 1
            CLOUD_CONFIG="$1" || :
            if [ ! -f ${CLOUD_CONFIG} ]; then
                echo No such file: "'"${CLOUD_CONFIG}"'" 1>&2
                exit 1
            fi
            ;;
        --arch)
            shift 1
            ARCH="$1"
            ;;
        --qemu)
            QEMU=1
            ;;
        --qind)
            QIND=1
            QEMU=0
            ;;
        --kvm)
            KVM=1
            ;;
        --no-format)
            FORMAT=0
            ;;
        --no-rm-usr)
            RM_USR=0
            ;;
        --no-rebuild)
            REBUILD=0
            ;;
        --fresh)
            FRESH=1
            ;;
        *)
            break
            ;;
    esac
    shift 1
done

QEMUARCH=${qemuarch["${ARCH}"]}
TTYCONS=${ttycons["${ARCH}"]}

if [ "$QEMU" == "1" ] && ! which qemu-system-${QEMUARCH}; then
    QEMU=0
fi

if [[ ! -e ${KERNEL} || ! -e ${INITRD} ]]; then
    echo "Failed to find ${KERNEL} or ${INITRD}" 1>&2
    exit 1
fi

# Linux and Darwin SHA1 sum binary are different, pick which to use
if [ "$UNAME" == "Darwin" ]; then sha1sum=$(which shasum)
elif [ "$UNAME" == "Linux" ]; then sha1sum=$(which sha1sum);
fi

if [ "$REBUILD" == "1" ]; then
    INITRD_TMP=${BUILD}/$(${sha1sum} ${INITRD} | awk '{print $1}')
    INITRD_CURRENT=${BUILD}/initrd-current
    INITRD_TEST=${BUILD}/initrd.test

    if [ ! -d ${INITRD_TMP} ]; then
        mkdir -p ${INITRD_TMP}
        pushd ${INITRD_TMP}
        xz -dfc ${INITRD} | gunzip -f | cpio -idm
        popd
    fi

    if [ -e ${INITRD_CURRENT} ]; then
        rm -f ${INITRD_CURRENT}
    fi

    ln -s ${INITRD_TMP} ${INITRD_CURRENT}

    mkdir -p ${INITRD_TMP}/usr/{bin,share/ros}
    cp bin/ros ${INITRD_TMP}/usr/bin/
    cp -f build/os-config.yml ${INITRD_TMP}/usr/share/ros/

    pushd ${INITRD_TMP}
    find . | cpio -H newc -o | gzip > ${INITRD_TEST}
    popd
    INITRD=${INITRD_TEST}
fi

KERNEL_ARGS="quiet rancher.password=rancher console=${TTYCONS} ${QEMU_APPEND}"
if [ "$FORMAT" == "1" ]; then
    KERNEL_ARGS="${KERNEL_ARGS} rancher.state.formatzero=true rancher.state.autoformat=[/dev/sda,/dev/vda]"
fi
if [ "$RM_USR" == "1" ]; then
    KERNEL_ARGS="${KERNEL_ARGS} rancher.rm_usr"
fi

if [ "$KVM" == "" ] && [ -c /dev/kvm ] && [ -r /dev/kvm ] && [ -w /dev/kvm ]; then
    KVM=1
fi

if [ "$QEMU" == "1" ]; then

    HD=${BASE}/state/hd.img
    [ "$FRESH" == "1" ] && rm -f ${HD} >/dev/null 2>&1 || :
    if [ ! -e ${HD} ]; then
        mkdir -p $(dirname ${HD})
        qemu-img create -f qcow2 -o size=10G ${HD}
    fi


    CCIMG=${BUILD}/cc.img
    CCDEV=$(losetup -f)
    CCROOT=${BUILD}/cloud-config
    dd if=/dev/zero of=${CCIMG} bs=1024 count=512
    losetup ${CCDEV} ${CCIMG}
    mkfs.vfat -n "config-2" ${CCDEV}

    rm -rf ${CCROOT}
    mkdir -p ${CCROOT}
    mount ${CCDEV} ${CCROOT}

    USER_DATA=${CCROOT}/openstack/latest/user_data
    mkdir -p $(dirname ${USER_DATA})
    rm -f ${USER_DATA} || :
    if [ -n "$CLOUD_CONFIG" ]; then
        cat ${CLOUD_CONFIG} > ${USER_DATA}
    else
        echo "#cloud-config" > ${USER_DATA}
        echo "ssh_authorized_keys:" >> ${USER_DATA}
        echo "- $(<${BASE}/assets/rancher.key.pub)" >> ${USER_DATA}
    fi

    umount ${CCROOT}
    losetup -d ${CCDEV}


    CPU=${cpu["$ARCH"]}
    if [ "$KVM" == "1" ] && [ "$ARCH" == "$HOST_ARCH" ]; then
        KVM_ENABLE="-enable-kvm"
        CPU="-cpu host"
    fi
    set -x
    exec qemu-system-${QEMUARCH} -serial stdio \
        -rtc base=utc,clock=host \
        ${KVM_ENABLE} \
        ${CPU} \
        ${machine["$ARCH"]} \
        -kernel ${KERNEL} \
        -initrd ${INITRD} \
        -m 2048 \
        ${network["$ARCH"]} \
        $(eval "${cd["$ARCH"]} ${CCIMG}") \
        $(eval "${hd["$ARCH"]} ${HD}") \
        -smp 1 \
        -append "${KERNEL_ARGS}" \
        -nographic \
        -display none \
        ${QEMU_ARGS} \
        "${@}"

elif [ "$QIND" == "1" ]; then

    NAME=${NAME:-ros-qind}

    if [ "$FRESH" == "1" ]; then
        docker rm -fv ${NAME} >/dev/null 2>&1 || :
    fi
    if ! docker inspect ${NAME} >/dev/null 2>&1; then
        if [ "$KVM" == "1" ]; then
            KVM_ENABLE="--device=/dev/kvm:/dev/kvm"
        fi

        mkdir -p ./tmp
        TMP=$(mktemp -d ./tmp/ros-qind-XXXXXX)
        mkdir -p ${TMP}/stuff
        trap "rm -rf ${TMP}" EXIT
        ln ${CLOUD_CONFIG} ${KERNEL} ${INITRD} ./assets/rancher.key ./assets/rancher.key.pub ${TMP}/stuff/

        KERNEL_FILE=$(basename ${KERNEL})
        INITRD_FILE=$(basename ${INITRD})

        if [ -n "$CLOUD_CONFIG" ]; then
            CLOUD_CONFIG_ENABLE="--cloud-config /stuff/$(basename ${CLOUD_CONFIG})"
        else
            SSH_PUB_ENABLE="--ssh-pub /stuff/rancher.key.pub"
        fi

        set -x
        docker create --name=${NAME} -it ${KVM_ENABLE} \
                    rancher/qind \
                    --hostname "rancher-dev" \
                    ${CLOUD_CONFIG_ENABLE} \
                    ${SSH_PUB_ENABLE} \
                    -m 1G -kernel /stuff/${KERNEL_FILE} -initrd /stuff/${INITRD_FILE} -append "${KERNEL_ARGS}" \
                    "${@}"

        docker cp ${TMP}/stuff ${NAME}:/stuff
        rm -rf ${TMP}
    fi
    exec docker start -ai ${NAME}

else
    exit 42
fi