my

#!/usr/bin/env bash

set -o errexit  # exit on fail
set -o pipefail # catch errors in pipelines
set -o nounset  # exit on undeclared variable
# set -o xtrace    # trace execution

buku_tags() {
    requires buku sed grep sort fzf cut tr

    buku --np --stag |
    sed 's/.* \([^ ]*\) (\(.*\))/\2 \1/' |
    grep --invert-match --regexp='^[[:space:]]*$' --regexp=' date:' |
    sort --numeric-sort |
    fzf \
        --height "${FZF_TMUX_HEIGHT:-40%}" \
        --multi \
        --bind=ctrl-r:toggle-sort \
        --with-nth 2.. \
        --delimiter=' ' \
        --no-sort \
        --exact |
    cut -d' ' -f2- |
    tr '\n' ','
    echo
}

http_publish() {
    requires ngrok tunnelto

    local port=$1

    if command -v ngrok >/dev/null; then
        ngrok http -host-header="localhost:8080" "${port}"
    elif command -v tunnelto >/dev/null; then
        tunnelto --port "${port}"
    fi
}

bios_or_efi() {
    requires

    [ -d /sys/firmware/efi ] && echo UEFI || echo BIOS
}

fb() {
    requires buku fzf

    # save newline separated string into an array
    mapfile -t website <<< "$(buku -p -f 5 | column -ts$'\t' | fzf --multi)"
    # open each website
    for i in "${website[@]}"; do
        index="$(echo "$i" | awk '{print $1}')"
        buku -p "$index"
        buku -o "$index"
    done
}

#################################################
# LIST PACKAGES INSTALLED INTO PIPX
#
list_pipx_requirements() {
    requires pipx grep sed

    pipx list |
        grep '   package' |
        sed 's/   package \(.*\) \(.*\), Python.*/\1==\2/g'
}

#################################################
# LIST AVAILABLE `$TERM` VARIABLES
#
list_available_terms() {
    requires infocmp

    infocmp -D | while read -r dir_with_terminals; do
        find "${dir_with_terminals}" -type f -mindepth 2 -exec basename {} \;
    done
}

#################################################
# GET TEXT FROM PREFERRED EDITOR
#
# Get user input with $EDITOR and
#     spit it to stdout.
#
editor_to_stdout() {
    requires cat

    tmp_file=$(mktemp)
    trap 'rm -rf ${tmp_file}' EXIT

    ${EDITOR} "${tmp_file}"

    if [ -s "${tmp_file}" ]; then
        cat "${tmp_file}"
    else
        exit 1
    fi
}

#################################################
# WEATHER FORECAST
#
# Show weather in two representations:
#    a graph and pictures with texts.
#
weather() {
    requires finger head curl

    # weather graph
    cyan_bg=$(tput setab 6)
    nc=$(tput sgr0)

    finger "tbilisi~$(tput cols)@graph.no" |
        head --lines=-1 |
        sed \
            -e "s/ SW/  ↙/g" \
            -e "s/ SE/  ↘/g" \
            -e "s/ NW/  ↖/g" \
            -e "s/ NE/  ↗/g" \
            -e "s/  S/  ↓/g" \
            -e "s/  N/  ↑/g" \
            -e "s/  W/  ←/g" \
            -e "s/  E/  →/g" \
            -e "s/| Rain/${cyan_bg}&${nc}/g" -e "s/ | /${cyan_bg}&${nc}/g" \

    # empty line to divide graph and images weather representations
    printf '\n'

    # get preferred language (default: 'en')
    if [[ ${LANG} =~ .*\.UTF-8 ]]; then
        lang=${LANG:0:2}
    else
        lang='en'
    fi

    # get weather in ASCII pics
    curl --silent --ipv4 --header "Accept-Language: ${lang}" wttr.in |
        head --lines=-1
}

#################################################
# SHOW WORLD MAP IN CONSOLE
#
map() {
    requires telnet

    telnet mapscii.me
}

#################################################
# SPEEDTEST
#
speedtest() {
    requires curl python

    curl --silent 'https://raw.githubusercontent.com/sivel/speedtest-cli/master/speedtest.py' |
        python -
}

#################################################
# SHOW PACKAGE DEPENDENCIES AS A GRAPH
#
# ARGUMENTS: package name
#
graph_dependencies() {
    requires apt-rdepends dot feh

    package=$1

    apt-rdepends --dotty "${package}" |
        dot -Tpng |
        feh --auto-zoom --scale-down -
}

#################################################
# SHOW INFO ON DISKS
#
# List block devices
#   and eport disk space usage
#
disks() {
    requires lsblk df

    printf '╓───── m o u n t . p o i n t s              \n'
    printf '╙────────────────────────────────────── ─ ─ \n'
    lsblk --all

    printf '                                            \n'

    printf '╓───── d i s k . u s a g e                  \n'
    printf '╙────────────────────────────────────── ─ ─ \n'
    df --human-readable
}

#################################################
# PRINT CURRENT KEYBOARD LAYOUT (US/RU)
#
# Source: https://unix.stackexchange.com/a/28347
#
current_layout_indicator() {
    requires xset grep cut

    led=$(xset -q | grep --after-context=0 'LED' | cut --characters=59-67)

    case ${led} in
    '00000000') printf 'US\n' ;;
    *) printf 'RU\n' ;;
    esac
}

#################################################
# SHOW INSTALLED PACKAGES WITH THEIR DESCRIPTION
#
# Source: https://askubuntu.com/questions/2389
#         https://stackoverflow.com/a/20639730
#         https://stackoverflow.com/a/22439016
#
show_installed() {
    requires curl sed apt-mark comm zsh tr apt-cache grep dpkg

    preinstalled=$(
        source /etc/os-release
        curl --silent "https://releases.ubuntu.com/$(
            [[ ${VERSION_ID} == 20.04 ]] && printf '20.04/ubuntu-20.04'
            [[ ${VERSION_ID} == 18.04 ]] && printf '18.04/ubuntu-18.04.4'
        )-live-server-amd64.manifest" |
        sed 's|\([^[:space:]:]*\).*|\1|g'
    )
    manual=$(
        apt-mark showmanual
    )
    manual_no_preinstalled=$(
        comm -23 <(sort --unique <<<"${manual}") <(sort --unique <<<"${preinstalled}")
    )
    completions=$(
        zsh -i -c 'for key val in ${(kv)_comps}; echo "${key} ${val}"'
    )
    packages_regex=$(
        tr '\n' '|' <<<"${manual_no_preinstalled}"
    )
    descriptions=$(
        apt-cache search "^(${packages_regex})$" |
        grep --extended-regexp "^(${packages_regex}) - "
    )

    # Color print
    red='\033[0;31m'
    green='\033[0;32m'
    grey='\033[0;37m'
    nc='\033[0m'

    while read -r package; do
        # Print package description
        description=$(
            grep "^${package} - " <<<"${descriptions}" |
            cut -d' ' -f2-
        )
        printf "${red}%s${nc} %s" "${package}" "${description} ["

        # Binaries provided by this package
        binaries=$(
            dpkg --listfiles "${package}" |
            { grep --extended-regexp '/bin/|/sbin/' || true; } |
            sed 's|.*/||'
        )

        # Print completions for each binary
        while read -r binary; do
            # If completion exists, print in green
            if grep "^${binary} " <<<"${completions}" >/dev/null; then
                printf "${green}%s${nc}," "${binary}"
            # otherwise print in red
            else
                printf "${grey}%s${nc}," "${binary}"
            fi
        done <<<"${binaries}"

        printf "]\n"

    done <<<"${manual_no_preinstalled}"
}

#################################################
# DOWNLOAD ALL ATTACHMENTS FROM 4CHAN THREAD
#
# ARGUMENTS: boardname, threadnumber
# Download all attachments found in 4chan thread
#
save_4chan_thread_imgs() {
    requires mkdir lynx grep uniq xargs wget

    pagename="${1}_${2}"
    # Create folder for downloading; fail if already downloaded/exists
    mkdir "$pagename"
    # Get all links on the thread page
    lynx -listonly -nonumbers -dump "http://boards.4chan.org/${1}/thread/${2}/" |
        # Filter links pointing to jpg images
        grep '.jpg$' | uniq |
        # Asynchronously download images into the folder
        xargs -I{} --max-args=1 --max-procs=8 \
            wget --no-verbose --directory-prefix="$pagename" "{}"
}


#################################################
# DOWNLOAD RANDOM IMAGE FROM /R/WALLPAPER
#
# Saves a random .jpg wallpaper to file and prints
#     the file name back.
# Returns non-zero exit code on fail.
#
random_reddit_image() {
    requires mktemp lynx grep shuf xargs

    tmp_file=$(mktemp /tmp/XXXXXXXX.jpg)

    post_link=$(lynx -listonly -nonumbers -dump 'https://www.reddit.com/r/wallpaper/' |
        grep 'wallpaper/comments/' |
        sort -u |
        shuf -n 1)

    img_link=$(lynx -listonly -nonumbers -dump "${post_link}" |
        grep 'i\.redd\.it')

    wget --quiet --output-document="${tmp_file}" "${img_link}"

    echo "${tmp_file}"
}

#################################################
# SHARE TCP PORT VIA SERVEO.NET
#
# ARGUMENTS: port
# Reconnect to serveo.net on ssh disconnect.
#
serveo() {
    requires ssh sleep

    port=$1

    while true; do
        ssh -R "80:localhost:${port}" serveo.net
        # Break if normally exit, or exit by Ctrl+C
        # shellcheck disable=SC2181
        if [[ $? == 255 || $? == 0 ]]; then
            break
        else
            sleep 1
        fi
    done
}

#################################################
# UPGRADE SYSTEM
#
full_upgrade() {
    requires sudo apt git zsh

    # Update apt packages
    sudo -- sh <<EOF
        if command -v apt >/dev/null; then
            apt update
            apt upgrade --yes
            apt autoremove --yes
        fi
        if command -v nix >/dev/null; then
            nix-channel --update
            nix-env -u '*'
        fi
        # if command -v guix >/dev/null; then
        #     guix pull
        #     guix package -u
        # fi
EOF
    # Update dotfiles
    if [[ -d ~/.dotfiles ]]; then
        git --git-dir="${HOME}/.dotfiles/.git/" pull origin master
        ~/.dotfiles/install
    fi
    # Update private dotfiles
    if [[ -d ~/.dotfiles-private ]] && command -v run_keybase >/dev/null; then
        run_keybase -g
        git --git-dir="${HOME}/.dotfiles-private/.git/" pull keybase master
        ~/.dotfiles-private/install
        run_keybase -k || true
    fi
    # Update zsh modules for zinit
    if command -v zinit >/dev/null; then
        zsh -i -c -- 'zinit self-update; zinit update --all'
    fi
    # Update zsh modules for zpm
    if command -v zpm >/dev/null; then
        rm -rf ~/.cache/zpm/ /tmp/zsh-${UID}
        zsh -i -c -- ''
    fi
    # Update poetry
    if command -v poetry >/dev/null; then
        poetry self update || true
    fi
    # Upgrade pip and pipx
    if command -v pip >/dev/null &&
       pip freeze |grep -q pipx 2>/dev/null; then
        pip install --user --upgrade pip
        pip install --user --upgrade pipx
    fi
    # Upgrade pipx packages
    if command -v pipx >/dev/null; then
        # if [[ $(printf "%03d%03d%03d" $(pipx --version |tr '.' ' ')) -gt 000016000 ]] &&
        #    command -v jq xargs >/dev/null; then
        #     pipx list --json 2>/dev/null |
        #     jq -r '.venvs | keys | .[]' |
        #     xargs --no-run-if-empty -L1 -P8 pipx upgrade
        # else
            pipx upgrade-all
        # fi
    fi
    # Upgrade nix packages
    if command -v nix >/dev/null; then
        nix-channel --update
        nix-env -u '*'
    fi
    # # Upgrade guix packages
    # if command -v guix >/dev/null; then
    #     guix pull
    #     guix package -u
    # fi
    # Update brewed packages
    if command -v brew >/dev/null; then
        brew update
        brew upgrade
    fi
    # Update nnn plugins
    if command -v nnn >/dev/null; then
        sh -c "$(curl -Ls https://raw.githubusercontent.com/jarun/nnn/master/plugins/getplugs)"
    fi
}

#################################################
# FULL SYSTEM CLEANUP
#
full_clean() {
    requires sudo apt journalctl

    sudo -- sh <<EOF
        if command -v apt >/dev/null; then
            apt autoremove --yes
            apt clean
        fi
        if command -v journalctl >/dev/null; then
            journalctl --rotate
            journalctl --vacuum-time=1s
        fi
        if command -v nix >/dev/null; then
            nix-store --gc
            nix-store --optimise
            nix-collect-garbage --delete-old
        fi
        if command -v docker >/dev/null; then
            docker system prune --force --all
            docker volume rm \$(docker volume ls -q) || true
        fi
        if command -v podman >/dev/null; then
            podman system prune --all --force && podman rmi --all
        fi
EOF
    # Garbage-collect nix
    if command -v nix >/dev/null; then
        nix-store --gc
        nix-store --optimise
        nix-collect-garbage --delete-old
    fi
    # Garbage-collect guix
    if command -v guix >/dev/null; then
        guix gc --delete-generations=1m
    fi
    # # Cleanup unused linuxbrew packages
    # if command -v brew >/dev/null; then
    #     (
    #         cd /tmp
    #         brew bundle dump
    #         brew bundle --force cleanup
    #         mv Brewfile Brewfile.used
    #     )
    # fi
    if command -v brew >/dev/null; then
        brew cleanup --prune=1 -s
    fi
    # Clean sublime text 3 backups
    if [[ -d ~/.config/sublime-text-3/Backup ]]; then
        rm -rf ~/.config/sublime-text-3/Backup
    fi
}

#################################################
# SET BACKGROUND IMAGE
#


set_bg_random() {
    requires wallpaper shuf

    wallpaper "$(shuf --echo --head-count=1 "${HOME}/0files/imgs/wallpapers"/*)"
}

#################################################
# LOGOUT PROMPT FOR I3 AND DMENU
#
# Using dmenu ask if user wants to logout
#     and exit i3 on "yes" answer
# Source: https://github.com/bookercodes/dotfiles/blob/ubuntu/.i3/scripts/exit_menu
#
i3_exit_menu() {
    requires dmenu i3-msg

    while true; do
        select=$(
            printf "NO\nYES" |
            if command -v rofi >/dev/null; then
                rofi -dmenu -i -p "Are you sure you want to logout?"
            else
                dmenu -fn style=bold:pixelsize=22 -i -p "Are you sure you want to logout?"
            fi
        )
        [[ ${select} = "NO" ]] && exit 0
        [[ ${select} = "YES" ]] && i3-msg exit
    done
}

#################################################
# SEARCH SELECTED TEXT IN A SEARCH ENGINE
#
surfraw_pick_elvi() {
    requires surfraw

    local elvi_names;
    local picked_elvi;
    local clipboard;

    clipboard=$(xclip -selection primary -out)
    if [[ -z "${clipboard}" ]]; then
        exit 1
    fi

    elvi_names=$(
        find ~/.config/surfraw/elvi/ /usr/lib/surfraw/ \
            -type f -printf "%f\n" 2>/dev/null |

        while IFS= read -r elvi; do
            case "${elvi}" in
                 google )     printf "9 %s\n" "${elvi}" ;;
                 searx )      printf "8 %s\n" "${elvi}" ;;
                 yandex )     printf "7 %s\n" "${elvi}" ;;
                 duckduckgo ) printf "6 %s\n" "${elvi}" ;;
                 * )          printf "0 %s\n" "${elvi}" ;;
            esac
        done |

        sort --key=1 --numeric-sort --reverse |
        cut --delimiter=' ' --fields=2- |
        uniq
    )

    picked_elvi=$(
        printf "%s" "${elvi_names}" |
        if command -v rofi >/dev/null; then
            rofi -dmenu -i -p "Engine"
        else
            dmenu -fn style=bold:pixelsize=22 -i -p "Engine"
        fi
    )

    surfraw "${picked_elvi}" "${clipboard}"
}

#################################################
# FIX CORRUPTED ZSH HISTORY FILE
#
# Backup copy is placed into ~/.zsh_history_bad
#
fix_zsh_history() {
    requires mv strings zsh

    mv "${HOME}/.zsh_history" "${HOME}/.zsh_history_bad"
    strings "${HOME}/.zsh_history_bad" >"${HOME}/.zsh_history"
    zsh -c 'fc -R "${HOME}/.zsh_history"'
}

#################################################
# FULL SCREEN HORIZONTAL LINE
#
hr() {
    requires tr

    printf '%*s\n' "${COLUMNS:-$(tput cols)}" '' | tr ' ' '-'
}

#################################################
# UPLOAD FILE TO TRANSFER.SH
#
# ARGUMENTS: filename to upload (or stdin stream)
# Uploads file and prints download link
#
transfer() {
    requires curl sed tty

    tmp_file=$(mktemp /tmp/transfer_XXXXXXXX)
    trap 'rm ${tmp_file}' EXIT

    # Help. In case no arguments specified
    if [[ $# == 0 ]]; then
        echo "No arguments specified. Usage:"
        echo "$ transfer /tmp/test.md"
        echo "$ cat /tmp/test.md | transfer test.md"
        exit 1
    fi

    # Upload either from file or stdin
    if tty -s; then
        basefile=$(basename "${1}" | sed -e 's/[^a-zA-Z0-9._-]/-/g')
        curl --progress-bar --upload-file "${1}" "https://transfer.sh/${basefile}" >>"${tmp_file}"
    else
        curl --progress-bar --upload-file "-" "https://transfer.sh/${1}" >>"${tmp_file}"
    fi

    # Print download link
    cat "${tmp_file}"
    echo
}

#################################################
# PRINT MOST FREQUENTLY USED COMMANDS
#
# Also prints how much each command is used.
#
most_used_commands() {
    requires zsh awk grep column sort nl head

    zsh --login -c "HISTFILE=~/.zsh_history; HISTSIZE=999999999; fc -R; history 0" |
        awk '{CMD[$2]++;count++;}END { for (a in CMD)print CMD[a] " " CMD[a]/count*100 "% " a;}' |
        grep -v "./" |
        column -c3 -s " " -t |
        sort -nr |
        nl |
        head -n30
}

#################################################
# INSTALL PACKAGE BY URL
#
# ARGUMENTS:
#     url_link
#     string of requirements e.g. 'zsh,sudo,gnupg'
#     package name
#     package version
#     command to run before running make
# Download an application, create a package and install it.
#
install_from_web() {
    requires mktemp cd git wget tar sudo checkinstall apt

    lnk=$1
    dependencies=$2
    pkgname=$3
    pkgversion=$4
    run_script=$5

    # Create temporary directory for package source files
    # and schedule it's autoclean
    tmp_dir=$(mktemp -d /tmp/XXXXXXXX)
    trap 'cd -; sudo rm -r ${tmp_dir}' EXIT
    cd "${tmp_dir}"

    # Download git repository
    if [[ ${lnk} =~ .*\.git$ || ${lnk} =~ https://git\..* || ${lnk} =~ http://git\..* ]]; then
        git clone "${lnk}" .
    # ... or download and unpack .tar.gz
    elif [[ ${lnk} =~ .*\.tar\.gz$ ]]; then
        wget --output-document=- "${lnk}" |
            tar --extract --gzip --file=- --strip-components=1
    # ... or download and install .deb. Then exit
    elif [[ ${lnk} =~ .*\.deb$ ]]; then
        wget --output-document="./package.deb" "${lnk}"
        sudo apt install --quiet "./package.deb"
        exit 0
    # ... or print error message
    else
        echo "This is a link to wtf?" >&2
        exit 1
    fi

    # Run custom script before compiling with make
    eval "${run_script}"

    # Create a .deb package
    sudo checkinstall -D \
        --install=no \
        --default \
        --requires "${dependencies}" \
        --pkgname "${pkgname}" \
        --pkgversion "${pkgversion}" | cat

    # Install .deb package with all dependencies
    sudo apt install ./"${pkgname}"_*.deb
}

#################################################
# REMOVE A SOFTWARE
#
remove_package() {
    requires lynx grep sed tar ln

    x=$1

    case $x in
    'kiss')
        rm -rf "${HOME}/bin/kiss" \
            "${HOME}/packages" \
            "${HOME}/.kiss" || true
        ;;
    'tor-browser')
        unlink "${HOME}/bin/tor-browser" || true
        rm -rf "${HOME}/opt/tor-browser/" || true
        ;;
    *)
        exit 1
        ;;
    esac
}

#################################################
# INSTALL A SOFTWARE
#
install_package() {
    requires lynx grep sed tar ln

    x=$1

    case $x in
    'kiss')
        link=$(lynx -listonly -nonumbers -dump 'https://github.com/kisslinux/kiss/releases/latest' |
            grep '\.tar\.gz$')
        wget --output-document=- "${link}" |
            tar --extract --gzip --file=- --directory="${HOME}/bin/" --strip-components=1
        mkdir "${HOME}/packages"
        git clone 'https://github.com/kisslinux/repo.git' "${HOME}/packages/kisslinux_repo"
        ;;
    'autobench')
        link=$(lynx -listonly -nonumbers -dump 'http://www.xenoclast.org/autobench/' |
            grep '\.deb$' | sed -n 1p)
        install_from_web "$link" '' '' '' ''
        ;;
    'tor-browser')
        url=$(lynx -listonly -nonumbers -dump 'https://github.com/TheTorProject/gettorbrowser/releases/latest' |
            grep 'linux64.*_en-US.tar.xz$')
        mkdir --parents "${HOME}/opt/tor-browser/"
        wget --output-document=- "$url" |
            tar --extract --xz --file=- --directory="${HOME}/opt/tor-browser/" --strip-components=2
        ln --symbolic "${HOME}/opt/tor-browser/start-tor-browser" "${HOME}/bin/tor-browser" 2>/dev/null || true
        ;;
    'grv')
        lnk=$(lynx -dump -nonumbers -listonly 'https://github.com/rgburke/grv/releases' |
            grep 'grv_.*_linux64$' |
            sed 1q)
        wget --output-document="${HOME}/bin/grv" "${lnk}"
        chmod u+x "${HOME}/bin/grv"
        ;;
    *)
        exit 1
        ;;
    esac
}

#################################################
# RUN JACKETT - A TORRENTS TORRENT SCRAPER
#
jackett() {
    requires docker

    downloads_dir=${HOME}/Downloads
    mkdir --parents "${downloads_dir}"

    docker run \
        -ti --rm \
        --name=jackett \
        -v "${HOME}/.config/Jackett/Indexers":/config/Jackett/Indexers:rw \
        -v "${downloads_dir}":/downloads \
        -e PGID="$(id -g)" \
        -e PUID="$(id -u)" \
        -e TZ="$(cat /etc/timezone)" \
        -v /etc/localtime:/etc/localtime:ro \
        -p 9117:9117 \
        linuxserver/jackett
}


#################################################
# CHECK IF ALL REQUIREMENTS ARE MET
#
requires() {
    # Run only if debug variable set
    if [[ -n "${MY_DEBUG:-}" ]]; then
        not_installed=''
        for dependency in "${@}"; do
            if ! command -v "${dependency}" >/dev/null; then
                not_installed="${not_installed} ${dependency}"
            fi
        done
        if [[ -n "${not_installed}" ]]; then
            printf "No required dependencies installed: %s\n" "${not_installed}"
            exit 127
        fi
        exit 0
    fi
}

#################################################
# CHECK WHAT REQUIREMENTS OF WHAT FUNCTIONS ARE MISSING
#
check_dependencies() {
    # Get functions defined in this file
    _list_functions |
        # Check each of the rest functions' dependencies
        while IFS= read -r func; do
            if ! MY_DEBUG=1 my "${func}" &>/dev/null; then
                echo "Testing ${func}() failed:"
                MY_DEBUG=1 my "${func}" || true
            fi
        done
}

#################################################
# LIST FUNCTIONS IN THIS FILE
#
_list_functions() {
    # Get functions defined in this file
    declare -f | grep '^[a-zA-Z0-9_]*\s()' | cut -f 1 -d ' ' |
        # Drop functions we do not want to publicly list
        grep -v -e 'check_dependencies' -e 'requires' -e '^_.*'
}


"$@"