.functions

#!/usr/bin/env zsh

# Exists - function to check if command exists
function _exists() { (( $+commands[$1] )) }


# Brew - update 'brew', then upgrade all installed packages, then cleanup and report
if _exists brew; then
	function brewup () {
		brew update --verbose && brew upgrade && brew cleanup
	}
	function brewf () {
		(cd ~ ; brew bundle dump && ria ~/Brewfile)
	}
fi

# UPDATE the important tools
function updatetools () {
	# Ask for the administrator password upfront
	sudo -v
	# Apple softwareupdate
	if _exists softwareupdate; then
		echo "Update App Store apps"
		# sudo softwareupdate -i -a
	fi;

	# Python pip
	# updates pip2 and pip3, and set the latter (pip3) as the default 'pip'
	# Note: now only updating pip3 and ignoring pip2
	#
	# # python3 -m pip install --upgrade pip
	PIPS=("pip")  # was 'pip3' & 'pip2'; include "pip2" for older pip
	for TMPPIP in "$PIPS[@]"
	do
		if _exists ${TMPPIP} ; then
			echo "Update ${TMPPIP}"
			python3 -m ${TMPPIP} install --upgrade pip
		fi;
	done
	unset PIPS

	# Homebrew
	if _exists brew; then
		echo "Update Homebrew (Cask) & packages"
		brew update && brew upgrade && brew cleanup
	fi;

	# Ruby Gems
	export PATH="/usr/local/opt/ruby/bin:$PATH"
	if _exists gem; then
		echo "Update Ruby & gems"
		export LDFLAGS="-L/usr/local/opt/ruby/lib"
		export CPPFLAGS="-I/usr/local/opt/ruby/include"
		export PKG_CONFIG_PATH="/usr/local/opt/ruby/lib/pkgconfig"
		sudo gem update —system && sudo gem update
	fi;

	# Linux apt
	if _exists apt && [ ! $(uname -s) = 'Darwin' ]; then
		echo "Update 'apt' & packages"
		sudo apt update && sudo apt -y full-upgrade && sudo apt install -y unattended-upgrades
	fi;
	# cleanup sudo
	sudo -k

	# NPM
	if _exists npm; then
		echo "Update npm & packages"
		npm install npm -g && npm update -g && npm install -g npm
	fi;
	
	# Rust
	if _exists rustup; then
		echo "Update Rust"
		rustup update
	fi;
	
	# Cargo
	if _exists cargo; then
		echo "Update cargo packages"
		cargo update
	fi;
	
}

# pip upgrade - upgrades all install modules found with pip
function pipupgrade() {
	PIPS=("pip2" "pip3")
	for TMPPIP in "$PIPS[@]"
	do
		if _exists ${TMPPIP}; then
			echo "Upgrade modules for ${TMPPIP}"
			${TMPPIP} freeze --local | egrep -v '^\-e' | cut -d = -f 1 | xargs -n1 sudo -H ${TMPPIP} install --upgrade
		fi;
	done
	unset PIPS
}

# Create a new directory and enter it
function mkd() {
	mkdir -p "$@" && cd "$_";
}

# 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 )) && _exists zopfli; then
		# the .tar file is smaller than 50 MB and Zopfli is available; use it
		cmd="zopfli";
	elif _exists pigs; then
		cmd="pigz";
	else
		cmd="gzip";
	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;
}

# Use Git’s colored diff when available
if _exists git ; 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')";
}

# Start an HTTP server from a directory, optionally specifying the port
function server() {
	local port="${1:-8000}";
	sleep 1 && open "http://localhost:${port}/" &
	# Set the default Content-Type to `text/plain` instead of `application/octet-stream`
	# And serve everything as UTF-8 (although not technically correct, this doesn’t break anything for binary files)
	python -c $'import SimpleHTTPServer;\nmap = SimpleHTTPServer.SimpleHTTPRequestHandler.extensions_map;\nmap[""] = "text/plain";\nfor key, value in map.items():\n\tmap[key] = value + ";charset=UTF-8";\nSimpleHTTPServer.test();' "$port";
}

# Start a PHP server from a directory, optionally specifying the port
# (Requires PHP 5.4.0+.)
function phpserver() {
	local port="${1:-4000}";
	local ip=$(ipconfig getifaddr en1);
	sleep 1 && open "http://${ip}:${port}/" &
	php -S "${ip}:${port}";
}

# 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;
}

# 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;
}

# Normalize `open` across Linux, macOS, and Windows.
# This is needed to make the `o` function (see below) cross-platform.
if [ ! $(/usr/bin/uname -s) = 'Darwin' ]; then
	if grep -q Microsoft /proc/version; then
		# Ubuntu on Windows using the Linux subsystem
		alias open='explorer.exe';
	else
		alias open='xdg-open';
	fi
fi

# `o` with no arguments opens the current directory, otherwise opens the given
# location
function o() {
	if [ $# -eq 0 ]; then
		open .;
	else
		open "$@";
	fi
}

# `tre` is a shorthand for `tree` with hidden files and color enabled, ignoring
# the `.git` directory, listing directories first. The output gets piped into
# `less` with options to preserve color and line numbers, unless the output is
# small enough for one screen.
function tre() {
	tree -aC -I '.git|node_modules|bower_components' --dirsfirst "$@" | less -FRNX;
}

# Separate the grain from the chaff (empty lines or comment lines)
function grain () {
	grep -E -v '^(#|;|$|[ ]*#)' "$@"
}

# checkusers - Cautionary script to check for nefarious hidden users
function checkusers () {
	if [ $(/usr/bin/uname -s) = 'Darwin' ]; then
		lw="/Library/Preferences/com.apple.loginwindow"
		printf "Current users:\n %s\n" $(/usr/bin/users)
		declare -a allowedusers=("daemon","root","nobody","Guest")
		printf "\n%-12s %-5s\n" "User" "ID"
		for i in $(dscl . -list /Users | grep -vE '^_'); do
			if [[ ! "${allowedusers[@]}" =~ "${i}" ]]; then
				k=$(id -u ${i})
				printf "  %-10s %-5s\n" ${i} ${k}
			fi
		done
		printf "\nLogin Window:\n%s\n" "$(defaults read "${lw}")"
	else
		echo "Not yet implemented for $(uname -s)"
	fi
}

# increment a version number
# echo "1.2.3" | inc_version 3 = 1.2.4
# echo "1.2.3" | inc_version 1 = 2.0.0
# from https://gir.st/blog/inc-version.htm
function inc_version() {
        awk -F. -v OFS=. '{ $ver++; while(ver++<NF) $ver=0; print $0 }' ver=$1
}

# ISO-8601 naming
# Rename a file to include the creation date
function rename_iso_append() {
	oldfile=$1
	oldfileroot="${oldfile%.*}"
	oldfiletype="${oldfile##*.}"
	iso="$(gdate -d "$(/usr/bin/stat "${oldfile}" | cut -f2 -d'"')" +"%Y%m%dT%H%M%S%z")"
	case ${oldfile} in 
		*\.* ) mv -v "${oldfile}" "${oldfileroot}-${iso}.${oldfiletype}" ;;
		*    ) mv -v "${oldfile}" "${oldfileroot}-${iso}" ;;
	esac
}
# Convert shortened ISO8601 to readable date
function i82d() {
	echo $1 | gsed -e 's/^\([0-9]\{4\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)T\([0-9]\{2\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\1-\2-\3T\4:\5:\6/'
}
# Convert shortened ISO8601 to epoch seconds
function i82ec () {
	gdate -d"$(i82d $1)" +%s
}

# `mount` with no arguments neatly shows currrent state, 
# otherwise does the requested mount operations
function mount() {
	if [ $# -eq 0 ]; then
		/sbin/mount | column -t ;
	else
		/sbin/mount "$@";
	fi;
}

# Wake On LAN
# ** requires "brew install wakeonlan"
# Get remote server MAC Address
networkfile="${HOME}/Library/system.d/network2309.csv"
function mac_address() {
	if [ $# -eq 0 ]; then
		echo "$0 remoteServerName"
	else
		rhost="$@"
		if grep -q "${rhost}" "${networkfile}" 2> /dev/null ; then
			fnd=("${(s:,:)$(grep "${rhost}" "${networkfile}")}")
			macaddr=${fnd[1]}
			echo "${(U)macaddr}" # ${macaddr} from Network file"
		elif nc -z "${rhost}" 22 2> /dev/null; then
			macaddr=$(ssh "${USER}"@"${rhost}" "ifconfig en0" | grep ether | cut -d' ' -f2)
			echo "${(U)macaddr},${rhost}" >>| ${networkfile}
			echo "${(U)macaddr}" # "${macaddr} Added to Network file for ${rhost}"
		else
			echo "Unknown host ${rhost} not available."
		fi
	fi
}
# wakeup by hostname
function wakeup() {
	rhost="$@"
	if grep -q "${rhost}" "${networkfile}"; then
		macaddr=$(grep "${rhost}" "${networkfile}" | cut -d',' -f1)
		wakeonlan "${macaddr}"
	else
		echo "${rhost} not found in network file. \nUse 'mac_address ${rhost}' to add this."
	fi
}

# time it - time a set of commands
function tit() {
	start=$(gdate +%s.%N)
	"${@}"
	end=$(gdate +%s.%N)
	runtime=$( echo "$end - $start" | bc -l )
	echo "time: ${@}: ${runtime}"

}

# List new files recursively by date created within current directory. Displays relative dates. 
# based on https://gist.github.com/benwoodward/8873c8ad5517ce255ad04bd082979146
# function relative-date() {
#   while read input_string; do
#     local file_path=`echo $input_string | cut -d ' ' -f 5-`
#     local ls_date=`echo $input_string | cut -d ' ' -f 1,2,3,4`
#     # Accepts date in format found in `ls` output, and converts to epoch
#     local date="$(gdate --date="$ls_date" +"%s")"
#     local now="$(gdate +"%s")"
#     local time_diff=$((now - date))

#     if ((time_diff > 48*60*60)); then
#       date_string=`printf "%3.0f days ago" $((time_diff/(24*60*60)))`
#     elif ((time_diff > 60*60)); then
#       date_string=`printf "%3.0f hours ago" $((time_diff/(60*60)))`;
#     elif ((time_diff > 60)); then
#       date_string=`printf "%3.0f minutes ago" $((time_diff/60))`;
#     else
#       date_string=`printf "%3.0f seconds ago" $time_diff`;
#     fi

#     # date_string=${(r:15:)date_string}
#     echo "${(r:15:)date_string}\e[32m$file_path\e[m"
#   done
# }

function relative_date(){
	typeset -A stat
	zstat -H stat $1
	local -i time_diff=$((EPOCHSECONDS - stat[mtime]))
	unset stat
	if ((time_diff > 48*60*60)); then
		printf -v REPLY '%3.0f days ago' $((time_diff/24/60/60))
	elif ((time_diff > 60*60)); then
		printf -v REPLY "%3.0f hours ago" $((time_diff/60/60))
	elif (( time_diff > 60 )); then
		printf -v REPLY "%3.0f minutes ago" $((time_diff/60))
	else
		printf -v REPLY "%3.0f seconds ago" $time_diff
	fi
}
function list-files(){
	setopt extendedglob
	zmodload -F zsh/stat b:zstat
	#zmodload zsh/stat b:zstat
	local -a results
	if ()(($#)) *$1*(NY1-.); then
		results=( *$1*(.om) )
	elif [[ "$1" =~ ^[1-9][0-9]*$ ]]; then
		results=( (^(.git*|.tags*)/)#^(.git*|.tags*)(.om[1,$1]) )
	else
		results=( (^(.git*|.tags*)/)#^(.git*|.tags*)(.om) )
	fi
	for result in $results; do
		local REPLY
		# echo "$result"
		relative_date $result
		# print "${(r:18:)REPLY} \e[32m$result\e[0m"
		print "${(r:16:)REPLY} $result"
		unset REPLY
	done
	unset results
}
	
function list-new-files() {
	if [ -n "$ZSH_VERSION" ]; then
		headn=$1; shift
		for arg in "$@"
		do
			# srch="${(j.,.)@:-.}" # "${@:-.}"
			srch=${arg}'/**/*(.om[1,'${headn}'])'
			[[ $#@ -gt 1 ]] && echo "# ${arg}"
			ls -ltT $~srch | tr -s "\t" ' ' \
				| cut -d' ' -f6- | relative_date 
		done
	elif [ -n "$BASH_VERSION" ]; then
		cmd=( find "${@:-.}" -type f \
		-not \( -wholename './.git*' -prune \) \
		-not \( -wholename './tags*' -prune \) \
		-exec ls -lTU \{\} \; \| rev \| cut -d ' ' -f 1,2,3,4,5 \| rev \
		\| relative_date \
		\| sort -k 1 -r \| rev \| cut -d ':' -f 1,2 \| rev \
		\| sed 's/://g' )
	else
		echo "oops"# asume something else
	fi
}
zle -N list-new-files

function new-files() {
	fdir=()
	headn=10
	for arg in "$@"
	do
		[[ -d "$arg" ]] && fdir+=(${arg}) && echo "dir: ${arg}"
		[[ "${arg}" -gt 0 ]] && headn=${arg} && echo "num: ${arg}"
		shift
	done
	list-new-files "$headn" "$fdir[@]"  
}

function check_cmd() {
	for arg in "$@"
	do
		cmd="${arg}"
		if [ -n "$ZSH_VERSION" ]; then
			# assume Zsh
			(( $+commands[${cmd}] )) && echo "Found command ${cmd}"
		elif [ -n "$BASH_VERSION" ]; then
			# assume Bash
			[ command -v ls &>/dev/null ] && echo "Found command ${cmd}"
		else
			echo "oops"# asume something else
		fi
	done
}

function toggle() {
	case "#1" in
		icon )
			if [ ! $(uname -s) = 'Darwin' ]; then
				mystate=$(defaults read com.apple.finder CreateDesktop)
				case ${mystate} in 
					true  ) flip="false" ;;
					false ) flip="true" ;;
				esac
				defaults write com.apple.finder CreateDesktop ${flip}
				killall Finder
			fi
			;;
		* )
			echo "Unknown toggle" ;;
	esac
}

function downloads() {
	if _exists sqlite3; then
		echo "from the Quarantine Manager : "
		echo "from the Quarantine Manager - $(date +%F) : " >>| $HOME/LSQuarantineEvent.txt
		sqlite3 ~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV* \
			'select LSQuarantineDataURLString from LSQuarantineEvent' \
			| grain | tee >(wc -l) >>| $HOME/LSQuarantineEvent.txt
	fi;
}

function genpassword() {
	local _len=${1:-14}
	local _char=${2:-'!-~'}  # '!-~' includes all printable ASCII, from octal-41 to octal-176, 94 characters
	local _passphrase=""

	local function report() {
		local RED=$(tput setaf 1)
		local GREEN=$(tput setaf 2)
		local YELLOW=$(tput setaf 3)
		local BLUE=$(tput setaf 4)
		local MAGENTA=$(tput setaf 5)
		local CYAN=$(tput setaf 6)
		local BRIGHT=$(tput bold)
		local NORMAL=$(tput sgr0)
		local _color=${RED}
		local _alert="weak"

		echo -n "${(l:12:)1:?"MACHINE"} : ${_passphrase}  "
		local _entropy=$(echo "l(${2:?16}^${_len})/l(2)" | bc -l | tr -d '\n' | xargs -0 printf "%.0f")

		if [ ${_entropy} -gt 150 ]; then
			_color=${BRIGHT}${CYAN}
			_alert="paranoid is good"
		elif [ ${_entropy} -gt 120 ]; then
			_color=${GREEN}
			_alert="strong"
		elif [ ${_entropy} -gt 100 ]; then
			_color=${BLUE}
			_alert="good"
		elif [ ${_entropy} -gt 80 ]; then
			_color=${YELLOW}
			_alert="fair"
		fi
		printf "${_color}% 5.0f${NORMAL} bits of entropy: ${_color}%s${NORMAL}\n" ${_entropy} ${_alert}
	}

	local radix64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
	if [ -e /dev/urandom ]; then
		_passphrase=$(< /dev/urandom tr -dc "${_char}" | head -c ${_len} | xargs -0)
		report urandom $(( 15+10+7+26+6+26+4 ))
	fi
	if (( $+commands[gpg] )); then
		_passphrase=$(gpg --gen-random --armor 1 ${_len} | head -c ${_len} | xargs -0)
		report gpg ${#radix64}
	fi
	if (( $+commands[openssl] )); then
		_passphrase=$(openssl rand -base64 ${_len} | head -c ${_len} | xargs -0)
		report openssl ${#radix64}
	fi
	if (( $+commands[sha256sum] )); then
		_passphrase=$(echo "$(date '+%s')${RANDOM}" | sha256sum -b | base64 | head -c ${_len} | xargs -0)
		report sha256sum $(( 10+26+26 ))
	fi
	
}

function f {
	if (( $+commands[fd] )); then
		fd "${argv[@]:-}"
	else
		hunt="$1" ; shift
		find "${argv[@]:-.}" -iname "*${hunt}*" | grep --color=always -E "${hunt}"  | less -FRNX
	fi
}
function findf {
	hunt="$1" ; shift
	if (( $+commands[fd] )); then
		fd -tf "$hunt" "${argv[@]:-}"
	else
		find "${argv[@]:-.}" -iname "*${hunt}*" -type f | grep --color=always -E "${hunt}"  | less -FRNX
	fi
}
function findd {
	if (( $+commands[fd] )); then
		fd -td "$1" "${argv[@]:-}"
	else
		hunt="$1" ; shift
		find "${argv[@]:-.}" -iname "*${hunt}*" -type f | grep --color=always -E "${hunt}"  | less -FRNX
	fi
}
	
function mydns() {
	networksetup -getdnsservers Wi-Fi
}

function p1ng() {
	# Ping
	ping -c 1 --apple-connect -n -Q ${argv[@]:-localhost}  | sed -n '4p;6p'
}

# Speedtest - brew install speedtest-cli
if _exists speedtest; then
	function testspeed {
		# execute speed test using secure connection and return the numeric results
		speedtest --secure | grep -E '[[:digit:]]+\.*[[:digit:]]+'
	}
fi