_functions

#!/usr/bin/env bash
### .functions - more complicated aliases, basically

# colors
_RED="$(tty -s && tput setaf 1)"
_YELLOW="$(tty -s && tput setaf 3)"
_WHITE="$(tty -s && tput setaf 7)"
_GRAY="$(tty -s && tput setaf 8)"
_BOLD="$(tty -s && tput bold)"
_RESET="$(tty -s && tput sgr0)"

# list: display all functions in custom dotfiles
function _funclist {
  if hash ag 2>/dev/null; then
    ag '(function )([A-Za-z0-9_-]+)' "${HOME}"/.functions* --nonumbers
  else
    echo 'Error: Missing ag (silver searcher). Cannot display functions.'
  fi
}

# ansicolors: display all fg and bg ansi color escape codes
function ansicolors {
  for attr in $(seq 0 1); do
    for fg in $(seq 30 37); do
      for bg in $(seq 40 47); do
        printf "\033[%i;%i;%im%i;$i;%i\033[m " "$attr" "$bg" "$fg" "$attr" "$fg" "$bg"
      done
      echo
    done
  done
}

# b64: base64 encode string
function b64 {
  echo -n "$1" | openssl base64
}

# dummy: create dummy binary file
function dummy() {
  dd if=/dev/urandom bs=1024 count="$1" of=dummy
}

# print out list of generic variables
function foobarlist() {
  list=('foo' 'bar' 'baz' 'qux' 'quux' 'quuz' 'corge' 'grault' 'garply' 'waldo' 'fred' 'plugh' 'xyzzy' 'thud')

  if [[ $# -eq 0 ]]; then
    for w in "${list[@]}"; do
      echo "${w}"
    done
  elif [[ $# -ge 1 ]]; then
    echo "${list[$1]}"
  fi
}

# get_rand_port: get random available local port for local webservers
function get_rand_port {
  netstat -aln | awk '
    $6 == "LISTEN" {
      if ($4 ~ "[.:][0-9]+$") {
        split($4, a, /[:.]/);
        port = a[length(a)];
        p[port] = 1
      }
    }
    END {
      for (i = 3000; i < 65000 && p[i]; i++){};
      if (i == 65000) {exit 1};
      print i
    }
  '
}

# list http ports and procs
function httports {
  # shellcheck disable=SC2196
  lsof -i -n -P | grep "${HTTP_SERVICES:?}" | grep LISTEN | egrep -o ":[0-9]{2,5}" | cut -f2- -d: | sort -n | uniq
}
function httportss {
  # shellcheck disable=SC2196
  sudo lsof -i -n -P | grep "${HTTP_SERVICES}" | grep LISTEN | egrep -o ":[0-9]{2,5}" | cut -f2- -d: | sort -n | uniq
}
function httprocs() {
  lsof -i -n -P | grep 'httpd\|vpnkit\|java\|nc\|node\|ng' | grep LISTEN | awk '{print $1}' | sort -n
}
function httprocss {
  sudo lsof -i -n -P | grep 'httpd\|vpnkit\|java\|nc\|node\|ng' | grep LISTEN | awk '{print $1}' | sort -n | uniq
}

# simple http servers for local directory in various flavors
## php
function httphp() {
  rport=$(get_rand_port);

  if [[ $# -eq 1 ]]; then
    open http://localhost:"${rport}" "$1";
  else
    open http://localhost:"${rport}";
  fi

  php -S 127.0.0.1:"${rport}";
}
## python 2.x
function httpy2 {
  rport=$(get_rand_port);
  open http://localhost:"${rport}";
  python -m SimpleHTTPServer "${rport}";
}
## python 3.x
function httpy3 {
  rport=$(get_rand_port);
  open http://localhost:"${rport}";
  python3 -m http.server "${rport}";
}
## python 3.x (or 2.x if 3.x not available)
function httpy {
  major_version="$(python -c 'import platform as p;print(p.python_version_tuple()[0])')"
  rport=$(get_rand_port)
  if [[ "${major_version}" == '3' ]]; then
    exec python -m http.server "${rport}"
  else
    exec python -m SimpleHTTPServer "${rport}"
  fi
}
## nodejs (http-server)
function httnode {
  rport=$(get_rand_port);
  http-server -o -p "${rport}";
}
## ruby 1.9.2+
function httruby {
  rport=$(get_rand_port);
  open http://localhost:"${rport}";
  ruby -run -e httpd . -p "${rport}";
}

function jcurl {
  # http://benw.me/posts/colourized-pretty-printed-json-with-curl/
  curl "$@" | jq | pygmentize -l json -O "style=paraiso-dark"
}

## get the Notes field from a Logic Pro X project (e.g. lyrics)
function lpxdump_notes() {
  # Check if a filename is provided as an argument
  if [[ "$#" -ne 1 ]]; then
    echo "Usage: lpxdump_notes <filename>"
  else
    # assuming only one Alternative
    filename=$1/Alternatives/000/ProjectData

    # Check if the file exists
    if [[ ! -e "${filename}" ]]; then
      echo "File not found: ${filename}"
    else
      # regex pattern for code where Notes start and end (in LPX 10.7, at least)
      pattern='\\\\f0\\\\fs30'
      end_pattern='}'

      # find first, and only first, instance of this to capture Project Notes
      str=$(strings "${filename}" | awk -v pattern="${pattern}" -v end_pattern="${end_pattern}" '
        $0 ~ pattern {
          flag=1
        }
        flag {
          print
        }
        $0 ~ end_pattern && flag {
          flag=0
          exit
        }
      ')

      # clean up output
      notes=$(
        echo "${str}" \
        | awk '{gsub(/pard.+/,""); print}' \
        | awk '{gsub(/\\f0\\fs30/,""); print}' \
        | awk '{gsub(/\\cf2 /,""); print}' \
        | awk '{gsub(/^ /,""); print}' \
        | awk '{gsub(/\\/,""); print}' \
        | awk '{gsub(/\}/,""); print}' \
        | awk '{gsub(/^[\s]+$/,""); print}' \
        | awk '{gsub(/qSxT/,""); print}' \
        | awk '{gsub(/\04792/,"\047"); print}' \
      )

      echo "${notes}"
    fi
  fi
}
alias logicdump_notes=lpxdump_notes

## get the Tempo field from a Logic Pro X project
function lpxdump_tempo() {
  # Check if a filename is provided as an argument
  if [[ "$#" -ne 1 ]]; then
    echo "Usage: lpxdump_tempo <filename>"
  else
    # assuming only one Alternative
    altdir=Alternatives/000/MetaData
    filename=$1/${altdir}

    # Check if the file exists
    if [[ ! -e "$1" ]]; then
      echo "File not found: $1"
    else
      echo "$1"
      # use built-in macOS defaults tool to read .plist
      defaults read "${filename}" BeatsPerMinute
    fi
  fi
}
alias logicdump_tempo=lpxdump_tempo

## love2d - make .love file from source directory for macOS
function makelovefile() {
  if [[ "$#" -eq 0 ]]; then
    DEST=$(basename "$(pwd)").love
    SRC="."
  elif [[ "$#" -eq 1 ]]; then
    DEST=$1
    SRC="."
  elif [[ "$#" -ge 2 ]]; then
    DEST=$1
    SRC=$2
  fi

  zip -r "${DEST}" "${SRC}" -x "*.git*" -x "*.DS_Store" -x "*.md"
}

# display public IP using cloudflare/google
# myip 4 -> IPv4, myip 6 -> IPv6, myip -> IPv4 and IPv6
function myip() {
  if [[ $# -eq 0 ]]; then
    myip4=$(dig +short txt ch whoami.cloudflare @1.0.0.1)
    myip6=$(dig -6 TXT +short o-o.myaddr.l.google.com @ns1.google.com)

    echo "${myip4}" | xargs
    echo "${myip6}" | xargs
  elif [[ $# -ge 1 ]]; then
    if [[ "$1" -eq '4' ]]; then
      myip=$(dig +short txt ch whoami.cloudflare @1.0.0.1)

      echo "${myip}" | xargs
    elif [[ "$1" -eq '6' ]]; then
      myip=$(dig -6 TXT +short o-o.myaddr.l.google.com @ns1.google.com)

      echo "${myip}" | xargs
    else
      echo "only IPv4 and IPv6 supported"
    fi
  fi
}

# creates temp http server using various langs
# depending on what's available on the host
function serveit() {
  if hash php 2>/dev/null; then
    httphp "$@"
  elif hash ruby 2>/dev/null; then
    httruby "$@"
  elif hash node 2>/dev/null; then
    httnode "$@"
  elif hash python3 2>/dev/null; then
    httpy3 "$@"
  elif hash python 2>/dev/null; then
    httpy "$@"
  else
    echo "cannot start server: no supported languages available (php, ruby, node, python)"
  fi
}

# speedtest
function speedtest() {
  if hash speedtest-cli 2>/dev/null; then
    logfile="${HOME}"/speedtest_log.txt

    echo "Checking internet speed and logging..."
    {
      date
      echo "============================"
      hostname
      speedtest-cli --simple
      echo "----------------------------"
      echo ""
    } >> "${logfile}"
    echo "Done and logged to ${logfile}"
  else
    echo "speedtest-cli not installed; try brew install speedtest-cli"
  fi
}

# mov to gif
function vid2gif() {
  RUN_CMD=true

  if ! [[ -x "$(command -v ffmpeg)" ]]; then
    echo 'Error: ffmpeg is not installed. Please install with (brew install ffmpeg)' >&2
    RUN_CMD=false
  fi

  if ! [[ -x "$(command -v gifsicle)" ]]; then
    echo 'Error: gifsicle is not installed. Please install with (brew install gifsicle)' >&2
    RUN_CMD=false
  fi

  if [[ "${RUN_CMD}" = true ]]; then
    ffmpeg -i "$1" -pix_fmt rgb24 -r 10 -f gif - | gifsicle --optimize=3 --delay=8 > ~/Downloads/"$1".gif
  fi
}
alias mp42gif=vid2gif
alias mov2gif=vid2gif

# mp3 to ogg
function mp32ogg() {
  if ! [[ -x "$(command -v ffmpeg)" ]]; then
    echo 'Error: ffmpeg is not installed. please install with (brew install ffmpeg)' >&2
    exit 1
  fi

  for i in *.mp3; do ffmpeg -i "${i}" "${i%.*}.ogg"; done
}

# mp3 to wav
function mp32wav() {
  if ! [[ -x "$(command -v ffmpeg)" ]]; then
    echo 'Error: ffmpeg is not installed. please install with (brew install ffmpeg)' >&2
    exit 1
  fi

  for i in *.mp3; do ffmpeg -i "${i}" "${i%.*}.wav"; done
}

# wav to flac
function wav2flac() {
  if ! [[ -x "$(command -v ffmpeg)" ]]; then
    echo 'Error: ffmpeg is not installed. please install with (brew install ffmpeg)' >&2
    exit 1
  fi

  for i in *.wav; do ffmpeg -i "${i}" -af aformat=s16:44100 "${i%.*}.flac"; done
}

# wav to mp3
function wav2mp3() {
  if ! [[ -x "$(command -v ffmpeg)" ]]; then
    echo 'Error: ffmpeg is not installed. please install with (brew install ffmpeg)' >&2
    exit 1
  fi

  for i in *.wav; do ffmpeg -i "${i}" "${i%.*}.mp3"; done
}

# * to *
function mediaconv() {
  if ! [[ -x "$(command -v ffmpeg)" ]]; then
    echo 'Error: ffmpeg is not installed. please install with (brew install ffmpeg)' >&2
    exit 1
  fi

  if [[ "$#" -lt 2 ]]; then
    echo "Usage: mediaconv <ext1> <ext2>"
  fi

  for i in *."$1"; do ffmpeg -i "${i}" "${i%.*}.$2"; done
}

function whoruns() {
  # shellcheck disable=SC2009
  ps -oe user,comm | grep "$1"
}

##############################################################

## load additional functions broken out into own files
# shellcheck disable=SC1091
if [[ -f "${HOME}"/.functions_about ]]; then source "${HOME}"/.functions_about; fi
# shellcheck disable=SC1091
if [[ -f "${HOME}"/.functions_extras ]]; then source "${HOME}"/.functions_extras; fi

## load private, non-tracked, functions
# shellcheck source=/dev/null
if [[ -f "${HOME}"/.functions_priv ]]; then source "${HOME}"/.functions_priv; fi