#!/bin/bash

# Pretty name for PROJECT's version
#rr[PROJECT_version]

# PROJECT's git url
#rr[PROJECT_url]

# PROJECT's git branch or SHA1 revision parsable by git rev-parse.
#rr[PROJECT_branch]

# PROJECT's git SHA1 revision.  These are mostly used in manifests.
#rr[PROJECT_rev]

# Baseline branch name for current configuration.  These branches are
# present in all above git repos.
#rr[baseline_branch]="linaro-local/ci/CONFIGURATION"

# PROJECT that we are testing in this build.  Use ${rr[current_branch]} for
# this project, and ${rr[baseline_branch]} for all other projects.
#rr[current_project]="$current_project"

# Git branch or SHA1 revision of ${rr[current_project]} to test.
#rr[current_branch]="$current_branch"

# Run mode: bisect or non-bisect.  In bisect mode we do a couple things
# slightly differently (e.g., don't touch repo in clone_repo() ).
#rr[mode]="$mode"

# Ignore failures in check_regression, which forces update_baseline().
#rr[reset_baseline]="$reset_baseline"

# Target architecture to build for: arm or aarch64.
#rr[target]="$target"

# Top-level artifacts directory.
#rr[top_artifacts]="$top_artifacts"

# Reset artifacts to an empty state.  ${rr[top_artifacts]}/results is the most
# important artifact, since it records the metric of how successful the build
# is.
reset_artifacts ()
{
    (
    set -euf -o pipefail

    # Clean ${rr[top_artifacts]} but preserve
    # - ${rr[top_artifacts]}/console.log and $run_step_artifacts/console.log, which
    # are being written to by run_step().
    # - ${rr[top_artifacts]}/jenkins/*, which is cleaned by tcwg_kernel.yaml.
    fresh_dir $run_step_top_artifacts \
	      $run_step_top_artifacts/console.log \
	      $run_step_artifacts/console.log \
	      "$run_step_top_artifacts/jenkins/*"

    local single_branch=${rr[baseline_branch]}

    # Clone base-artifacts so that run_step can rsync artifacts for skipped
    # steps.
    # base-artifacts repo is big and changes all the time, so we
    # fetch only the $baseline_branch, instead of all branches.
    rr[base-artifacts_rev]="${rr[base-artifacts_rev]-${rr[baseline_branch]}}"
    clone_or_update_repo base-artifacts ${rr[base-artifacts_rev]} https://git-us.linaro.org/toolchain/ci/base-artifacts.git auto $single_branch
    cat <<EOF | manifest_out
rr[base-artifacts_rev]=$(git -C base-artifacts rev-parse HEAD)
EOF
    )
}

# Clone repository for $project
# $1: Repo / project name
clone_repo ()
{
    (
    set -euf -o pipefail
    local project="$1"

    if [ x"${rr[mode]}" = x"bisect" ]; then
	# Cleanup current checkout in bisect mode.
	git_clean "$project"
	return 0
    fi

    local branch
    # Select the branch to build.
    # ${rr[current_branch]} specifies branch for ${rr[current_project]},
    # and everything else uses baseline branch.
    if [ x"$project" = x"${rr[current_project]}" ]; then
	if [ x"${rr[current_branch]}" = x"default" ]; then
	    branch=${rr[${current_project}_branch]}
	elif [ x"${rr[current_branch]}" = x"baseline" ]; then
	    branch="refs/remotes/baseline/${rr[baseline_branch]}"
	else
	    branch=${rr[current_branch]}
	fi
    else
	branch="refs/remotes/baseline/${rr[baseline_branch]}"
    fi

    branch="${rr[${project}_rev]-$branch}"

    # Decide on whether to use read-only or read-write mode for
    # refs/remotes/baseline.  We use read-only wherever possible to allow
    # developers without ssh keys on Linaro git servers to reproduce builds
    # in --mode "baseline".
    local read_only="true"
    if [ x"$project" = x"${rr[current_project]}" -a \
	  x"${rr[mode]}" = x"jenkins-full" ]; then
	read_only=false
    fi

    # Clone origin remote
    clone_or_update_repo_no_checkout $project ${rr[${project}_url]} auto "" > /dev/null
    # Add baseline remote
    git_init_linaro_local_remote $project baseline $read_only
    # Checkout, now that we have both origin and baseline remotes ready.
    clone_or_update_repo $project $branch ${rr[${project}_url]} > /dev/null

    local cur_rev
    cur_rev=$(git -C $project rev-parse HEAD)

    cat <<EOF | manifest_out
rr[${project}_rev]=$cur_rev
EOF

    if [ x"$project" = x"${rr[current_project]}" ]; then
	local baseline_rev
	baseline_rev=$(git_rev_parse_long $project ${rr[baseline_branch]} baseline)
	# Prepare for failure.  If build fails we will bisect sha1 for
	# ${rr[current_branch]} and sha1 for ${rr[baseline_branch]}.
	cat > ${rr[top_artifacts]}/trigger-bisect-on-failure <<EOF
current_project=${rr[current_project]}
baseline_rev=$baseline_rev
bad_rev=$cur_rev
EOF
	git -C $project rev-list --count HEAD ^$baseline_rev > ${rr[top_artifacts]}/distance-to-baseline
    fi
    )
}

# Prepare ABE tree for [partial] GNU builds
prepare_abe ()
{
    (
    set -euf -o pipefail

    clone_or_update_repo abe tested https://git-us.linaro.org/toolchain/abe.git > /dev/null

    cd abe

    # Add ccache wrappers.
    rm -rf $(pwd)/bin
    mkdir $(pwd)/bin

    cat > $(pwd)/bin/gcc <<EOF
#!/bin/sh
exec ccache /usr/bin/gcc "\$@"
EOF
    chmod +x $(pwd)/bin/gcc

    cat > $(pwd)/bin/g++ <<EOF
#!/bin/sh
exec ccache /usr/bin/g++ "\$@"
EOF
    chmod +x $(pwd)/bin/g++

    export PATH=$(pwd)/bin:$PATH

    ./configure --with-git-reference-dir=/home/tcwg-buildslave/snapshots-ref
    )
}

# Build ABE component
# $1: Component -- ABE component to build.
build_abe ()
{
    (
    set -euf -o pipefail

    local component="$1"

    local project stage
    case "$component" in
	stage1)
	    project=gcc
	    stage="--stage 1"
	    ;;
	stage2)
	    project=gcc
	    stage="--stage 2"
	    ;;
	*)
	    project=$component
	    stage=""
	    ;;
    esac

    clone_repo $project

    # Don't use ABE's repo clone functions and setup abe/snapshots/ directory
    # to have the right entries.
    local git_dir git_path
    git_dir="$(basename ${rr[${project}_url]})"
    git_path="abe/snapshots/$git_dir"
    rm -rf $git_path $git_path~master
    ln -s $(pwd)/$project $git_path
    ln -s $(pwd)/$project $git_path~master

    cd abe

    local gnu_target
    gnu_target=$(print_gnu_target ${rr[target]})

    # Remove previous build directories and .stamp files.
    # We rely on ccache for fast rebuilds.
    set +f; rm -rf builds/x86_64-unknown-linux-gnu/$gnu_target/$git_dir~master*; set -f

    export PATH=$(pwd)/bin:$PATH

    if [ x"$component" != x"stage2" ]; then
	# TODO: Fix install_sysroot logic in ABE.
	# ABE tries to install sysroot even for partial builds, e.g.,
	# with "--build binutils".  Workaround by patching ABE.
	sed -i -e "s/do_install_sysroot/:/" lib/control.sh
    else
	git checkout -- lib/control.sh
    fi

    ccache -z
    # Run "./abe.sh --build $project".
    ./abe.sh \
	--build $project \
	--target $gnu_target \
	--extraconfigdir config/master \
	--disable update \
	$project=${rr[${project}_url]}~master \
	$stage
    ccache -s
    )
}

# Build LLVM
build_llvm ()
{
    (
    set -euf -o pipefail

    clone_repo llvm

    # Copy only components from the monorepo that are required for kernel build
    rsync -a --del --exclude /tools/clang llvm/llvm/ llvm-src/
    rsync -a --del llvm/clang/ llvm-src/tools/clang/

    # Setup ccache and ninja wrappers.
    rm -rf $(pwd)/bin
    mkdir $(pwd)/bin

    cat > $(pwd)/bin/cc <<EOF
#!/bin/sh
exec ccache /usr/bin/gcc "\$@"
EOF
    chmod +x $(pwd)/bin/cc

    cat > $(pwd)/bin/c++ <<EOF
#!/bin/sh
exec ccache /usr/bin/g++ "\$@"
EOF
    chmod +x $(pwd)/bin/c++

    if [ -f /usr/local/bin/ninja.bin ]; then
	# Use ninja configuration from llvm buildbots to avoid running out of RAM.
	cat > $(pwd)/bin/ninja <<EOF
#!/bin/sh
exec /usr/local/bin/ninja.bin -m 30 -M 50 -D 5000 "\$@"
EOF
	chmod +x $(pwd)/bin/ninja
    fi

    export PATH=$(pwd)/bin:$PATH

    # Remove stale build directories.  We rely on ccache for fast rebuilds.
    rm -rf llvm-build llvm-install
    mkdir -p llvm-build
    cd llvm-build

    cmake -G Ninja  ../llvm-src -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=True -DCMAKE_INSTALL_PREFIX=../llvm-install -DLLVM_TARGETS_TO_BUILD=$(print_llvm_target ${rr[target]})
    ccache -z
    ninja
    ninja install
    ccache -s
    )
}

# Check if current build regressed compared to the baseline
# (unless ${rr[reset_baseline]} is set).
check_regression ()
{
    (
    set -euf -o pipefail

    if ! ${rr[reset_baseline]} && ! no_regression_p; then
	# Fail.
	false
    fi
    )
}

# Commit current result and artifacts to the baseline repository
update_baseline ()
{
    (
    set -euf -o pipefail

    local amend=""
    local prev_head=""

    # We discard baseline entries for results worse or same than
    # the current one, but keep entries for results that are better
    # (so that we have a record of pending regressions).
    while no_regression_p; do
	if git -C base-artifacts rev-parse HEAD^ >/dev/null 2>&1; then
	    prev_head=$(git -C base-artifacts rev-parse HEAD)
	    git -C base-artifacts reset --hard HEAD^
	else
	    # We got to the beginning of git history, so amend the current
	    # commit.  The initial state of baseline is "empty" branch,
	    # which we treat as worst possible in no_regression_p().
	    amend="--amend"
	    prev_head=""
	    break
	fi
    done

    # For every regression we want to keep artifacts for the first-bad
    # build, so discard one less than needed.
    if [ x"$prev_head" != x"" ]; then
	git -C base-artifacts reset --hard $prev_head
    fi

    # Rsync current artifacts.
    # !!! From this point on, logs and other artifacts won't be included
    # in base-artifacts.git repo (though they will be uploaded to jenkins).
    rsync -a --del --exclude /.git ${rr[top_artifacts]}/ base-artifacts/

    local build_rev
    build_rev=$(git -C ${rr[current_project]} rev-parse HEAD)

    cd base-artifacts
    git add .
    git commit $amend -m "${rr[current_project]}-$build_rev: $(tail -n1 ${rr[top_artifacts]}/results)

$(cat ${rr[top_artifacts]}/results)"
    )
}

# Push to ${rr[current_project]} baseline branch and to base-artifacts repo.
push_baseline ()
{
    (
    set -euf -o pipefail

    git_init_linaro_local_remote base-artifacts baseline false
    git_push base-artifacts baseline ${rr[baseline_branch]}
    git_push ${rr[current_project]} baseline ${rr[baseline_branch]}
    )
}