.functions

#!/usr/bin/env zsh

# http://www.zsh.org/mla/users//2014/msg00715.html
zshaddhistory() { whence ${${(z)1}[1]} >| /dev/null || return 1 }

# Change working directory to the top-most Finder window location
function cdf() { # short for `cdfinder`
  cd "$(osascript -e 'tell app "Finder" to POSIX path of (insertion location as alias)')";
}

# Create a .tar.gz archive, using `zopfli`, `pigz` or `gzip` for compression
function targz() {
  local tmpFile="${@%/}.tar";
  tar -cvf "${tmpFile}" --exclude=".DS_Store" "${@}" || return 1;

  size=$(
    stat -f"%z" "${tmpFile}" 2> /dev/null; # macOS `stat`
    stat -c"%s" "${tmpFile}" 2> /dev/null;  # GNU `stat`
  );

  local cmd="";
  if (( size < 52428800 )) && hash zopfli 2> /dev/null; then
    # the .tar file is smaller than 50 MB and Zopfli is available; use it
    cmd="zopfli";
  else
    if hash pigz 2> /dev/null; then
      cmd="pigz";
    else
      cmd="gzip";
    fi;
  fi;

  echo "Compressing .tar ($((size / 1000)) kB) using \`${cmd}\`…";
  "${cmd}" -v "${tmpFile}" || return 1;
  [ -f "${tmpFile}" ] && rm "${tmpFile}";

  zippedSize=$(
    stat -f"%z" "${tmpFile}.gz" 2> /dev/null; # macOS `stat`
    stat -c"%s" "${tmpFile}.gz" 2> /dev/null; # GNU `stat`
  );

  echo "${tmpFile}.gz ($((zippedSize / 1000)) kB) created successfully.";
}

# Determine size of a file or total size of a directory
function fs() {
  if du -b /dev/null > /dev/null 2>&1; then
    local arg=-sbh;
  else
    local arg=-sh;
  fi
  if [[ -n "$@" ]]; then
    du $arg -- "$@";
  else
    du $arg .[^.]* ./*;
  fi;
}

# Get colors in manual pages
function man() {
  env \
    LESS_TERMCAP_mb="$(printf '\e[1;31m')" \
    LESS_TERMCAP_md="$(printf '\e[1;31m')" \
    LESS_TERMCAP_me="$(printf '\e[0m')" \
    LESS_TERMCAP_se="$(printf '\e[0m')" \
    LESS_TERMCAP_so="$(printf '\e[1;44;33m')" \
    LESS_TERMCAP_ue="$(printf '\e[0m')" \
    LESS_TERMCAP_us="$(printf '\e[1;32m')" \
    man "$@"
}

# Use Git’s colored diff when available
hash git &>/dev/null;
if [ $? -eq 0 ]; then
  function diff() {
    git diff --no-index --color-words "$@";
  }
fi;

# Create a data URL from a file
function dataurl() {
  local mimeType=$(file -b --mime-type "$1");
  if [[ $mimeType == text/* ]]; then
    mimeType="${mimeType};charset=utf-8";
  fi
  echo "data:${mimeType};base64,$(openssl base64 -in "$1" | tr -d '\n')";
}

# Create a git.io short URL
function gitio() {
  if [ -z "${1}" -o -z "${2}" ]; then
    echo "Usage: \`gitio slug url\`";
    return 1;
  fi;
  curl -i https://git.io/ -F "url=${2}" -F "code=${1}";
}

serve-spa() {
  command -v npx >/dev/null 2>&1 || { echo >&2 "node >v12.x.x is required. Aborting."; exit 1; }
  local port_number=${1:-3000}
  local current_dir=${2:-$PWD}

  echo 'serving ' $current_dir
  npx serve --single --cors --no-clipboard -p $port_number $current_dir
}

server() {
  command -v npx >/dev/null 2>&1 || { echo >&2 "node >v12.x.x is required. Aborting."; exit 1; }
  local port_number=${1:-3000}
  local current_dir=${2:-$PWD}

  echo 'serving ' $current_dir
  npx serve --single --cors --no-clipboard -p $port_number $current_dir
}

# Compare original and gzipped file size
function gz() {
  local origsize=$(wc -c < "$1");
  local gzipsize=$(gzip -c "$1" | wc -c);
  local ratio=$(echo "$gzipsize * 100 / $origsize" | bc -l);
  printf "orig: %d bytes\n" "$origsize";
  printf "gzip: %d bytes (%2.2f%%)\n" "$gzipsize" "$ratio";
}

# Run `dig` and display the most useful info
function digga() {
  dig +nocmd "$1" any +multiline +noall +answer;
}

# UTF-8-encode a string of Unicode symbols
function escape() {
  printf "\\\x%s" $(printf "$@" | xxd -p -c1 -u);
  # print a newline unless we’re piping the output to another program
  if [ -t 1 ]; then
    echo ""; # newline
  fi;
}

# Decode \x{ABCD}-style Unicode escape sequences
function unidecode() {
  perl -e "binmode(STDOUT, ':utf8'); print \"$@\"";
  # print a newline unless we’re piping the output to another program
  if [ -t 1 ]; then
    echo ""; # newline
  fi;
}

# Get a character’s Unicode code point
function codepoint() {
  perl -e "use utf8; print sprintf('U+%04X', ord(\"$@\"))";
  # print a newline unless we’re piping the output to another program
  if [ -t 1 ]; then
    echo ""; # newline
  fi;
}

# Show all the names (CNs and SANs) listed in the SSL certificate
# for a given domain
function getcertnames() {
  if [ -z "${1}" ]; then
    echo "ERROR: No domain specified.";
    return 1;
  fi;

  local domain="${1}";
  echo "Testing ${domain}…";
  echo ""; # newline

  local tmp=$(echo -e "GET / HTTP/1.0\nEOT" \
    | openssl s_client -connect "${domain}:443" -servername "${domain}" 2>&1);

  if [[ "${tmp}" = *"-----BEGIN CERTIFICATE-----"* ]]; then
    local certText=$(echo "${tmp}" \
      | openssl x509 -text -certopt "no_aux, no_header, no_issuer, no_pubkey, \
      no_serial, no_sigdump, no_signame, no_validity, no_version");
    echo "Common Name:";
    echo ""; # newline
    echo "${certText}" | grep "Subject:" | sed -e "s/^.*CN=//" | sed -e "s/\/emailAddress=.*//";
    echo ""; # newline
    echo "Subject Alternative Name(s):";
    echo ""; # newline
    echo "${certText}" | grep -A 1 "Subject Alternative Name:" \
      | sed -e "2s/DNS://g" -e "s/ //g" | tr "," "\n" | tail -n +2;
    return 0;
  else
    echo "ERROR: Certificate not found.";
    return 1;
  fi;
}

#Open caniuse.com in browser
caniuse() {
  local domain="https://caniuse.com/"
  local query

  if [ $# -eq 0 ]; then
      open -u ${domain}
  else
      for term in "$@"; do
          query=$(node -p "encodeURIComponent('${term}')")
          open -u "${domain}#search=${query}"
      done
  fi
}

#   ii:  display useful host related informaton
#   -------------------------------------------------------------------
ii() {
    echo -e "\nYou are logged on ${RED}$HOST"
    echo -e "\nAdditionnal information:$NC " ; uname -a
    echo -e "\n${RED}Users logged on:$NC " ; w -h
    echo -e "\n${RED}Current date :$NC " ; date
    echo -e "\n${RED}Machine stats :$NC " ; uptime
    echo -e "\n${RED}Current network location :$NC " ; scselect
    echo -e "\n${RED}Public facing IP Address :$NC " ; pubip
    #echo -e "\n${RED}DNS Configuration:$NC " ; scutil --dns
}

# who is using the laptop's iSight camera?
camerausedby() {
  echo "Checking to see who is using the iSight camera… 📷"
  usedby=$(lsof | grep -w "AppleCamera\|USBVDC\|iSight" | awk '{printf $2"\n"}' | xargs ps)
  echo -e "Recent camera uses:\n$usedby"
}

# direct it all to /dev/null
function nullify() {
  "$@" >/dev/null 2>&1
}

#remove remote git branches by prefix
git-branch-rm-remote() {
  vared -p "This will remove your remote branches with '$@' prefix. Are you sure? [yn] " -c answer
  if [[ $answer = y ]] ; then
    git branch -r | awk -Forigin/ '/\/'$@'/ {print $2 $3}' | xargs -I {} git push origin :{}
  fi
}

set-gitlab() {
  local username

    if [ "$#" -eq 1 ]; then
      echo 'Usage: set-gitlab <username> <repo-name>'
      exit 1;
    fi

  git remote set-url --add --push origin git@github.com:${1}/${2}.git && \
  git remote set-url --add --push origin git@gitlab.com:${1}/${2}.git
}

git-track-branches() {
  for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; do
    git branch --track ${branch#remotes/origin/} $branch
  done
}

skype() {
  local account=${1:-nmrony}
  open -na /Applications/Skype.app --args --secondary --datapath="/Users/$(whoami)/Library/Application\ Support/Skype-$account"
}

rmp() {
    if [ "$#" -eq 0 ]; then
        echo "Usage: rmp <file_or_directory> ..."
        return 1
    fi

    [[ "$#" -lt 2 ]] && { echo "Usage: rmp <target>"; return 1; }

    # Warn if deleting more than 10 items
    if [ "$#" -gt 10 ]; then
        read -p "You are about to delete $#. Proceed? [y/N] " answer
        case "$answer" in
            [Yy]* ) ;;
            * ) echo "Aborted."; return 1 ;;
        esac
    fi

    # Create timestamped trash folder
    mkdir -p "/tmp/.empty"

    # Loop through all arguments
    for target in "$@"; do
        if [ -e "$target" ]; then
            # Use rsync to sync file/directory to /tmp/.empty
            rsync --recursive --whole-file --info=progress2 --delete "$target" /tmp/.empty/ 2>/dev/null
            # Remove any empty directories left behind
            rm -rf "$target" /tmp/.empty 2>/dev/null
        else
            echo "Warning: '$target' does not exist"
        fi
    done
}

# remote and local friendly resumable copy command with progress bar
# Examples:
#   cpv /local/file /local/dest/
#   cpv /local/file user@host:/remote/path/
#   cpv user@host:/remote/file /local/dest/
#   cpv user1@host1:/file user2@host2:/dest/
cpv() {
     [[ $# -lt 2 ]] && { echo "Usage: cpv <source> <destination>"; return 1; }

    local src="$1"
    local dest="$2"
    local ssh_opts="ssh -T -o Compression=no -o ControlMaster=auto -o ControlPath=/tmp/ssh-%r@%h:%p -o ControlPersist=600"

    # Detect if source and/or destination is remote
    local src_remote=false
    local dest_remote=false
    [[ "$src" == *:* ]] && src_remote=true
    [[ "$dest" == *:* ]] && dest_remote=true

    # Remote transfers: use SSH
    if $src_remote || $dest_remote; then
        # Remote transfer: use SSH optimized for speed
        rsync -aH --compress --progress --ignore-existing --whole-file --partial -e "$ssh_opts" \
          --compress-level=1 --skip-compress=gz/zip/z/rpm/deb/iso/bz2/tgz/7z/mp3/mp4/mov/avi/ogg/jpg/jpeg/png/pdf \
          "$src" "$dest"
    else
        # Local transfer: no compression, whole file
        rsync -aH --info=progress2 --ignore-existing --whole-file --partial "$src" "$dest"
    fi
}


## Taken from https://github.com/ohmyzsh/ohmyzsh/blob/master/lib/functions.zsh
# take functions

# mkcd is equivalent to takedir
function mkcd takedir() {
  mkdir -p $@ && cd ${@:$#}
}

function takeurl() {
  local data thedir
  data="$(mktemp)"
  curl -L "$1" > "$data"
  tar xf "$data"
  thedir="$(tar tf "$data" | head -n 1)"
  rm "$data"
  cd "$thedir"
}

function takegit() {
  git clone "$1"
  cd "$(basename ${1%%.git})"
}

function take() {
  if [[ $1 =~ ^(https?|ftp).*\.(tar\.(gz|bz2|xz)|tgz)$ ]]; then
    takeurl "$1"
  elif [[ $1 =~ ^([A-Za-z0-9]\+@|https?|git|ssh|ftps?|rsync).*\.git/?$ ]]; then
    takegit "$1"
  else
    takedir "$@"
  fi
}

# install and update MinC (Microshift in Container for Kubernetes cluster)
function update_minc() {
  if [[ $(uname -m) == "arm64" ]]; then
   curl -L -o ~/.local/bin/minc https://github.com/minc-org/minc/releases/latest/download/minc_darwin_arm64
   chmod +x ~/.local/bin/minc && ~/.local/bin/minc completion zsh > $DEV_ZONE_CONFIG_PATH/zinit/_minc
  else
    curl -L -o ~/.local/bin/minc https://github.com/minc-org/minc/releases/latest/download/minc_darwin_amd64
    chmod +x ~/.local/bin/minc && ~/.local/bin/minc completion zsh > $DEV_ZONE_CONFIG_PATH/zinit/_minc
  fi
}



# toggle proxy settings for macos
function toggle_proxy() {
  local PROXY_URL=${1:-$AUTO_PROXY_URL}
  local SERVICE=${2:-"Wi-Fi"}

  if [[ $1 == "--help" ]] || [[ $1 == "-h" ]] || [[ $1 == "help" ]]; then
    echo
    echo "Usage: $0 <proxy-url> <service> (defaut: service: Wi-Fi, proxy-url: AUTO_PROXY_URL)"
    echo
    echo "Options:"
    echo "  help      --help, -h        print help menu"
    echo "  status    --status, -s      current status of proxy"
    return
  fi

  local AUTO_PROXY_STATUS=$(networksetup -getautoproxyurl "$SERVICE" | grep Enabled | awk '{print $2}')

  if [[ "$1" == "--status" ]] || [[ "$1" == "-s" ]] || [[ "$1" == "status" ]]; then
    echo -n "Auto Proxy for $SERVICE: "
    [[ "$AUTO_PROXY_STATUS" == "No" ]] && echo "Disabled" || echo "Enabled"
    return
  fi

  if [[ $AUTO_PROXY_STATUS == "Yes" ]]; then
    echo "Disabling Auto Proxy..."
    networksetup -setautoproxystate "$SERVICE" off
    echo "Auto Proxy disabled."
  else
    echo "Enabling Auto Proxy with PAC URL: ${PROXY_URL}"
    networksetup -setautoproxyurl "${SERVICE}" "${PROXY_URL}"
    networksetup -setautoproxystate "${SERVICE}" on
    echo "Auto Proxy enabled."
  fi
  echo "\nFor help pass help/--help/-h"
}