#!/usr/bin/env bash

## rdlink [-d|--debug] <PATH>
##
## License: GNU GPL V3 or later
##  Author: Martin Winkler

# Exit on error. Append "|| true" if you expect an error.
set -o errexit
# Exit on error inside any functions or subshells.
set -o errtrace
# Do not allow use of undefined vars. Use ${VAR:-} to use an undefined VAR
set -o nounset
# Catch the error in case mysqldump fails (but gzip succeeds) in `mysqldump |gzip`
set -o pipefail

LOG_LEVEL="${LOG_LEVEL:-1}" # 7 = debug -> 0 = emergency

rl::rdlink() {
  local subject=
  local work=
  local resolved=0

  info "pwd: $(pwd)"
  info "Processing... $@"

  subject="$(rl::normalize "${1:-}")" || true
  # Follow multiple symlinks
  while subject="$(rl::quicklink "${subject}")" ; do
    # A link was resolved at least once
    info "rl::rdlink - Link found: $subject"
    resolved=1
  done

  # Special cases handling
  {
    # If subject is still a link, after rl::quicklink call(s)
    # current user has no permission to access the link itself
    # (e.g. /proc/**/cwd)
    if [ -L "${subject}" ] ; then
      info "rl::rdlink exit - can't access link ${subject}"
      printf "\n"
      return 1
    fi
  }

  # Empty output if (dirname $subject) is not a valid path
  if ! work="$(rl::canon "${subject}")" ; then
    # Special: Links resolved to something like: /proc/2267178/fd/pipe:[22306727]
    # are not existing files but `readlink -f` prints result anyway
    # Printing result if a link was resolved at least once
    if (( ! resolved )); then
      info "rl::rdlink exit - invalid path ${subject}"
      printf "\n"
      return 1
    fi
  else
    subject="${work}"
  fi

  printf "${subject}\n"
}

rl::quicklink() {
  subject=
  work=

  info "Quicklink... ${1:-}"

  # Check if current candidate is a symlink
  if ! subject=$(readlink -- "${1:-}"); then
    printf -- "${1:-}\n"
    return 1
  fi
  info " - symlink ${1} -> ${subject}"

  # relative symlink target; prepend its parent direcotry
  if [[ "${subject}" != "/"* ]]; then
    work="$(rl::canon "$(dirname -- "${1:-}")")"
    subject="${work}/${subject}"
    info " - relative link resolved: ${subject}"
  fi

  printf "${subject}\n"
  return 0
}

rl::canon() {
  local subject=
  local work=
  local bname=

  info "Canonicalize path... ${1:-}"
  if work="$(cd "${1:-}" >/dev/null 2>&1 && pwd -P)" ; then
    # Special: `pwd -P` returns with // as root for links starting at /
    # e.g. $(readlink /proc/self/root) == "/"
    #      $(cd /proc/self/root/mnt && pwd -P) == "//mnt"
    subject="$(rl::normalize "${work}")"
    info " - directory: ${subject}"
  elif work="$(cd "$(dirname -- "${1:-}")" >/dev/null 2>&1 && pwd -P)" ; then
    bname="$(basename -- "${1:-}")"

    # Special: / produces //
    [[ "${work}" == "/" ]] && work=

    subject="${work}${bname:+"/${bname}"}"
    info " - parent: ${subject}"
  else
    info " - no hit for: ${1:-}"
    subject="${1:-}"
    return 1
  fi

  printf -- "${subject}\n"
  return 0
}

rl::normalize() {
  local work=
  info "Normalizing... ${1:-}"

  work="${1:-}"
  # Remove multiple /
  while [[ "${work:-}" = *"//"* ]]; do
    work="${work//'//'/'/'}"
  done

  printf -- "${work}\n"
}

rl::main() {
  local file=
  local arg=

  for arg in "$@"; do
    case "$arg" in
      --)
        shift
        break ;;
      -d|--debug)
        shift
        LOG_LEVEL=7 ;;
      -dd)
        shift
        set -o xtrace ;;
      -*)
        shift ;;
    esac
  done

  info "BASH rdlink"

  for file in "$@"; do
    rl::rdlink "$file"
  done
}

function rl::log () {
  local log_level="${1:-${LOG_LEVEL}}"
  shift

  # all remaining arguments are to be printed
  local log_line=""

  while IFS=$'\n' read -r log_line; do
    printf "%s [%9s] %s\n" "$(date -u +"%Y-%m-%d %H:%M:%S UTC")" "${log_level}" "${log_line}" 1>&2
  done <<< "${@:-}"
}
emergency() {                                  rl::log emergency "${@}"; exit 1; }
alarm()     { [[ "${LOG_LEVEL:-0}" -ge 1 ]] && rl::log alert "${@}"; true; }
critical()  { [[ "${LOG_LEVEL:-0}" -ge 2 ]] && rl::log critical "${@}"; true; }
error()     { [[ "${LOG_LEVEL:-0}" -ge 3 ]] && rl::log error "${@}"; true; }
warning()   { [[ "${LOG_LEVEL:-0}" -ge 4 ]] && rl::log warning "${@}"; true; }
notice()    { [[ "${LOG_LEVEL:-0}" -ge 5 ]] && rl::log notice "${@}"; true; }
info()      { [[ "${LOG_LEVEL:-0}" -ge 6 ]] && rl::log info "${@}"; true; }
debug()     { [[ "${LOG_LEVEL:-0}" -ge 7 ]] && rl::log debug "${@}"; true; }
msg()       {                                  echo "$@"; true; }


# Provide as function to be called when sourced
rdlink() {
  rl::rdlink "$@"
}

### Check if script is _sourced
### https://stackoverflow.com/a/28776166
_sourced=0
if [ -n "${ZSH_EVAL_CONTEXT:-}" ]; then
  case ${ZSH_EVAL_CONTEXT:-} in *:file) _sourced=1;; esac
elif [ -n "${KSH_VERSION:-}" ]; then
  [ "$(cd $(dirname -- $0) && pwd -P)/$(basename -- $0)" != "$(cd $(dirname -- ${.sh.file}) && pwd -P)/$(basename -- ${.sh.file})" ] && _sourced=1
elif [ -n "${BASH_VERSION:-}" ]; then
  (return 0 2>/dev/null) && _sourced=1
else # All other shells: examine $0 for known shell binary filenames
  # Detects `sh` and `dash`; add additional shell filenames as needed.
  case ${0##*/} in sh|dash) _sourced=1;; esac
fi
###

if (( ! _sourced )); then
  rl::main "$@"
fi