###########################
#### Function Definitions #
###########################
## Selfupdate
function dotfiles_selfupdate
{
    (. $DOTFILES/check_for_update.sh && _upgrade_dotfiles)
}

## get cheat sheets for commands from cheat.sh. Usage: cheat commandname
function cheat
{
    curl "https://cheat.sh/$1"
}
# get cheat sheets for commands matching $1
function cheatall
{
    curl "https://cheat.sh/~$1"
}

# List all docker tags for an image
function dockertags
{
    if [[ -z $(command -v jq) ]]; then
        echo "jq not installed. Please install jq." 1>&2
        return
    fi
    i=0
    while [[ $? == 0 ]]; do
       i=$(($i+1))
       curl "https://registry.hub.docker.com/v2/repositories/library/$1/tags/?page=$i" 2>/dev/null | jq '."results"[]["name"]'
    done
}

# watch with grc enabled
function watchgrc
{
    watch -n 1 -c grc --colour=on "$@"
}

## Simple calculator. Usage: calc 1+1, calc 5/7, calc "sqrt(2)"
function calc
{
    awk "BEGIN { print $* }"
}

## Make new directory and cd to that directory. Usage: mcd newfolder
function mcd
{
    mkdir -p "$1"
    cd $1
}

## Print full path of item in current directory
function ppath
{
    echo "$PWD/$1"
}

## Color string with given color. Usage: color $colorname "string", available colors in colors.sh
function color
{
    color=$1
    set -x
    shift 1
    echo -e "$"$color"$@${CLEAR}\n"
    set +x
}


## These functions return a colored version of the input string. Usage: red "string"
function red
{
    echo -e "$Red$@$CLEAR"
}
function green
{
    echo -e "$Green$@$CLEAR"
}
function blue
{
    echo -e "$Blue$@$CLEAR"
}

## Flashes the screen until user presses a key
function flasher
{
    while true; do printf "\e[?5h\007"; sleep 0.25; printf "\e[?5l"; read -s -n -t1 && break; done;
}

## Beep until user presses a key
function beeper
{
    while true; do printf "\e[?5h\007"; sleep 0.25; printf "\e[?5l"; read -s -n -t1 && break; done;
}


## Simple http server for current directory (or path)
function httpserver
{
    (
        if [[ -d $1 ]]; then
            cd "$1" && echo "Starting webserver in $(realpath $1)/" || echo "directory: $1 does not exist" >&2 || exit 1
        else
            echo "Starting webserver in $PWD/"
        fi
        open "http://localhost:8000" &>/dev/null &
        if [[ "$(command -v python3)"  ]]; then
            python=python3
        else
            python=python
        fi
        $python -m http.server 8000
    )
}
alias webserver='httpserver'

## Upload something using the 0x0.st service. Usage: upload [filename|url]
function upload
{
    local url
    if echo "$@" | grep -E -s -q "^http[s]://"; then
        url=true
    fi
    if [[ $url == true ]]; then
        out="$(curl -F"url=$@" https://0x0.st)"
    else
        out=$(curl --progress-bar -F"file=@$@" "https://0x0.st/")
    fi
    if [[ $? -ne 0 ]]; then
        echo -e "Failed uploading $@:\n $out" >&2
        return
    fi

    echo -e "Done, file at:\t$out"
    if [[ $(uname) == "Darwin" ]]; then
        clipboard="pbcopy"
    elif command -v wl-copy; then
        clipboard="wl-copy"
    elif command -v xclip; then
        clipboard="xclip"
    else
        clipboard="cat"
    fi
    echo -n"$out" | $clipboard
}

## If connecting through ssh and reverse forwarding port 2222 (ssh -R 2222:localhost:22 ), this function allows to copy the files back to the machine one is connecting from by typing 'mecp filename' (configure the username for "localhost" in ~/.ssh/config or add an username)
function mecp
{
    rsync -r -P -e "ssh -p 2222" -R "$@" localhost:~/Desktop/
}


## generate a password using pwgen, generate_password 20 generates a 20 characters long password
function generate_password
{
    pwgen -1sycn $1
}

## Generate a password from dev urandom using only printable characters
function genpwd
{
    if [[ $1 ]]; then
        strlen=$1
    else
        strlen=32
    fi
    # All characters excluding backlash
    env LC_CTYPE=C tr -dc '[:graph]\' < /dev/urandom | fold -w $strlen | head -n 1
}


if [[ "$(uname)" == "Darwin" ]]; then
    ## Copy output of previous command to termbin.com (command line pastebin) and put in in clipboard
    function termbin
    {
        nc termbin.com 9999 | pbcopy &&  echo -n "$(pbpaste) --> in clipboard"
    }
else
    ## Copy output of previous command to termbin.com (command line pastebin)
    function termbin
    {
        nc termbin.com 9999
    }
fi

## List defined functions in $DOTFILES/functions.sh
function list_functions
{
    grep --color=no -A 1 '^##' $DOTFILES/functions.sh | sed -E 's/function (.*)/\1/g'
}


###########################
## MAC SPECIFIC           #
###########################

if [[ "$(uname)" == "Darwin" ]]; then
## Create a RAM disk. Default size 1GB. If supplied, first argument defines the RAM disk size in GB
function ramdisk
{
    if [[ -e $1 ]]; then
        sizeingb=$1
    else
        sizeingb=1
    fi

    # Numsectors is size in bytes / 512 (sector size in bytes)
    name='RAM_disk'
    sizeinbytes=$(($sizeingb*1000**3))
    NUMSECTORS=$(($sizeinbytes/512))
    mydev=$(hdiutil attach -nomount ram://$NUMSECTORS )
    # strip whitespace (hdiutil outputs a lot of spaces/tabs along with the device name)
    mydev=$(echo "$mydev"| xargs echo)
    newfs_hfs "$mydev"
    mkdir -p "/tmp/$name"
    mount -t hfs "$mydev" "/tmp/$name"
    echo "RAM Disk mounted: /tmp/$name"
    echo "To eject (destroy) RAM disk, use:"
    echo "  $ diskutil eject $mydev"
}

## Open a pdf version of the man in Preview
function man2pdf
{
    man -t "$1" | open -f -a Preview
}

## Open Man in separate (different-looking) window
function nman
{
    if [ $# -eq 1 ] ; then
        open "x-man-page://$1"
    elif [ $# -eq 2 ] ; then
        open "x-man-page://$1/$2"
    fi
}
fi

### end of mac-specific functions

pipupdate(){
    set -x
    if [[ "$1" == "user" ]]; then
        user_flags='--user'
        shift
    fi
    if [[ -n "$@" ]]; then
        pip="$1"
        shift
        flags="$*"
        echo "pip command is: '$pip $flags'"
        if ! command -v "$pip" ; then
            echo "Given command ($1) does not exist." 1>&2
            return
        fi

    else
        pip='python'
        flags='-m pip'
        echo "Using default pip: $pip $flags"
    fi

    for package in $($pip $flags freeze $user_flags --local | grep -v '^\-e' | cut -d = -f 1) ; do
        $pip $flags install "$user_flags" -U "$package"
    done
    set +x
}

# unzip file to directory with the same name of the zip file (without extension)
function unzipd {
    zip_file="$1"
    filename=$(basename -- "$zip_file")
    extension="${filename##*.}"
    name="${filename%.*}"
    unzip -d "$name" "$zip_file"
}

# remove local branches which have been merged into master
function git_prune_branches(){
    git branch --merged master | grep -v '^[ * ]*master$' | xargs git branch -d
}

fvim() {
    if [[ -n "$@" ]]; then
        vim `fzf -q $@`
    else
        vim `fzf`
    fi
}

# retry command until it succeeds (waiting one second or $RETRY_INTERVAL)
function retry() {
    local _retry_interval
    if [[ -z "$RETRY_INTERVAL" ]]; then _retry_interval=1; else _retry_interval=$RETRY_INTERVAL; fi
    until $@; do sleep $RETRY_INTERVAL; done
}

# Creats a gitignore for the given argument (e.g. python, cpp, etc)
function gi() { curl -sL https://www.toptal.com/developers/gitignore/api/$@; }

# Runs git log with fzf with preview
compdef _git fgitlog=git-log
function fgitlog() {
    git log --oneline $@ | fzf --multi --preview 'git -p show --color=always {+1}' --preview-window=right,60%
}

compdef _git fgitlog=git-log
git-commit-show() {
    git log --graph --color=always --format="%C(auto)%h%d %s %C(black)%C(bold)%cr" |
        fzf --ansi --no-sort --reverse --tiebreak=index --preview \
            'f() {
                set -- $(echo -- "$@" | grep -o "[a-f0-9]\{7\}")
                [ $# -eq 0 ] || git show --color=always $1
            }
            f {}' \
            --bind "j:down,k:up,alt-j:preview-down,alt-k:preview-up,ctrl-f:preview-page-down,ctrl-b:preview-page-up,q:abort,ctrl-m:execute:
                (grep -o '[a-f0-9]\{7\}' | head -1 |
                xargs -I % sh -c 'git show --color=always % | less -R') << 'FZF-EOF'
                {} FZF-EOF" \
            --preview-window=right:60%
}

# dotfiles user functions
if [[ -f $HOME/.dotfiles_functions ]]; then
    source "$HOME/.dotfiles_functions"
fi