init_submodules ()
{
    pushd $1 &> /dev/null
    if [ -d "./.git" ]
    then
        git submodule init
        git submodule update
    fi
    popd &> /dev/null
}

is_not_old_SunOS ()
{
    if expr "`uname -sr`" : 'SunOS 5\.[0-9]$' > /dev/null ; then
	return 1
    else
	return 0
    fi
}

set_var ()
{
    found=0
    i=0
    eval x="\$OVERRIDE_${1}"

    if [ -n "$x" ]
    then
        value=$x
    else
        value=$2
    fi

    if is_not_old_SunOS
    then
        while [ "$i" -lt "${#varkeys[@]}" ]
        do
            if [ "$1" = "${varkeys[$i]}" ]
            then
                varvals[$i]="$value"
                found=1
            fi
            (( i=i+1 ))
        done
        if [ "$found" != 1 ]
        then
            varkeys[$i]="$1"
            varvals[$i]="$value"
        fi
        # Set value in this shell for later comparisons.
        export $1="$value"
    else
        # Set value in this shell for later comparisons.
        eval $1=\"$value\"
        export $1
    fi
}

set_undefined_var ()
{
    eval x="\$${1}"

    if [ -z "$x" ]
    then
        set_var ${1} ${2}
    fi
}

unset_var ()
{
    eval x="\$OVERRIDE_${1}"

    if [ -n "$x" ]
    then
        #There is and override use it and don't unset
        return
    fi

    if is_not_old_SunOS
    then
        i=0
        while [ "$i" -lt "${#varkeys[@]}" ]
        do
            if [ "$1" = "${varkeys[$i]}" ]
            then
                varvals[$i]=""
                varkeys[$i]=""
            fi
            (( i=i+1 ))
        done
    fi
    # unset value in this shell for later comparisons.
    unset $1
}

dump_env_vars ()
{
    if is_not_old_SunOS
    then
        i=0
        while [ "$i" -lt "${#varkeys[@]}" ]
        do
            if [ "${varkeys[$i]}" != "" ]
            then
                echo "${varkeys[$i]}=\"${varvals[$i]}\""
                echo "export ${varkeys[$i]}"
            fi
            (( i=i+1 ))
        done
    fi
}

generateReleaseInfo ()
{
    . $OSPL_HOME/bin/checkconf
    . $OSPL_HOME/release_info/RELEASE_tmpl
    BASE_VERSION=`echo "$PACKAGE_VERSION" | sed 's/\([0-9][0-9]*.[0-9][0-9]*.[0-9][0-9]*\)\(.*\)$/\1/'`
    set_var BASE_VERSION "$BASE_VERSION"
    # We can't base this on git as users aren't necessarily working with a checkout
    # As we only need this to be unique todays date will do.
    if is_not_old_SunOS
    then
        TODAYS_DATE=`perl -e 'print int(time)'`
    else
        TODAYS_DATE=`date +%s`
    fi
    DAYS_EPOCH=`expr $TODAYS_DATE / 86400`
    CURRENT_DATE=`date +%Y-%m-%d`

    #Commercial version is Major.Minor.Patch, just add Days since epoch to it
    CONV_VERSION=${BASE_VERSION}.${DAYS_EPOCH}

    #Opensource format is Major.Minor.DATE, Date is too big so we remove and
    #replace with days since epoch and then a 0 to make up the 4 number group
    if [ "$OSPL_MAINT" -gt "9999" ]
    then
        CONV_VERSION=`echo $BASE_VERSION | cut -d. -f-2`".${DAYS_EPOCH}.0"
    fi
    sed -e "s@#RELEASE_DATE#@${CURRENT_DATE}@g" \
        -e "s/#CS_DLL_VERSION#/${CONV_VERSION}/g" \
        $OSPL_HOME/release_info/RELEASE_tmpl > $OSPL_HOME/release_info/RELEASE
}

print_usage ()
{
    echo "usage: configure [options] [target-type]"
    echo "-? : print this message"
    echo "If no target-type is specified the target-types" \
         "are listed to choose from."
}

source_package_info ()
{
   . "$OSPL_HOME/release_info/RELEASE"
   set_var PACKAGE_VERSION $PACKAGE_VERSION
   set_var PACKAGE_DATE $PACKAGE_DATE
   set_var PACKAGE_NAME $PACKAGE_NAME
   set_var OSPL_MAJOR $OSPL_MAJOR
   set_var OSPL_MINOR $OSPL_MINOR
   set_var OSPL_MAINT $OSPL_MAINT
   set_var OSPL_PATCH $OSPL_PATCH
   set_var CS_DLL_VERSION $CS_DLL_VERSION
   RIGHT_NOW=`date +%T`
   echo
   echo "Setup at ${RIGHT_NOW} for ${PACKAGE_NAME} - Version ${PACKAGE_VERSION} - Date ${PACKAGE_DATE}"
   echo
}

set_home ()
{
   OSPL_HOME=`pwd`
}

reset_old_vars ()
{
   OLD_SPLICE_BIN_PATH="${SPLICE_BIN_PATH}"
   OLD_SPLICE_EXEC_PATH="${SPLICE_EXEC_PATH}"
   OLD_SPLICE_LIBRARY_PATH="${SPLICE_LIBRARY_PATH}"
   OLD_SPLICE_TEST_LIBRARY_PATH="${SPLICE_LIBRARY_TEST_PATH}"

   SPLICE_TARGET=
   if [ "$1" != "KEEP_OSPL_HOME" ]
   then
      OSPL_HOME=
   fi
   SPLICE_ORB=
}

print_setup ()
{
    echo
    echo "Variable Setup"
    echo "SPLICE_TARGET =" $SPLICE_TARGET
    echo "SPLICE_HOST =" $SPLICE_HOST
    echo "OSPL_HOME =" $OSPL_HOME
    echo "SPLICE_ORB =" $SPLICE_ORB
}

display_and_get_target ()
{
    while [ -z "$SPLICE_TARGET_ENV" ]
    do
        echo "Available targets are:"
        n=1
        for i in $SELECTED_TARGETS
        do
            echo $n ">" $i
            n=`expr $n + 1`
        done
        echo -n "Please select a target number:"
        read ARGUMENT
        n=1
        for i in $SELECTED_TARGETS
        do
            if [ "$n" = "$ARGUMENT" ]
            then
                SPLICE_TARGET_ENV=$i
            fi
            n=`expr $n + 1`
        done
        if [ -z "$SPLICE_TARGET_ENV" ]
        then
            echo
            echo "Invalid selection, try again!"
        fi
    done
}

get_avail_targets ()
{
    ENV_DIR="$1/setup/environment"

    TARGETS=`ls "$ENV_DIR"`
    # Remove uninteresting targets
    host=`uname -s`
    for target in $TARGETS
    do
        if [ ! -f "$ENV_DIR/$target" ]
        then
            continue
        fi
        case $host in
        Linux)
            required_host=`grep "SPLICE_HOST=.*linux" "$ENV_DIR/$target"`
            if [ -n "$required_host" ]
            then
                SELECTED_TARGETS="$SELECTED_TARGETS $target"
            fi
        ;;
        SunOS)
            os_version=`uname -r`
            os_number=`echo $os_version | sed 's/.*\.//'`
            required_host=`grep "SPLICE_HOST=.*solaris$os_number" "$ENV_DIR/$target"`
            if [ -n "$required_host" ]
            then
                SELECTED_TARGETS="$SELECTED_TARGETS $target"
            fi
        ;;
        AIX)
            required_host=`grep "SPLICE_HOST=.*AIX" "$ENV_DIR/$target"`
            if [ -n "$required_host" ]
            then
                SELECTED_TARGETS="$SELECTED_TARGETS $target"
            fi
        ;;
        CYGWIN*)
            required_host=`grep "SPLICE_HOST=.*\.win" $ENV_DIR/$target`
            if [ -n "$required_host" ]
            then
                SELECTED_TARGETS="$SELECTED_TARGETS $target"
            fi
        ;;
        Darwin)
            required_host=`expr "$target" : '[^.]*\.darwin10[-_]'`
            if [ "$required_host" -ne 0 ]
            then
                SELECTED_TARGETS="$SELECTED_TARGETS $target"
            fi
        ;;
        *)
            SELECTED_TARGETS="$SELECTED_TARGETS $target"
        ;;
        esac
    done
    set_var SELECTED_TARGETS "$SELECTED_TARGETS"
}

set_target_alternate ()
{
    while [ $# -gt 0 ]
    do
        case $1 in
            -I)
                shift 1
                FIRST_HOME=$1
                shift 1
                ;;
            -O)
                shift 1
                SECOND_HOME=$1
                shift 1
                ;;
            -T)
                shift 1
                TARGET_ARG=$1
                shift 1
                ;;
        esac
    done

    set_var SPLICE_TARGET_ENV $TARGET_ARG
    if [ ! -z "$SPLICE_PLATFORM" ]
    then
        set_var SPLICE_TARGET_ENV $SPLICE_PLATFORM
    fi

    if [ ! -f "$FIRST_HOME/setup/environment/${SPLICE_TARGET_ENV}" -a \
        ! -f "$SECOND_HOME/setup/environment/${SPLICE_TARGET_ENV}" ]
    then
    echo "Specified envionment \"${SPLICE_TARGET_ENV}\" is not supported"
        echo
        return 1
    fi
    return 0
}

setup_pathed_vars ()
{
    SPLICE_BIN_PATH="${OSPL_HOME}/bin"
    case $host in
        CYGWIN_NT*)
            SPLICE_BIN_PATH="${OSPL_HOME}/lib/${SPLICE_HOST}:$SPLICE_BIN_PATH"
            ;;
    esac
    if [ -n "${OLD_SPLICE_BIN_PATH}" ]
    then
        PATH=`echo ${PATH} | \
            sed "s#${OLD_SPLICE_BIN_PATH}:##"`
    fi
    PATH="${SPLICE_BIN_PATH}:${PATH}"
    set_var SPLICE_BIN_PATH "$SPLICE_BIN_PATH"

    SPLICE_EXEC_PATH="${OSPL_HOME}/exec/${SPLICE_TARGET}"
    if [ -n "${OLD_SPLICE_EXEC_PATH}" ]
    then
        PATH=`echo ${PATH} | \
            sed "s#${OLD_SPLICE_EXEC_PATH}:##"`
    fi
    #PATH="${SPLICE_EXEC_PATH}:${PATH}"
    set_var SPLICE_EXEC_PATH "$SPLICE_EXEC_PATH"

    SPLICE_LIBRARY_PATH="${OSPL_HOME}/lib/${SPLICE_TARGET}"
    if [ -n "${OLD_SPLICE_LIBRARY_PATH}" ]
    then
        LD_LIBRARY_PATH=`echo ${LD_LIBRARY_PATH} | \
            sed "s#${OLD_SPLICE_LIBRARY_PATH}:##"`
    fi
    LD_LIBRARY_PATH="${SPLICE_LIBRARY_PATH}:${LD_LIBRARY_PATH}"
    set_var SPLICE_LIBRARY_PATH "$SPLICE_LIBRARY_PATH"
    case $host in
        CYGWIN_NT*)
        PATH="${SPLICE_LIBRARY_PATH}:${PATH}"
            ;;
    esac

    if [ -n "$OSPL_OUTER_HOME" ]
    then
        SPLICE_LIBRARY_TEST_PATH="${OSPL_OUTER_HOME}/testsuite/lib/${SPLICE_TARGET}"
        if [ -n "${OLD_SPLICE_LIBRARY_TEST_PATH}" ]
        then
            LD_LIBRARY_PATH=`echo ${LD_LIBRARY_PATH} | \
                sed "s#${OLD_SPLICE_LIBRARY_TEST_PATH}:##"`
        fi
        LD_LIBRARY_PATH="${SPLICE_LIBRARY_TEST_PATH}:${LD_LIBRARY_PATH}"
        set_var SPLICE_LIBRARY_TEST_PATH "$SPLICE_LIBRARY_TEST_PATH"
        case $host in
            CYGWIN_NT*)
            PATH="${SPLICE_LIBRARY_TEST_PATH}:${PATH}"
                ;;
        esac
    fi

    if [ "_${SPLICE_HOST}" != "_${SPLICE_TARGET}" ]
    then
        if [ -n "${OLD_SPLICE_HOST}" ]
        then
            LD_LIBRARY_PATH=`echo ${LD_LIBRARY_PATH} | \
                sed "s#${OSPL_HOME}/lib/${OLD_SPLICE_HOST}:##"`
            PATH=`echo ${PATH} | \
                sed "s#${OSPL_HOME}/exec/${OLD_SPLICE_HOST}:##"`
        fi
    fi

    LD_LIBRARY_PATH="${OSPL_HOME}/lib/${SPLICE_HOST}:${LD_LIBRARY_PATH}"
    PATH="${OSPL_HOME}/exec/${SPLICE_HOST}:${PATH}"

    set_var PATH "$PATH"

    case $host in
        Darwin*)
            set_var DYLD_FALLBACK_LIBRARY_PATH "$LD_LIBRARY_PATH${DYLD_FALLBACK_LIBRARY_PATH:+:}$DYLD_FALLBACK_LIBRARY_PATH"
        unset_var LD_LIBRARY_PATH
        export DYLD_LIBRARY_PATH
        ;;
    *)
        set_var LD_LIBRARY_PATH "$LD_LIBRARY_PATH"
        export LD_LIBRARY_PATH
        ;;
    esac
}

export_vars ()
{
    host=`uname -s`
    OSPL_TMPL_PATH="${OSPL_HOME}/etc/idlpp"
    case $host in
        CYGWIN_NT*)
            CYGWIN_INSTALL_DRIVE=`(df -k . | grep ":" | awk -F ':' '{ print $1 }')`
            OSPL_TMPL_PATH=`cygpath -d $OSPL_HOME/etc/idlpp`
            OSPL_TEMP=`cygpath -w $OSPL_HOME/etc/tmp`
               mkdir -p $OSPL_TEMP
                set_var OSPL_TEMP "$OSPL_TEMP"
            ;;
    esac
    set_var CYGWIN_INSTALL_DRIVE "$CYGWIN_INSTALL_DRIVE"
    set_var OSPL_HOME "$OSPL_HOME"
    set_var MPC_ROOT "$OSPL_HOME/submods/MPC_ROOT"
    OSPL_HOME_NORMALIZED=`"$OSPL_HOME/bin/ospl_normalizePath" "$OSPL_HOME"`
    set_var OSPL_HOME_NORMALIZED "$OSPL_HOME_NORMALIZED"
    set_var SPLICE_TARGET "$SPLICE_TARGET"
    set_var SPLICE_REAL_TARGET "$SPLICE_TARGET"
    set_var OSPL_TMPL_PATH "$OSPL_TMPL_PATH"
    if [ -n "${PROTOBUF_HOME}" ]
    then
        PROTOBUF_HOME_NORMALIZED=`"$OSPL_HOME/bin/ospl_normalizePath" "$PROTOBUF_HOME"`
        set_var PROTOBUF_HOME_NORMALIZED "$PROTOBUF_HOME_NORMALIZED"
    fi
}

cleanup ()
{
    unset ARGUMENT
    unset TARGETS
    unset target
    unset i
    unset n
    unset_var OLD_SPLICE_BIN_PATH
    unset_var OLD_SPLICE_EXEC_PATH
    unset_var OLD_SPLICE_LIBRARY_PATH
    unset SELECTED_TARGETS
    unset ENV_DIR

    unset print_usage
    unset reset_old_vars
    unset set_home
    unset source_package_info
    unset get_avail_targets
    unset display_and_get_target
    unset set_target_alternate
    unset export_vars
    unset cleanup
    unset varkeys
    unset varvals
    unset generateReleaseInfo
    unset init_submodules
    unset setup_pathed_vars
}

# Sets the values OSPL_HOST_HEADERS and OSPL_TARGET_HEADERS
# that can be used to correctly include/compile the appropriate
# OS abstraction source
get_abstraction_header_dirs ()
{
    pushd $OSPL_HOME > /dev/null
    set_var SPLICE_HOST $SPLICE_HOST
    # Temporarily set SPLICE_TARGET to be SPLICE_HOST ...
    SPLICE_REAL_TARGET=$SPLICE_TARGET
    set_var SPLICE_TARGET $SPLICE_HOST
    # ... to read the OS abstration headers for the host 'target'
    set_var OSPL_HOST_HEADERS `make --no-print-directory get_target_os_header_dir`
    # ... then set SPLICE_TARGET correctly & repeat
    set_var SPLICE_TARGET $SPLICE_REAL_TARGET
    set_var OSPL_TARGET_HEADERS `make --no-print-directory get_target_os_header_dir`
    popd > /dev/null
}
