.aliasrc-shell-settings

# vi: ft=zsh

DIR="$(dirname "$(readlink -f "$0")")"

alias pbc="pbcopy"
alias gd="git diff"
alias gdh="gd HEAD"
alias gds="gd --staged"
alias gs="git status"
alias hist="history"
alias l='ls -la | grep "^d" && ls -la | grep -v "^d"'
alias ll="ls -la"
alias s="source ~/.zshrc && hash -r && if type direnv > /dev/null; then direnv reload; fi"
alias yarn=__yarn

# functions
alias bunx=__bunx
alias mise-install=__mise-install
alias mise-update=__mise-update
alias cdf=__cdf
alias cdt=__cdt
alias dns=__dns
alias ff=__ff
alias fif=__fif
alias git-set-origin=__git-set-origin
alias git-vim-status=__git-vim-status
alias screen=__screen
alias ssh-keygen-secure=__ssh-keygen-secure
alias u=__u

# bash scripts
export BASH_SCRIPTS_PATH="$DIR/scripts"
export PATH="$BASH_SCRIPTS_PATH:$PATH"

# bash script aliases
for f in `find "$BASH_SCRIPTS_PATH" -type f -name "alias_*"`; do
  cmd=`echo $f | sed -E 's#.*alias_(.*)#\1#'`
  toeval="alias $cmd=\"$BASH_SCRIPTS_PATH/alias_$cmd\""
  eval "$toeval"
done

# just helpful if I'm looking for the command and look under disk :)
alias disknnn="nnn"

if [ "$OS" = "darwin" ]; then
  echo "macOS detected: loading $BASH_SCRIPTS_PATH/osx"
  export PATH="$PATH:$BASH_SCRIPTS_PATH/osx"
fi

if [ "$OS" = "proxmox" ]; then
  echo "proxmox detected: loading $BASH_SCRIPTS_PATH/proxmox"
  export PATH="$PATH:$BASH_SCRIPTS_PATH/proxmox"
fi

# node scripts
__add_node_scripts_to_path() {
  local nodedir="$DIR/scripts/node"
  for f in `ls $nodedir`; do
    local filename=$(basename "$nodedir/$f" .mjs)
    alias $filename="$nodedir/$f"
  done
}
__add_node_scripts_to_path

################################################################
# aliasing these to functions breaks functionality
cd() {
  if [ $# -eq 1 -a -f "$@" ]; then
    echo "file found, changing to parent directory"
    cdf "$1"
    return $?
  fi

  if [ "$1" != "-" -a ! -d "$@" ]; then
    echo "no such directory: $@"
    return 1
  fi

  builtin cd "$@" && echo "$OLDPWD --> $PWD"
}

__rmrf() {
  SECONDS=0
  echo "rm -rf $@"
  local volume="$(df -P . | sed -n '$s/[^%]*%[[:blank:]]*//p')"
  local tmp=$(mktemp)
  local tmpFolder=$(basename $tmp)
  local folders=("$@")

  if [ $volume = "/" ]; then
    local trash="/tmp/trash"
  else
    local trash="$volume/tmp/trash"
  fi

  mkdir -p $trash

  if [ "$#" -eq 0 ]; then
    echo "trash: $trash"
    ls -la $trash
    return 0;
  fi

  local trashfolder="$trash/$tmpFolder"
  mkdir -p $trashfolder

  echo "moving "$folders" to $trashfolder"
  mv $folders $trashfolder
  echo "emptying $trash in the background..."

  __rmrfhelper() {
    duration=$SECONDS
    command rm -rf $trash
    echo "$(($duration / 60)) minutes and $(($duration % 60)) seconds elapsed."
  }

  { __rmrfhelper & } 2>/dev/null
}

__rm() {
  if [ "$1" = "-rf" ]; then
    shift
    __rmrf "$@"
    return $?
  fi

  command rm "$@"
}

function findup() {
  local needle="${1}"
  local _DIR="${PWD}"

  while [[ $PWD != '/' && ${PWD##*/} != 'httpdocs' ]]; do
    if [[ -d "$needle" || -f "$needle" ]]; then
      echo "${PWD}/${needle}"
      builtin cd "${_DIR}"
      return 0
    fi

    builtin cd ..
  done

  builtin cd "${_DIR}"
}
################################################################

__bunx() {
  if exists bun; then
    bun x "$@"
  else
    mise-install bun && bun x "$@"
  fi
}

__mise-install() {
  if [ -z $1 ]; then
    echo "missing plugin name"
    return
  fi

  mise plugin add "$1"
  mise install "$1@latest"
  mise global "$1@latest"
}

__mise-update() {
  mise update
  for tool in $(mise plugin list); do
    mise install "${tool}" latest  \
      &&  mise global "${tool}" latest  \
      &&  echo "${tool} set globally"
    done
}

__caff() {
  if command -v caffeinate &> /dev/null
  then
    caffeinate -disu
  else
    echo "caffeinate not supported"
  fi
}

__cdf() {
  cd "$(dirname "$1")"
}


# cd to file or folder
__cdt() {
  while [[ $PWD != '/' && `basename $PWD` != "$1" && ! -f "$1" ]]; do cd ..; done
}

__dns() {
  domain="$1"
  echo "[nameservers]"
  dig +short "$domain" ns
  echo "[a records]"
  dig +short "$domain" a
  echo "[cname records]"
  dig +short "$domain" cname
  echo "[txt records]"
  dig +short "$domain" txt
  echo "[mx records]"
  dig +short "$domain" mx
  echo "[aaaa records]"
  dig +short "$domain" aaaa
  echo "[srv records]"
  dig +short "$domain" srv
}

# find file
__ff() {
  local needle="${1:- }"
  local grepopts="$2"

  find . -iname "*$needle*" -type f | grep "$needle" $grepopts
}

# find in file
__fif() {
  grep "$@" -r . | grep "$@"
}

__git-set-origin() {
  local remote="${1:-origin}"
  local currentbranch=$(git rev-parse --abbrev-ref HEAD)

  local gitpath="$remote/$currentbranch"
  echo "Setting upstream to \"$gitpath\""
  git branch --set-upstream-to="$gitpath"
}

__git-vim-status() {
  vim -p $(git status -s | sed -r 's#^(.*->)?[ARMU? ]+(.*)$#\2#')
}

__screen() {
  if [[ ! $1 =~ ^- ]]; then
    if [[ $1 == "ls" ]]; then
      command screen -ls
      return $?
    fi

    command screen -RR -S "$1"
    return $?
  fi

  command screen "$@"
  return $?
}

__ssh-keygen-secure() {
  ssh-keygen -t ed25519 -a 100
}

__u() {
  if exists brew; then
    echo "updating brew"
    brew update && brew upgrade
  fi
  if exists pacman; then
    echo "updating pacman"
    sudo pacman -Syu
  fi
  if exists apt; then
    if apt -v &> /dev/null; then
      echo "updating apt"
      sudo apt update && sudo apt upgrade
    fi
  fi
  if exists yum; then
    echo "updating yum"
    sudo yum update
  fi
}


__yarn() {
  echo "!!! use bun !!!"
  return 1
}