#!/usr/bin/env bash
#
# Summary: Create a Python virtualenv using the pyenv-virtualenv plugin
#
# Usage: pyenv virtualenv [-f|--force] [-u|--upgrade] [VIRTUALENV_OPTIONS] <version> <virtualenv-name>
#        pyenv virtualenv --version
#        pyenv virtualenv --help
#
#   -u/--upgrade     Upgrade existing virtualenv to use new version of Python,
#                    assuming Python has been upgraded in-place.
#   -f/--force       Install even if the version appears to be installed already
#

PYENV_VIRTUALENV_VERSION="20130614"

set -e
[ -n "$PYENV_DEBUG" ] && set -x

# Provide pyenv completions
if [ "$1" = "--complete" ]; then
  exec pyenv-versions --bare
fi

if [ -z "$PYENV_ROOT" ]; then
  PYENV_ROOT="${HOME}/.pyenv"
fi

# Define library functions
parse_options() {
  OPTIONS=()
  ARGUMENTS=()
  local arg option index

  for arg in "$@"; do
    if [ "${arg:0:1}" = "-" ]; then
      if [ "${arg:1:1}" = "-" ]; then
        OPTIONS[${#OPTIONS[*]}]="${arg:2}"
      else
        index=1
        while option="${arg:$index:1}"; do
          [ -n "$option" ] || break
          OPTIONS[${#OPTIONS[*]}]="$option"
          index=$(($index+1))
        done
      fi
    else
      ARGUMENTS[${#ARGUMENTS[*]}]="$arg"
    fi
  done
}

resolve_link() {
  $(type -p greadlink readlink | head -1) "$1"
}

abs_dirname() {
  local cwd="$(pwd)"
  local path="$1"

  while [ -n "$path" ]; do
    cd "${path%/*}"
    local name="${path##*/}"
    path="$(resolve_link "$name" || true)"
  done

  pwd
  cd "$cwd"
}

http() {
  local method="$1"
  local url="$2"
  local file="$3"
  [ -n "$url" ] || return 1

  if type curl &>/dev/null; then
    "http_${method}_curl" "$url" "$file"
  elif type wget &>/dev/null; then
    "http_${method}_wget" "$url" "$file"
  else
    echo "error: please install \`curl\` or \`wget\` and try again" >&2
    exit 1
  fi
}

http_head_curl() {
  curl -qsILf "$1" >&4 2>&1
}

http_get_curl() {
  curl -C - -o "${2:--}" -qsSLf "$1"
}

http_head_wget() {
  wget -q --spider "$1" >&4 2>&1
}

http_get_wget() {
  wget -nv -c -O "${2:--}" "$1"
}

version() {
  local version="$(virtualenv --version 2>/dev/null || true)"
  echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (virtualenv ${version:-unknown})"
}

usage() {
  # We can remove the sed fallback once pyenv 0.2.0 is widely available.
  pyenv-help virtualenv 2>/dev/null || sed -ne '/^#/!q;s/.//;s/.//;1,4d;p' < "$0"
  virtualenv --help 2>/dev/null || true
  [ -z "$1" ] || exit "$1"
}

virtualenv_is_pyvenv() {
  # Use pyvenv only if virtualenv is not installed and there is pyvenv
  if pyenv-which "virtualenv" 1>/dev/null 2>&1; then
    return 1
  else
    pyenv-which "pyvenv" 1>/dev/null 2>&1
  fi
}

virtualenv() {
  if virtualenv_is_pyvenv; then
    pyenv-exec pyvenv "$@"
  else
    pyenv-exec virtualenv "$@"
  fi
}

PYENV_VIRTUALENV_ROOT="$(abs_dirname "$0")/.."
if [ -z "${PYENV_VIRTUALENV_CACHE_PATH}" ]; then
  PYENV_VIRTUALENV_CACHE_PATH="${PYTHON_BUILD_CACHE_PATH:-${PYENV_ROOT}/cache}"
fi
VIRTUALENV_OPTIONS=()

unset FORCE
unset QUIET
unset UPGRADE
unset VERBOSE

parse_options "$@"
for option in "${OPTIONS[@]}"; do
  case "$option" in
  "f" | "force" )
    FORCE=true
    ;;
  "h" | "help" )
    usage 0
    ;;
  "q" | "quiet" )
    QUIET="--quiet"
    ;;
  "u" | "upgrade" )
    UPGRADE=true
    ;;
  "v" | "verbose" )
    VERBOSE="--verbose"
    ;;
  "version" )
    version
    exit 0
    ;;
  * ) # virtualenv long options
    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
    ;;
  esac
done

if [[ "${#ARGUMENTS[@]}" == 0 ]]; then
  echo "pyenv: no virtualenv name given." 1>&2
  exit 1
elif [[ "${#ARGUMENTS[@]}" == 1 ]]; then
  # If only one argument given, use current version as source version
  VERSION_NAME="$(pyenv-version-name)"
  VIRTUALENV_NAME="${ARGUMENTS[0]}"
else
  # Otherwise, use former as source version, and latter as virtualenv version
  VERSION_NAME="${ARGUMENTS[0]}"
  VIRTUALENV_NAME="${ARGUMENTS[1]##*/}"
fi

if [ -z "${VERSION_NAME}" ] || [ -z "${VIRTUALENV_NAME}" ]; then
  usage 1
fi

# Set VERSION_NAME as default version in this script
export PYENV_VERSION="${VERSION_NAME}"

# Source version must exists before creating virtualenv
pyenv-prefix 1>/dev/null 2>&1 || usage 1

if [ -z "$TMPDIR" ]; then
  TMP="/tmp"
else
  TMP="${TMPDIR%/}"
fi

SEED="$(date "+%Y%m%d%H%M%S").$$"
UPGRADE_PATH="${TMP}/pyenv-virtualenv.${SEED}"
UPGRADE_LIST="${TMP}/pyenv-virtualenv.${SEED}.txt"

VIRTUALENV_PATH="${PYENV_ROOT}/versions/${VIRTUALENV_NAME}"

if virtualenv_is_pyvenv; then
  # Unset some arguments not supported by pyvenv
  unset QUIET
  unset VERBOSE
  if [ -n "$UPGRADE" ]; then
    unset UPGRADE
    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--upgrade"
  fi
else
  pyenv-which "virtualenv" 1>/dev/null 2>&1 || {
    VIRTUALENV_VERSION="==${VIRTUALENV_VERSION}"
    pyenv-exec pip install $QUIET $VERBOSE "virtualenv${VIRTUALENV_VERSION%==}"
    pyenv-rehash
  }
fi

# Unset environment variables which starts with `VIRTUALENV_`.
# These variables are reserved for virtualenv.
unset VIRTUALENV_VERSION


# Define `before_virtualenv` and `after_virtualenv` functions that allow
# plugin hooks to register a string of code for execution before or
# after the installation process.
declare -a before_hooks after_hooks

before_virtualenv() {
  local hook="$1"
  before_hooks["${#before_hooks[@]}"]="$hook"
}

after_virtualenv() {
  local hook="$1"
  after_hooks["${#after_hooks[@]}"]="$hook"
}

# Load plugin hooks.
for script in $(pyenv-hooks virtualenv); do
  source "$script"
done


[ -d "${VIRTUALENV_PATH}" ] && PREFIX_EXISTS=1

# If the virtualenv exists, prompt for confirmation unless
# the --force option was specified.
if [ -d "${VIRTUALENV_PATH}/bin" ]; then
  if [ -z "$FORCE" ]; then
    echo "pyenv: ${VIRTUALENV_PATH} already exists" 1>&2
    read -p "continue with installation? (y/N) "

    case "$REPLY" in
    y* | Y* ) ;;
    * ) exit 1 ;;
    esac
  fi

  if [ -n "$UPGRADE" ]; then
    PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec pip freeze >"${UPGRADE_LIST}"
    mv -f "${VIRTUALENV_PATH}" "${UPGRADE_PATH}"
  fi
fi

# Execute `before_virtualenv` hooks.
for hook in "${before_hooks[@]}"; do eval "$hook"; done

# Plan cleanup on unsuccessful installation.
cleanup() {
  [ -z "${PREFIX_EXISTS}" ] && rm -rf "$VIRTUALENV_PATH"
}

trap cleanup SIGINT

# Invoke virtualenv and record exit status in $STATUS.
STATUS=0
# virtualenv may download distribute/setuptools in current directory.
# change to cache directory to reuse them between invocation.
mkdir -p "${PYENV_VIRTUALENV_CACHE_PATH}"
cd "${PYENV_VIRTUALENV_CACHE_PATH}"
virtualenv $QUIET $VERBOSE "${VIRTUALENV_OPTIONS[@]}" "${VIRTUALENV_PATH}" || STATUS="$?"

# Create symlink of `python' bound for actual executable
# TODO: remove this if virtualenv doesn't really need this
if [ ! -e "${VIRTUALENV_PATH}/bin/python" ]; then
  PYTHON_BIN="$(pyenv-which python)"
  if [ -L "${PYTHON_BIN}" ] && [ -e "${VIRTUALENV_PATH}/bin/$(basename "$(resolve_link "${PYTHON_BIN}")")" ]; then
    ( cd "${VIRTUALENV_PATH}/bin" && ln -s "${PYTHON_BIN}" "python" )
  fi
fi

if virtualenv_is_pyvenv; then
  [ -n "${EZ_SETUP_URL}" ] || EZ_SETUP_URL="https://bitbucket.org/pypa/setuptools/raw/${SETUPTOOLS_VERSION:-0.7.4}/ez_setup.py"
  PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec python -c 'import setuptools' 1>/dev/null 2>&1 || {
    http get "${EZ_SETUP_URL}" | PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec python
  }

  [ -n "${GET_PIP_URL}" ] || GET_PIP_URL="https://raw.github.com/pypa/pip/${PIP_VERSION:-master}/contrib/get-pip.py"
  PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-which pip 1>/dev/null 2>&1 || {
    http get "${GET_PIP_URL}" | PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec python
  }
fi

## Migrate previously installed packages from requirements.txt
if [ -n "$UPGRADE" ]; then
  UPGRADE_STATUS=0
  PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec pip install $QUIET $VERBOSE --requirement "${UPGRADE_LIST}" || UPGRADE_STATUS=$?
  if [ "$UPGRADE_STATUS" == "0" ]; then
    rm -f "${UPGRADE_LIST}"
    rm -fr "${UPGRADE_PATH}"
  else
    { echo
      echo "UPGRADE FAILED"
      echo
      echo "Inspect or clean up the original tree at ${UPGRADE_PATH}"
      echo
      echo "Package list:"
      cat "${UPGRADE_LIST}"
    } 1>&2
    STATUS="$UPGRADE_STATUS"
  fi
fi

# Execute `after_virtualenv` hooks
for hook in "${after_hooks[@]}"; do eval "$hook"; done

# Run `pyenv-rehash` after a successful installation.
if [ "$STATUS" == "0" ]; then
  pyenv-rehash
else
  cleanup
fi

exit "$STATUS"