# Copyright 2015 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Common routines - do not execute directly.

# Sanitize environment
set -e
export LANG=C
export LC_ALL=C

if [ -z "$_SHU_PROGDIR" ]; then
    _SHU_PROGDIR=$(dirname "$0")
elif [ ! -f "$_SHU_PROGDIR"/common.shi ]; then
    echo "ERROR: Invalid _SHU_PROGDIR value (missing common.shi): $_SHU_PROGDIR"
fi

_SHU_PROGNAME=$(basename "$0")

# Print an error message to stderr then exit the current process.
panic () {
    echo "ERROR: $@" >&2
    exit 1
}

# Internal verbosity level. Note that this value is inherited from
# the VERBOSE environment variable.
_SHU_VERBOSE=${VERBOSE:-1}

# Increment internal verbosity level.
increment_verbosity () {
    _SHU_VERBOSE=$(( $_SHU_VERBOSE + 1 ))
}

# Decrement internal verbosity level.
decrement_verbosity () {
    _SHU_VERBOSE=$(( $_SHU_VERBOSE - 1 ))
}

# Set the verbosity to a given level.
set_verbosity () {
    _SHU_VERBOSE=$1
}

# Return internal verbosity level, clamped to 0 as a minimum bound.
get_verbosity () {
    local RET=$_SHU_VERBOSE
    if [ "$RET" -lt 0 ]; then
        RET=0
    fi
    echo "$RET"
}

# Used internally to conditionally print a message.
# $1: message's verbosity level. If greater or equal than $_SHU_VERBOSE then
#     the message will be ignored.
# $2+: message to print to stdout.
dump_n () {
    local LEVEL=$1
    shift
    if [ "$LEVEL" -lt "$_SHU_VERBOSE" ]; then
        printf "%s\n" "$@"
    fi
}

# Dump a message to standard output.
dump () {
    dump_n 0 "$@"
}

# Dump a message to standard output if --verbose was used.
log () {
    dump_n 1 "$@"
}

# Dump a message to standard output if --verbose --verbose is used.
log2 () {
    dump_n 2 "$@"
}

# Run a command, but suppress stdout
# keep stderr open in case error
silent_run () {
    "$@" >/dev/null
}

# Run a command, output depends on verbosity level
run () {
    local VERBOSE=$_SHU_VERBOSE
    if [ "$VERBOSE" -lt 0 ]; then
        VERBOSE=0
    fi
    if [ "$VERBOSE" -gt 1 ]; then
        echo "COMMAND: $@"
    fi
    case $VERBOSE in
        0|1)
             "$@" >/dev/null 2>&1
             ;;
        2)
            "$@" >/dev/null
            ;;
        *)
            "$@"
            ;;
    esac
}

# Return the current script's directory.
program_directory () {
    printf "%s" "$_SHU_PROGDIR"
}

# Return the current script's filename.
program_name () {
    printf "%s" "$_SHU_PROGNAME"
}

# Return the value of a given named variable.
# $1: variable name
#
# example:
#    FOO=BAR
#    BAR=ZOO
#    echo `var_value $FOO`
#    will print 'ZOO'
#
var_value () {
    eval printf %s \"\$$1\"
}

# Return success if variable $1 is set and non-empty, failure otherwise.
# $1: Variable name.
# Usage example:
#   if var_is_set FOO; then
#      .. Do something the handle FOO condition.
#   fi
var_is_set () {
    test -n "$(var_value $1)"
}

_var_quote_value () {
    printf %s "$1" | sed -e "s|'|\\'\"'\"\\'|g"
}

# Set the value of a given name variables.
# $1: Variable name.
# $2+: Variable value.
# example:
#    FOO=BAR
#    var_assign $FOO bar
# is equivalent to
#    BAR=bar
var_assign () {
    local _var_assign_varname _var_assign_value
    _var_assign_varname=$1
    shift
    _var_assign_value=$(_var_quote_value "$*")
    eval $_var_assign_varname=\'$_var_assign_value\'
}

# Append a space-separated list of items to a given variable.
# $1: Variable name.
# $2+: Variable value.
# Example:
#   FOO=
#   var_append FOO foo    (FOO is now 'foo')
#   var_append FOO bar    (FOO is now 'foo bar')
#   var_append FOO zoo    (FOO is now 'foo bar zoo')
var_append () {
    local _var_append_varname
    _var_append_varname=$1
    shift
    if test "$(var_value $_var_append_varname)"; then
        eval $_var_append_varname=\$$_var_append_varname\'\ $(_var_quote_value "$*")\'
    else
        eval $_var_append_varname=\'$(_var_quote_value "$*")\'
    fi
}

# Import shell script $1. Similar to sourcing the script except
# that each script will only be sourced once, even with multiple
# dependencies.
shell_import () {
    local SCRIPT="$_SHU_PROGDIR/$1"
    if [ ! -f "$SCRIPT" ]; then
        panic "Missing script: $SCRIPT"
    fi
    local SCRIPT_TAG=_SHU_SHELL_SCRIPT_TAG__${1%%.shi}
    SCRIPT_TAG=$(echo "$SCRIPT_TAG" | tr '-' '_' | tr '/' '__')
	case $(var_value $SCRIPT_TAG) in
        imported)
            # Script is already imported.
            return 0
            ;;
        importing)
            # Script is already being imported, this is
            # a circular dependency.
            panic "Circular dependency when trying to import $1"
            ;;
        *)
            # Import the script.
            var_assign $SCRIPT_TAG importing
            . "$SCRIPT"
            var_assign $SCRIPT_TAG imported
            ;;
    esac
}

# Unpack a given archive into a given destination directory.
# $1: Archive path
# $2: Destination directory
unpack_archive () {
    local PKG_PATH="$1"
    local DEST_DIR="$2"
    case $PKG_PATH in
        *.tar.gz|*.tar.bz2|*.tar.xz)
            silent_run tar xf "$PKG_PATH" -C "$DEST_DIR"
            ;;
        *.zip)
            silent_run unzip -q -o -d "$DEST_DIR" "$PKG_PATH"
            ;;
        *)
            panic "Unsupported package format: $PKG_PATH"
            ;;
    esac
}

# Return the build machine's operating system tag.
# Valid return values are:
#    linux
#    darwin
#    freebsd
#    windows   (really MSys)
#    cygwin
get_build_os () {
    if [ -z "$_SHU_BUILD_OS" ]; then
        _SHU_BUILD_OS=$(uname -s)
        case $_SHU_BUILD_OS in
            Darwin)
                _SHU_BUILD_OS=darwin
                ;;
            FreeBSD)  # note: this is not tested
                _SHU_BUILD_OS=freebsd
                ;;
            Linux)
                # note that building  32-bit binaries on x86_64 is handled later
                _SHU_BUILD_OS=linux
                ;;
            CYGWIN*|*_NT-*)
                _SHU_BUILD_OS=windows
                if [ "x$OSTYPE" = xcygwin ] ; then
                    _SHU_BUILD_OS=cygwin
                fi
                ;;
        esac
    fi
    echo "$_SHU_BUILD_OS"
}

# Return the build machine's CPU architecture.
# Valid return values are:
#     x86
#     x86_64
get_build_arch () {
    local TEST
    if [ -z "$_SHU_BUILD_ARCH" ]; then
        case $(get_build_os) in
            linux|darwin)
                _SHU_BUILD_ARCH=$(uname -m)
                # Kernel bitness might not match user space, so test
                # the bitness of our shell to know what the user is
                # really running.
                TEST=$(/usr/bin/file -L $SHELL 2>/dev/null | grep 'x86[_-]64')
                if [ "$TEST" ]; then
                    _SHU_BUILD_ARCH=x86_64
                fi
                ;;
            windows|cygwin)
                case $PROCESSOR_ARCHITECTURE in
                    ADM64)
                        _SHU_BUILD_ARCH=x86_64
                        ;;
                    *)
                        _SHU_BUILD_ARCH=x86
                        ;;
                esac
                ;;
            *)
                _SHU_BUILD_ARCH=$(uname -p)
                ;;
        esac
    fi
    echo "$_SHU_BUILD_ARCH"
}

# Return the executable extension for a given operating system tag.
# $1: operating system tag.
_shu_get_exe_extension_for () {
    case $1 in
        windows|cygwin)
            echo ".exe"
            ;;
        *)
            echo ""
    esac
}

# Return the dynamic library extension for a given operating system tag.
# $1: operating system tag.
_shu_get_dll_extension_for () {
    case $1 in
        darwin)
            echo ".dylib"
            ;;
        windows|cygwin)
            echo ".dll"
            ;;
        *)
            echo ".so"
            ;;
    esac
}

# Return the extension of executables on the build machine.
get_build_exe_extension () {
    if [ -z "$_SHU_BUILD_EXE_EXTENSION_DEFINED" ]; then
        _SHU_BUILD_EXE_EXTENSION=$(_shu_get_exe_extension_for $(get_build_os))
        _SHU_BUILD_EXE_EXTENSION_DEFINED=true
    fi
    echo "$_SHU_BUILD_EXE_EXTENSION"
}

# Return the extension of dynamic libraries on the build machine.
get_build_dll_extension () {
    if [ -z "$_SHU_BUILD_DLL_EXTENSION_DEFINED" ]; then
        _SHU_BUILD_DLL_EXTENSION=$(_shu_get_dll_extension_for $(get_build_os))
        _SHU_BUILD_DLL_EXTENSION_DEFINED=true
    fi
    echo "$_SHU_BUILD_DLL_EXTENSION"
}

# Return the number of CPU cores on the build machine.
get_build_num_cores () {
    case $(get_build_os) in
        linux)
            grep -c -e processor /proc/cpuinfo 2>/dev/null || echo 1
            ;;
        darwin|freebsd)
            sysctl -n hw.ncpu 2>/dev/null || echo 1
            ;;
        windows|cygwin)
            echo "${NUMBER_OF_PROCESSORS:-1}"
            ;;
        *)
            echo "1"
            ;;
    esac
}

# Convert commas into spaces.
# $1: input string
# Out: input string, with each comma replaced by a space.
commas_to_spaces () {
    printf "%s" "$@" | tr ',' ' '
}

# Convert spaces into commas
# $1+: input string
# Out: input string, with contiguous spaces replaced by a comma.
# NOTE: This also strips leading/trailing space.
spaces_to_commas () {
    local ITEM RET
    for ITEM in $*; do
        if [ -z "$RET" ]; then
            RET=$ITEM
        else
            RET="$RET,$ITEM"
        fi
    done
    printf "%s" "$RET"
}

# Return success iff item |$2| is in list |$1|.
# $1: input list
# $2: item to find in list.
list_contains () {
    local ITEM
    for ITEM in $(commas_to_spaces "$1"); do
        if [ "$ITEM" = "$2" ]; then
            return 0
        fi
    done
    return 1
}

# Copy a directory, create target location if needed
#
# $1: source directory
# $2: target directory location
#
copy_directory ()
{
    local SRCDIR="$1"
    local DSTDIR="$2"
    if [ ! -d "$SRCDIR" ] ; then
        panic "Can't copy from non-directory: $SRCDIR"
    fi
    log "Copying directory: from [$SRCDIR] to [$DSTDIR]"
    mkdir -p "$DSTDIR" && (cd "$SRCDIR" && 2>/dev/null tar cf - *) | (tar xf - -C "$DSTDIR") ||
            panic "Cannot copy to directory: $DSTDIR"
}

# $1: source directory
# $2: target directory location
# $3+: list of file names and filters.
copy_directory_files ()
{
    local SRCDIR="$1"
    local DSTDIR="$2"
    shift
    shift
    if [ ! -d "$SRCDIR" ] ; then
        panic "Can't copy from non-directory: $SRCDIR"
    fi
    log "Copying directory: from [$SRCDIR] to [$DSTDIR]"
    mkdir -p "$DSTDIR" || panic "Cannot create target directory: $DSTDIR"
    (cd "$SRCDIR" && 2>/dev/null tar cf - "$@" | \
            tar xf - -C "$DSTDIR") ||
        panic "Cannot copy to directory: $DSTDIR"
}

# Compute the SHA-1 sum of a given file. Implementation depends on the
# current host machine.
# $1: File path
# Out: SHA-1 sum as an hexadecimal string.
compute_file_sha1 () {
    case $(get_build_os) in
        linux)
            (sha1sum "$1" | awk '{ print $1; }') 2>/dev/null
            ;;
        darwin)
            (openssl sha1 "$1" | awk '{ print $2; }') 2>/dev/null
            ;;
        *)
            panic "Don't know how to compute a SHA-1 sum on this platform: \
$(get_build_os)"
    esac
}

# Compute the SHA-1 sum of a given zip or tarball archive. This is done by
# generated a sorted list of all files from the archive, and their SHA-1, then
# computing the SHA-1 of the result. This means the output is only dependent
# on the archive's content, not on any user/group/mtime field present in the
# actual archive file. Required because the Darwin 'tar' command doesn't seem
# to be able to generate reproducible archives (and even if it could, they
# would probably be slightly different from the ones generated on Linux).
# $1: Archive file path
# Out: SHA-1 sum as an hexadecimal string.
compute_archive_sha1 () {
    local LIST_FILE LIST_DIR RET
    LIST_DIR=$(mktemp -d /tmp/sha1_archive.XXXXXX)
    LIST_FILE=$(mktemp /tmp/sha1_list.XXXXXX)
    unpack_archive "$1" "$LIST_DIR"
    RET=0
    (
        unpack_archive "$1" "$LIST_DIR" &&
        cd "$LIST_DIR" &&
        LANG=C LC_ALL=C find . -type f -o -type l | sort -u -s | xargs openssl sha1 > "$LIST_FILE"
        compute_file_sha1 "$LIST_FILE"
    ) || RET=$?
    rm -rf "$LIST_DIR"
    rm -rf "$LIST_FILE"
    return $RET
}

# Return the file path of a given timestamp
# $1: Installation directory
# $2: Timestamp group name
_shu_timestamp_file () {
    printf %s "$1/timestamps/$2"
}

timestamp_check () {
    test -f "$(_shu_timestamp_file "$1" "$2")"
}

timestamp_set () {
    local TIMESTAMP="$(_shu_timestamp_file "$1" "$2")"
    run mkdir -p "$(dirname $TIMESTAMP)" && run touch "$TIMESTAMP"
}

timestamp_clear () {
    run rm -f "$(_shu_timestamp_file "$1" "$2")"
}

# Find a given program in the current path. This function never fails.
# $1: Program name
# Out: program path, if found, or empty string otherwise.
find_program () {
    which "$1" 2>/dev/null || true
}


# Return the dump_syms tool path for a given host system.
# $1: System name (e.g. 'linux-x86' or 'linux-x86_64')
aosp_prebuilt_breakpad_dump_syms_for () {
    local SYMTOOL="dump_syms"
    local HOST="$1"
    if [ "$(get_build_os)" = "linux" ]; then
        case ${HOST} in
            *windows*)
            SYMTOOL=${SYMTOOL}_dwarf
            HOST=$(get_build_os)-$(get_build_arch)
            ;;
        esac
    fi
    local SYMTOOL_PATH="$AOSP_DIR/$(aosp_prebuilt_breakpad_subdir_for $HOST)/bin/${SYMTOOL}"
    if [ ! -f "${SYMTOOL_PATH}" ]; then
        panic "Breakpad prebuilt ${SYMTOOL} could not be found at ${SYMTOOL_PATH}"
    fi
    printf %s "${SYMTOOL_PATH}"
}

# Build debug_info from unstripped binaries
# Platform specific. On mac, generates the dSYMs alongside the libraries
#
# $1: Src root directory
# $2: Target root directory
# $3+: List of binary paths relative to Src root
build_debug_info () {
    local SRC_ROOT="$1"
    local DEST_ROOT="$2"
    shift
    shift
    local BINARY_FILES="$@"
    for BINARY in $BINARY_FILES; do
        if [ "$(get_build_os)" = "darwin" ]; then
            DSYM_DIR=$DEST_ROOT/$BINARY.dSYM
            if [ -L "$SRC_ROOT"/$BINARY ]; then
                DEST=`readlink $SRC_ROOT/$BINARY`
                ln -fs $DEST.dSYM $DSYM_DIR
            else
                dsymutil --out=$DSYM_DIR $SRC_ROOT/$BINARY ||
                panic "Failed to create dsym for $SRC_ROOT/$BINARY"
            fi
        fi
    done
}

# Build breakpad symbols from unstripped binaries
# Builds a symbols directory at the destination root dir and populates it with
# *.sym extension symbol files mirroring the binary file paths
#
# Expects Breakpad prebuilt to be built, panics otherwise.
# $1: Src root directory
# $2: Target root directory
# $3: Host target
# $4+: List of binary paths relative to Src root
build_symbols () {
    local SRC_ROOT="$1"
    local DEST_ROOT="$2"
    local HOST="$3"
    shift
    shift
    shift
    local BINARY_FILES="$@"
    local SYMBOL_DIR="$DEST_ROOT"/symbols
    local BINARY_FULLNAME=
    local BINARY_DIR=
    local SYMTOOL="$(aosp_prebuilt_breakpad_dump_syms_for $HOST)"
    if [ ! -f "$SYMTOOL" ]; then
        panic "Breakpad prebuilt symbol dumper could not be found at $SYMTOOL"
    fi
    run mkdir -p "$SYMBOL_DIR"
    for BINARY in $BINARY_FILES; do
        if [ -L "$SRC_ROOT"/$BINARY ]; then
            continue
        fi
        BINARY_FULLNAME="$(basename "$BINARY")"
        BINARY_DIR="$(dirname "$BINARY")"
        run mkdir -p $SYMBOL_DIR/$BINARY_DIR
        if [ "$(get_build_os)" = "darwin" ]; then
            DSYM_DIR=$(mktemp -d /tmp/$BINARY_FULLNAME.dsym.XXXXXX)
            dsymutil --out=$DSYM_DIR $SRC_ROOT/$BINARY ||
                panic "Failed to create dsym for $SRC_ROOT/$BINARY"
            $SYMTOOL -g $DSYM_DIR $SRC_ROOT/$BINARY > $SYMBOL_DIR/$BINARY.sym ||
                panic "Failed to create symbol file for $SRC_ROOT/$BINARY"
            rm -rf "$DSYM_DIR"
        else
            $SYMTOOL $SRC_ROOT/$BINARY > $SYMBOL_DIR/$BINARY.sym ||
                panic "Failed to create symbol file for $SRC_ROOT/$BINARY"
        fi
    done
}

# Strips a library in place
# Expects TOOLCHAIN_WRAPPER_DIR to be valid (set by builder_prepare_for_host*)
# Panics if not found
# $1: Target root directory
# $2+: List of lib paths relative to $1
strip_libs () {
    local DEST_ROOT="$1"
    shift
    local LIBS="$@"
    if [ -z $TOOLCHAIN_WRAPPER_DIR ]; then
        panic "TOOLCHAIN_WRAPPER_DIR not set, was builder_prepare_for_host called?"
    fi
    if [ ! -d $TOOLCHAIN_WRAPPER_DIR ]; then
        panic "TOOLCHAIN_WRAPPER_DIR is not a directory"
    fi
    for LIB in $LIBS; do
        if [ "$(get_build_os)" = "darwin" ]; then
            run strip -S $DEST_ROOT/$LIB || panic "Could not strip $DEST_ROOT"
        else
            local OBJCOPY="$TOOLCHAIN_WRAPPER_DIR"/$(builder_gnu_config_host_prefix)objcopy
            if [ ! -f "$OBJCOPY" ]; then
                panic "Could not find objcopy at $OBJCOPY"
            fi
            run "$OBJCOPY" --strip-unneeded $DEST_ROOT/$LIB || \
                panic "Could not strip $DEST_ROOT/$LIB"
        fi
    done
}