#!/usr/bin/env bash

# This script takes a compressed artifact of a
# vagrant install directory, unpacks it, and
# creates an installer rpm

csource="${BASH_SOURCE[0]}"
while [ -h "$csource" ] ; do csource="$(readlink "$csource")"; done
root="$( cd -P "$( dirname "$csource" )/../" && pwd )"

. "${root}/package/common-setup"

installer_file="${1?Vagrant installed zip file required}"
vagrant_go="${2?Vagrant go binary file required}"
output_dir="${3?Package output directory required}"
version="${4?Vagrant version is required}"
release="${5}"

# Release isn't really supported now but in case it
# ever is we allow it to be set
if [ -z "${release}" ]; then
    release="1"
fi

if [ ! -f "${installer_file}" ]; then
    error "Installer path is not a valid file (%s)" "${installer_file}"
fi

if [ ! -f "${vagrant_go}" ]; then
    error "Vagrant go path is not a valid file (%s)" "${vagrant_go}"
fi

# Determine architecture based on file name
if [[ "${installer_file}" = *"386"* ]]; then
    arch="i686"
elif [[ "${installer_file}" = *"x86_64"* ]]; then
    arch="x86_64"
else
    fail "Cannot determine architecture from installer path (%s)" \
        "${installer_file}"
fi

# Get full paths
installer_file="$(file_directory "${installer_file}")/${installer_file##*/}"
vagrant_go="$(file_directory "${vagrant_go}")/${vagrant_go##*/}"
mkdir -p "${output_dir}" || exit
pushd "${output_dir}" > /dev/null || exit
output_dir="$(pwd)" || exit
popd > /dev/null || exit

# Create our output file path
output_path="${output_dir}/vagrant-${version}-${release}.${arch}.rpm"

# Create a working directory and expand the artifact
install_dir="$(mktemp -d vagrant-install.XXXXXX)" || exit
pushd "${install_dir}" > /dev/null || exit
install_dir="$(pwd)" || exit

info "Expanding vagrant installation..."
unzip -q "${installer_file}" || exit
popd > /dev/null || exit

# Create a packaging directory
package_dir="$(mktemp -d vagrant-package.XXXXXX)" || exit
pushd "${package_dir}" > /dev/null || exit
package_dir="$(pwd)" || exit
popd > /dev/null || exit

info "Building package directory structure..."

# Create some initial directory structure
mkdir -p "${package_dir}/usr/bin" || exit
mkdir -p "${package_dir}/opt/vagrant" || exit

# Add content to the package
mv "${install_dir}/bin" "${package_dir}/opt/vagrant" || exit
mv "${install_dir}/embedded" "${package_dir}/opt/vagrant" || exit

# Include the vagrant-go binary
cp "${vagrant_go}" "${package_dir}/opt/vagrant/bin/vagrant-go" || exit
chmod a+x "${package_dir}/opt/vagrant/bin/vagrant-go" || exit

# Add helper scripts
cp "${root}/package/support/rpm/vagrant" "${package_dir}/usr/bin" || exit
cp "${root}/package/support/rpm/vagrant-go" "${package_dir}/usr/bin" || exit

info "Building package..."

fpm -p "${output_path}" \
    -n vagrant \
    -v "${version}" \
    -s dir \
    -t rpm \
    --prefix '/' \
    --architecture "${arch}" \
    --rpm-auto-add-directories \
    --rpm-digest sha256 \
    --license "MIT" \
    --description "Vagrant is a tool for building and distributing development environments." \
    --vendor "HashiCorp" \
    --maintainer "HashiCorp <support@hashicorp.com>" \
    --url "https://www.vagrantup.com" \
    --epoch 0 \
    --iteration "${release}" \
    -C "${package_dir}" \
    . || exit

# Clean up our working directories
rm -rf "${install_dir}"
rm -rf "${package_dir}"
