#!/bin/bash

set -euf -o pipefail

scripts=$(dirname $0)
# shellcheck source=jenkins-helpers.sh
. $scripts/jenkins-helpers.sh
# shellcheck source=round-robin.sh
. $scripts/round-robin.sh

convert_args_to_variables "$@"

obligatory_variables rr[ci_config]
declare -A rr

# Execution mode: baseline, bisect, jenkins-full
rr[mode]="${rr[mode]-baseline}"

# Set custom revision for one of the projects, and use baseline revisions
# for all other projects.
rr[ci_project]="${rr[ci_project]-tcwg_kernel}"
rr[baseline_branch]="${rr[baseline_branch]-linaro-local/ci/${rr[ci_project]}/${rr[ci_config]}}"
rr[update_baseline]="${rr[update_baseline]-update}"
rr[top_artifacts]="${rr[top_artifacts]-$(pwd)/artifacts}"

# {toolchain_name}-{toolchain_ver}-{target}-{linux}-{linux_config}
IFS=- read -a ci_config <<EOF
${rr[ci_config]}
EOF
rr[toolchain]=${rr[toolchain]-${ci_config[0]}}
rr[release]=${rr[release]-${ci_config[1]}}
rr[target]=${rr[target]-${ci_config[2]}}
rr[linux_config]=${rr[linux_config]-${ci_config[4]}}

case "${rr[toolchain]}" in
    llvm)
        rr[components]="binutils llvm linux qemu" ;;
    gnu)
        rr[components]="binutils gcc linux qemu" ;;
    *) assert_with_msg "Unknown toolchain \"${rr[toolchain]}\"" false ;;
esac

# Use baseline branches by default.
for c in ${rr[components]}; do
    rr[${c}_git]=${rr[${c}_git]-baseline}
done

start_at="${start_at-default}"
finish_at="${finish_at-default}"
verbose="${verbose-true}"
verbose2="${verbose2-false}"

if $verbose2; then set -x; fi

trap print_traceback EXIT

# Set start and finish steps for different modes.
default_start_at=""
default_finish_at=""
case "${rr[mode]}" in
    "baseline")
	default_finish_at="update_baseline"
	;;
    "bisect")
	case "$(print_single_updated_component)" in
	    binutils) default_start_at="build_abe-binutils" ;;
	    gcc) default_start_at="build_abe-stage1" ;;
	    llvm) default_start_at="build_llvm" ;;
	    linux) default_start_at="build_linux" ;;
	    qemu) default_start_at="build_abe-qemu" ;;
	    *) assert false ;;
	esac
	default_finish_at="check_regression"
	;;
    "jenkins-full") ;;
esac
if [ x"$start_at" = x"default" ]; then
    start_at="$default_start_at"
fi
if [ x"$finish_at" = x"default" ]; then
    finish_at="$default_finish_at"
fi

run_step_init "$start_at" "$finish_at" "${rr[top_artifacts]}" "$verbose"

# Build Linux kernel
build_linux_1 ()
{
    (
    set -euf -o pipefail

    sanity_check_pwd

    clone_repo linux

    # shellcheck disable=SC2115
    rm -rf "$(pwd)"/bin
    mkdir "$(pwd)"/bin

    local gnu_host abe_bin cc ld_opt=""

    gnu_host=$(print_gnu_target native)
    abe_bin="$(pwd)/abe/builds/destdir/$gnu_host/bin"
    # Use binutils $abe_bin for both GNU and LLVM builds.
    # For LLVM builds at the very least we need target assembler, since,
    # otherwise, clang will try to use /usr/bin/as for cases that integrated
    # assembler can't handle.
    export PATH="$abe_bin:$PATH"

    case "${rr[toolchain]}" in
	llvm)
	    local llvm_bin
	    llvm_bin="$(pwd)/llvm-install/bin"
	    export PATH="$llvm_bin:$PATH"

	    cc="$llvm_bin/clang"
	    ld_opt="LD=$llvm_bin/ld.lld"
	    ;;
	gnu)
	    cc="$abe_bin/$(print_gnu_target ${rr[target]})-gcc"
	    ;;
    esac

    # Use ccache only when bisecting linux or qemu (or preparing to).
    # Otherwise the compiler is new in every build and we would
    # only clobber ccache volume.
    local ccache=""
    case "${rr[mode]}:$(print_single_updated_component)" in
	"baseline:") ccache="ccache" ;;
	"bisect:linux") ccache="ccache" ;;
	"bisect:qemu") ccache="ccache" ;;
    esac
    cat > "$(pwd)"/bin/${rr[target]}-cc <<EOF
#!/bin/sh
exec $ccache $cc "\$@"
EOF
    chmod +x "$(pwd)"/bin/${rr[target]}-cc

    # Define make variables.
    local opts
    opts="CC=$(pwd)/bin/${rr[target]}-cc $ld_opt SUBLEVEL=0 EXTRAVERSION=-bisect"
    if [ x"${rr[target]}" != x"$(uname -m)" ]; then
	opts="$opts ARCH=$(print_kernel_target ${rr[target]})"
	opts="$opts CROSS_COMPILE=$(print_gnu_target ${rr[target]})-"
	opts="$opts HOSTCC=gcc"
    fi

    cd linux

    make $opts distclean

    make $opts ${rr[linux_config]}
    sed -i -e 's:CONFIG_LOCALVERSION_AUTO=y:# CONFIG_LOCALVERSION_AUTO is not set:' .config
    set +f; rm -f localversion*; set -f
    make $opts oldconfig

    ccache -z
    KBUILD_BUILD_TIMESTAMP=0 make $opts -j"$(nproc --all)" -s -k &
    local res=0 && wait $! || res=$?
    ccache -s
    return $res
    )
}

# Build linux and count number successfully built .o files in linux
build_linux ()
{
    (
    set -euf -o pipefail

    build_linux_1 &
    local res=0 && wait $! || res=$?

    # Number of .o files created is the main success metric.
    local linux_n_obj
    linux_n_obj=$(find linux -name "*.o" | wc -l)
    echo "# linux_n_obj:" >> ${rr[top_artifacts]}/results
    echo "$linux_n_obj" >> ${rr[top_artifacts]}/results

    if [ $res = 0 ]; then
	echo "# linux build successful:" >> ${rr[top_artifacts]}/results
	echo "all" >> ${rr[top_artifacts]}/results
    fi

    return $res
    )
}

# Boot linux kernel
boot_linux ()
{
    (
    set -euf -o pipefail

    local image cpu
    case ${rr[target]} in
	aarch64)
	    image=linux/arch/arm64/boot/Image.gz
	    cpu="-cpu cortex-a53"
	    ;;
	arm)
	    image=linux/arch/arm/boot/zImage
	    cpu=""
	    ;;
	*) assert false ;;
    esac

    local gnu_host qemu
    gnu_host=$(print_gnu_target native)
    qemu="$(pwd)/abe/builds/hosttools/$gnu_host/bin/qemu-system-${rr[target]}"

    timeout --foreground 60s "$qemu" \
	    -kernel $image -machine virt $cpu -m 512 \
	    -serial stdio -display none \
	    -append "console=ttyAMA0 panic=-1" -no-reboot

    echo "# linux boot successful:" >> ${rr[top_artifacts]}/results
    echo "boot" >> ${rr[top_artifacts]}/results
    )
}

# Exit with code 0 if no regression compared to base-artifacts/results.
no_regression_p ()
{
    (
    set -euf -o pipefail

    local ref_artifacts=$1
    local new_artifacts=$2

    local linux_n_obj
    linux_n_obj=$(grep -v "^#" $new_artifacts/results | tail -n1)

    # Assume worst for non-existent baseline.
    local base_linux_n_obj="-10"
    if [ -f $ref_artifacts/results ]; then
	base_linux_n_obj=$(grep -v "^#" $ref_artifacts/results | tail -n1)
    fi

    local res=""
    case "$linux_n_obj:$base_linux_n_obj" in
	boot:*) res=0 ;;
	*:boot) res=1 ;;
	all:*) res=0 ;;
	*:all) res=1 ;;
    esac

    if [ x"$res" != x"0" ]; then
	local build_res

	no_build_regression_p "$@" &
	build_res=0 && wait $! || build_res=$?

	if [ x"$res" = x"" ]; then
	    res=$build_res
	fi
    fi

    return $res
    )
}

# Implement rr[breakup_updated_components] hook.
tcwg_kernel_breakup_updated_components ()
{
    (
    set -euf -o pipefail

    # Linux changes tend to cause the most regressions.
    # Breakup updated components into linux and the rest of components
    # to reduce the number of builds.
    if print_updated_components "\n" | grep -q "^linux\$"; then
	echo "linux"
	print_updated_components "\n" | grep -v "^linux\$" | tr '\n' ' ' | sed -e "s/ \$//g"
	echo
    else
	print_updated_components "\n"
    fi
    )
}
rr[breakup_updated_components]=tcwg_kernel_breakup_updated_components

run_step stop_on_fail -10 reset_artifacts
run_step stop_on_fail x prepare_abe
run_step skip_on_fail -9 build_abe binutils
case "${rr[toolchain]}" in
    gnu)
	run_step skip_on_fail -5 build_abe stage1
	;;
    llvm)
	run_step skip_on_fail -5 build_llvm
	;;
esac
run_step skip_on_fail -2 build_abe qemu
run_step skip_on_fail x build_linux
run_step skip_on_fail x boot_linux
run_step reset_on_fail x check_regression
run_step stop_on_fail x update_baseline
run_step stop_on_fail x push_baseline

trap "" EXIT