functions

#!/bin/bash -eu

# FIXME: All functions here need to be updated to use `local` variables.

# Create properties easily for PekWM.
propstring () {
    echo -n 'Property '
    xprop WM_CLASS | sed 's/.*"\(.*\)", "\(.*\)".*/= "\1,\2" {/g'
    echo '}'
}

# Back up an entire domain very quickly.
quick-warc() {
    if [ -f "$1".warc.gz ]; then
        echo "$1.warc.gz already exists"
    else
        wget --warc-file="$1" --warc-cdx --mirror --page-requisites \
        --no-check-certificate --restrict-file-names=windows \
        -e robots=off --waitretry 5 --timeout 60 --tries 5 --wait 1 \
        -U "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27" \
        "http://$1/"
    fi
}

# Create a .7z file from a directory or file in the same directory with
# .7z as the suffix.
mk7z() {
    if [ -z "$1" ]; then
        echo 'Please supply a file' 1>&2
        return 1;
    fi

    src="$(basename "$1")"
    dst="$src".7z

    if [ -f "$dst" ]; then
        echo "$dst already exists" 1>&2
        return 1;
    fi

    7z a "$dst" "$src"
}

# Backup one director to another with rsync.
backup() {
    if [ -z "$1" ] || [ -z "$2" ]; then
        echo 'Usage: backup <src> <dest>' 1>&2
        return 1
    fi

    if [ ! -d "$1" ]; then
        echo "Not a source directory: $1" 1>&2
        return 1
    fi

    if [ ! -d "$2" ]; then
        echo "Not a destination directory: $2" 1>&2
        return 1
    fi

    if [ -n "$3" ]; then
        echo 'You supplied a third argument. Something is probably wrong.' 1>&2
        return 1
    fi

    rsync -auv --delete "$1/" "$2"
}

validate_transcoding_filenames() {
    if [ -z "$1" ]; then
        echo "Not input filename was given!"
        return 1
    fi

    if ! [ -f "$1" ]; then
        echo "Input file does not exist: $1" 1>&2
        return 1
    fi

    if [ -z "$2" ]; then
        echo "Not output filename was given!"
        return 1
    fi

    if [ -d "$2" ]; then
        echo "The output filename is a directory: $2"
        return 1
    fi
}

# Download an MP3 from YouTube, or other sources.
download-mp3() {
    youtube-dl --extract-audio --audio-format mp3 "$1"
}

# Download an AAC file from YouTube, or other sources.
download-aac() {
    youtube-dl --extract-audio --audio-format aac "$1"
}

# Archive a YouTube video, preserving as much as possible.
archive-youtube() {
    youtube-dl -f 'bestvideo[ext!=webm]+bestaudio[ext!=webm]/best[ext!=webm]' \
        --write-info-json --write-thumbnail --add-metadata \
        "$1" \
        -o "./%(uploader)s/%(title)s {%(id)s}.%(ext)s"
}

to_x264_1080p_aac_192k() {
    validate_transcoding_filenames "$1" "$2" && \
    ffmpeg -i "$1" \
    -vcodec libx264 -profile:v high -preset slow \
        -b:v 2000k -maxrate 2000k -bufsize 4000k -vf \
        scale=-1:1080 -threads 0 \
    -acodec aac -b:a 192k -strict -2 \
    "$2"
}

to_x264_720p_aac_128k() {
    validate_transcoding_filenames "$1" "$2" && \
    ffmpeg -i "$1" \
    -codec:v libx264 -profile:v high -preset slow \
        -b:v 1000k -maxrate 1000k -bufsize 2000k -vf \
        scale=-1:720 -threads 0 \
    -codec:a aac -b:a 128k -strict -2 \
    "$2"
}

to_mp4() {
    validate_transcoding_filenames "$1" "$2" && \
    ffmpeg -i "$1" -c:v h264_nvenc -c:a aac -crf 17 "$2"
}

to_ps4_mp4() {
    validate_transcoding_filenames "$1" "$2" && \
    ffmpeg -i "$1" -c:v h264_nvenc -c:a ac3 -crf 17 -level:v 4.2 "$2"
}

to_wav() {
    validate_transcoding_filenames "$1" "$2" && \
    ffmpeg -i "$1" -acodec pcm_s16le -ar 44100 "$2"
}

adfs_xml_url() {
    domain=$(echo "$1" | sed -e 's/^\([a-zA-Z0-9]\+:\/\/\|\)\([^\/]\+\).*/\2/')

    echo "https://$domain/FederationMetadata/2007-06/FederationMetadata.xml"
}

download_adfs_xml() {
    domain=$(echo "$1" | sed -e 's/^\([a-zA-Z0-9]\+:\/\/\|\)\([^\/]\+\).*/\2/')
    url="https://$domain/FederationMetadata/2007-06/FederationMetadata.xml"

    wget --no-check-certificate "$url" -O "${domain}-metadata.xml" || rm -f "${domain}-metadata.xml"
}

# A function for conveniently adding remotes for GitHub forks.
add-github-remote() {
    local new_remote="$1"

    local remote
    for remote in $(git remote -v | awk '{print $1;}'); do
        if [ "$new_remote" == "$remote" ]; then
            echo -n 'We already have: ' 1>&2
            git remote get-url origin 1>&2
            return 1
        fi
    done

    basename="$(basename "$(git config --get remote.origin.url)")"
    git remote add "$new_remote" "git@github.com:${new_remote}/${basename}"
}

# A function for killing processes with confirmation.
killit() {
    if pgrep -af "$1"; then
        echo
        read -p 'Kill these processes? (y/N): ' -r

        if [[ $REPLY =~ ^[Yy]$ ]]; then
            pkill -f "$1"
        fi
    else
        echo 'No processes found.'
    fi
}

wgo() {
    local command="$1"

    case $command in
    list)
        curl -s https://go.dev/dl/ | grep -Eo 'go[0-9]+\.[0-9]+\.[0-9]+' | sort -t "." -k1,1n -k2,2n -k3,3n -u
    ;;
    install)
        if [ $# -ne 2 ]; then
            echo 'Usage: wgo install <version>' 1>&2
            return 1
        fi

        local version="$2"

        if ! [[ "$version" =~ [0-9]+\.[0-9]+\.[0-9]+ ]]; then
            echo "Invalid version: $version" 1>&2
            return 1
        fi

        go install "golang.org/dl/go$version@latest"
        "go$version" download
    ;;
    esac
}

# Completion for the wgo function.
_wgo() {
    # shellcheck disable=SC2034
    local cur prev words cword split
    _init_completion -s || return

    local commands
    commands='list install'

    if [[ $cword -eq 1 ]] ; then # if one argument given
        # shellcheck disable=SC2207
        COMPREPLY=( $( compgen -W "$commands" -- "$cur" ) )
    fi

    # shellcheck disable=SC2128
    [[ $COMPREPLY == *= ]] && compopt -o nospace
    return
}
complete -F _wgo wgo

# A wrapper for Python programs that automatically uses virtualenv.
wrap-python-executable() {
    basename="$1"
    shift 1

    executable=''
    home_executable="$HOME/.local/bin/$basename"

    # Search for possible venv locations.
    for env_dir in .venv venv env ve; do
        if [ -f "$env_dir/bin/$basename" ]; then
            executable="$env_dir/bin/$basename"
            break
        fi
    done

    # Fall back on home executable.
    if [ -z "$executable" ] && [ -f "$home_executable" ]; then
        executable="$home_executable"
    fi

    # Do nothing if we cannot find it.
    if [ -z "$executable" ]; then
        echo "Cannot find $basename!" 1>&2
        return 1
    fi

    "$executable" "$@"
}

# Specific wrappers.
# Using aliases makes them only available to interactive shells.
alias pytest='wrap-python-executable pytest'
alias flake8='wrap-python-executable flake8'
alias isort='wrap-python-executable isort'
alias pre-commit='wrap-python-executable pre-commit'
alias mypy='wrap-python-executable mypy'
alias pyright='wrap-python-executable pyright'

# Django wrappers
alias runserver='wrap-python-executable python manage.py runserver'
alias shell='wrap-python-executable python manage.py shell_plus'
alias dbshell='wrap-python-executable python manage.py dbshell'