#!/usr/bin/env bash

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

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
# NOTE: Debian/Ubuntu use their own names for package architectures that
#       are different from what shows up in `uname -m`.
#         i686 -> i386
#         x86_64 -> amd64
#         aarch64 -> arm64
#       We have to to honor that convention in fpm for packages to install
#       properly, and it makes sense to also match it in filenames too.
if [[ "${installer_file}" = *"386"* ]]; then
    arch="i686"
    fpm_arch="i386"
elif [[ "${installer_file}" = *"x86_64"* ]]; then
    arch="amd64"
    fpm_arch="amd64"
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}.deb"

# 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/deb/vagrant" "${package_dir}/usr/bin" || exit
cp "${root}/package/support/deb/vagrant-go" "${package_dir}/usr/bin" || exit

info "Building package..."

fpm -p "${output_path}" \
    -n vagrant \
    -v "${version}" \
    -s dir \
    -t deb \
    --prefix '/' \
    --architecture "${fpm_arch}" \
    --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" \
    --iteration "${release}" \
    --deb-user root \
    --deb-group root \
    -C "${package_dir}" \
    . || exit

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