#!/usr/bin/env bash
# Fetch info about your system
# https://github.com/dylanaraps/fetch
#
# Required Dependencies:
#   Bash 4.0+
#   Text formatting, dynamic image size and padding: tput
#   [Linux / BSD / Windows] Uptime detection: procps or procps-ng
#
#
# Optional Dependencies: (You'll lose these features without them)
#   Displaying Images: w3m + w3m-img
#   Image Cropping: ImageMagick
#   More accurate window manager detection: wmctrl
#   [ Linux / BSD ] Wallpaper Display: feh or nitrogen
#   [ Linux / BSD ] Current Song: mpc or cmus
#   [ Linux / BSD ] Resolution detection: xorg-xdpyinfo
#
# Created by Dylan Araps
# https://github.com/dylanaraps/

# Speed up script by not using unicode
export LC_ALL=C
export LANG=C
export LANGUAGE=C


# Config Options {{{


# Info Options {{{


# Info
# What to display and in what order.
# You can use ANY bash syntax in the function below!
# For example you could use if statments to only print info
# when a condition is true!
#
# The script comes with two helper functions:
# info:
#       info "subtitle" funcname
# prin:
#       prin "Custom message to print"
#       prin "Subtitle: Custom message to print"
#       prin "Subtitle: $(date)"
#
# You can also just use printf / echo to add lines but you'll
# need to prefix your msg with "${padding}", for example:
# echo -e "${padding} My custom message here"
#
# Info functions enabled by default are:
# "title" "distro" "kernel" "uptime" "packages"
# "shell" "resolution" "windowmanager" "gtktheme"
# "gtkicons" "cpu" "memory" "cols"
#
# Info functions that are disabled by default are:
# "resolution" "song" "visualstyle" "gpu"
#
# See this wiki page for more info:
# https://github.com/dylanaraps/fetch/wiki/Customizing-Info
printinfo () {
    info title
    info underline

    info "OS" distro
    info "Kernel" kernel
    info "Uptime" uptime
    info "Packages" packages
    info "Shell" shell
    info "Window Manager" windowmanager
    info "GTK Theme" gtktheme
    info "Icons" gtkicons
    info "CPU" cpu
    info "Memory" memory

    info linebreak
    info cols
}


# Window Manager


# CPU

# CPU speed type
# Only works on Linux with cpufreq.
# --speed_type current/min/max
speed_type="max"


# GPU

# Shorten output of the getgpu funcion
# --gpu_shorthand on/off
gpu_shorthand="off"


# Uptime

# Shorten the output of the uptime function
# --uptime_shorthand on/off
uptime_shorthand="off"


# Gtk Theme / Icons

# Shorten output (Hide [GTK2] etc)
# --gtk_shorthand on/off
gtk_shorthand="off"


# Color Blocks

# Color block range
# --block_range start end
start=0
end=7

# Toggle color blocks
# --color_blocks on/off
color_blocks="on"

# Color block width
# --color_block_width num
block_width=3


# }}}


# Text Colors {{{
# --colors 1 2 3 4 5


# --title_color num
title_color=4

# Color of "@" symbol in title
# --at_color num
at_color=6

# --subtitle_color num
subtitle_color=1

# --colon_color num
colon_color=8

# --underline_color num
underline_color=8

# --info_color num
info_color=6


# }}}


# Text Options {{{


# Toggle line wrapping
# --line_wrap on/off
line_wrap="on"

# Toggle bold text
# --bold on/off
bold="on"

# Toggle title underline
# --underline on/off
underline="on"

# Underline character
# --underline_char char
underline_char="-"

# Prompt height
# You should only have to change this if your
# prompt is greater than 2 lines high.
# --prompt_height num
prompt_height=1


# }}}


# Image Options {{{


# Image Source
# --image wall, shuffle, /path/to/img, off
image="wall"

# Thumbnail directory
imgtempdir="$HOME/.fetchimages"

# Image Backend
# Which program to draw images with
# --image_backend w3m, iterm2
image_backend="w3m"

# W3m-img path
# Some systems have this in another location
w3m_img_path="/usr/lib/w3m/w3mimgdisplay"

# Split Size
# Sizing for the img and text splits
# The larger the value the less space fetch will take up.
# The default value of 2 splits the image and text at
# half terminal width each.
# A value of 3 splits them at a third width each and etc.
# --split_size num
split_size=2

# Image position
# --image_position left/right
image_position="left"

# Shuffle dir
shuffledir="$HOME/Pictures/wallpapers/wash"

# Crop mode
# --crop_mode normal/fit/fill
crop_mode="normal"

# Crop offset
# Only affects normal mode.
# --crop_offset northwest/north/northeast/west/center
#               east/southwest/south/southeast
crop_offset="center"

# Font width
# Used when calculating dynamic image size
font_width=5

# Right gap between image and text
# --gap num
gap=4

# Image offsets
# --xoffset px
# --yoffset px
yoffset=0
xoffset=0


# }}}


# Other Options {{{


# Whether or not to always take a screenshot
# You can manually take a screenshot with "--scrot" or "-s"
scrot="off"

# Screenshot program to launch
# --scrot_cmd
scrot_cmd="scrot -c -d 3"

# Scrot dir
# Where to save the screenshots
# --scrot_dir /path/to/screenshot/folder
scrot_dir="$HOME/Pictures"

# Scrot filename
# What to name the screenshots
# --scrot_name str
scrot_name="fetch-%Y-%m-%d-%H:%M.png"


# }}}


# }}}


# Gather Info {{{


# Get Operating System Type
case "$(uname)" in
    "Linux")
        os="Linux"
    ;;

    "Darwin")
        os="Mac OS X"
    ;;

    "OpenBSD")
        os="OpenBSD"
    ;;

    *"BSD")
        os="BSD"
    ;;

    "CYGWIN"*)
        os="Windows"
    ;;

    *)
        printf "%s\n" "Couldn't detect OS, exiting"
        exit
    ;;
esac

# Get Distro
case "$os" in
    "Linux" )
        if type -p crux >/dev/null 2>&1; then
            distro="CRUX"
        elif type -p lsb_release >/dev/null 2>&1; then
            distro="$(lsb_release -a 2>/dev/null | awk -F':' '/Description/ {printf $2}')"
            distro=${distro/[[:space:]]/}
        else
            distro="$(grep -h '^NAME=' /etc/*ease)"
            distro=${distro#NAME\=*}
            distro=${distro#\"*}
            distro=${distro%*\"}
        fi
    ;;

    "Mac OS X")
        distro="Mac OS X $(sw_vers -productVersion)"
    ;;

    "OpenBSD")
        distro="OpenBSD"
    ;;

    "BSD")
        distro="$(uname -v)"
        distro=${distro%% *}
    ;;

    "Windows")
        case "$(cmd /c ver)" in
            *"XP"*)
                distro="Windows XP"
            ;;

            *"7"*)
                distro="Windows 7"
            ;;

            *"8.1"*)
                distro="Windows 8.1"
            ;;

            *"8"*)
                distro="Windows 8"
            ;;

            *"10"*)
                distro="Windows 10"
            ;;

            *)
                distro="Windows"
            ;;
        esac
    ;;

    *)
        distro="Unknown"
    ;;
esac

# Get Title
gettitle () {
    title="${USER}@$(hostname)"
}

# Get kernel version
getkernel() {
    kernel="$(uname -r)"
}

# Get uptime
getuptime () {
    case "$os" in
        "Linux")
            uptime="$(uptime -p)"
        ;;

        "Mac OS X" | *"BSD")
            # Get boot time in seconds
            boot="$(sysctl -n kern.boottime)"
            boot="${boot/{ sec = /}"
            boot=${boot/,*}

            # Get current date in seconds
            now=$(date +%s)
            uptime=$((now - boot))

            # Convert uptime to days/hours/mins
            mins=$((uptime / 60%60))
            hours=$((uptime / 3600%24))
            days=$((uptime / 86400))

            case "$mins" in
                0) ;;
                1) uptime="up ${mins} minute" ;;
                *) uptime="up ${mins} minutes" ;;
            esac

            case "$hours" in
                0) ;;
                1) uptime="up ${hours} hour, ${uptime/up /}" ;;
                *) uptime="up ${hours} hours, ${uptime/up /}" ;;
            esac

            case "$days" in
                0) ;;
                1) uptime="up ${days} day, ${uptime/up /}" ;;
                *) uptime="up ${days} days, ${uptime/up /}" ;;
            esac
        ;;

        "Windows")
            uptime=$(uptime | awk -F ':[0-9]{2}+ |(, ){1}+' '{printf $2}')
            uptime=${uptime/  / }
        ;;

        *)
            uptime="Unknown"
        ;;

    esac

    if [ "$uptime_shorthand" == "on" ]; then
        uptime=${uptime/up/}
        uptime=${uptime/minutes/mins}
        uptime=${uptime# }
    fi
}

# Get package count
getpackages () {
    case "$distro" in
        "Arch Linux"* | "Parabola GNU/Linux-libre"* | "Manjaro"* | "Antergos"*)
            packages="$(pacman -Qq --color never | wc -l)"
        ;;

        "void"*)
            packages="$(xbps-query -l | wc -l)"
        ;;

        "Ubuntu"* | "Mint"* | "Debian"* | "Kali Linux"* | "Deepin Linux"* | "elementary"*)
            packages="$(dpkg --get-selections | grep -v deinstall$ | wc -l)"
        ;;

        "Slackware"*)
            packages="$(ls -1 /var/log/packages | wc -l)"
        ;;

        "Gentoo"* | "Funtoo"*)
            packages="$(ls -d /var/db/pkg/*/* | wc -l)"
        ;;

        "Fedora"* | "openSUSE"* | "Red Hat Enterprise Linux"* | "CentOS"*)
            packages="$(rpm -qa | wc -l)"
        ;;

        "CRUX")
            packages="$(pkginfo -i | wc -l)"
        ;;

        "Mac OS X"*)
            if [ -d "/usr/local/bin" ]; then
                local_packages=$(ls -l /usr/local/bin/ | grep -v "\(../Cellar/\|brew\)" | wc -l)
                packages=$((local_packages - 1))
            fi

            if type -p port >/dev/null 2>&1; then
                port_packages=$(port installed 2>/dev/null | wc -l)
                packages=$((packages + $((port_packages - 1))))
            fi

            if type -p brew >/dev/null 2>&1; then
                brew_packages=$(brew list -1 2>/dev/null | wc -l)
                packages=$((packages + brew_packages))
            fi

            if type -p pkgin >/dev/null 2>&1; then
                pkgsrc_packages=$(pkgin list 2>/dev/null | wc -l)
                packages=$((packages + pkgsrc_packages))
            fi
        ;;

        "OpenBSD" | "NetBSD")
            packages=$(pkg_info | wc -l)
        ;;

        "FreeBSD")
            packages=$(pkg info | wc -l)
        ;;

        "Windows"*)
            packages=$(cygcheck -cd | wc -l)
        ;;

        *)
            packages="Unknown"
        ;;
    esac

    packages=${packages// }
}

# Get shell
getshell () {
    shell="$SHELL"
}

# Get window manager
getwindowmanager () {
    if type -p wmctrl >/dev/null 2>&1; then
        windowmanager="$(wmctrl -m | head -n1)"
        windowmanager=${windowmanager/Name: /}

    elif [ "$XDG_CURRENT_DESKTOP" ]; then
        windowmanager="$XDG_CURRENT_DESKTOP"

    elif [ -e "$HOME/.xinitrc" ]; then
        xinitrc=$(grep "^[^#]*exec" "${HOME}/.xinitrc")
        windowmanager="${xinitrc/exec /}"
        windowmanager="${windowmanager/-session/}"
        windowmanager="${windowmanager^}"

    else
        case "$os" in
            "Mac OS X")
                windowmanager="Quartz Compositor"
            ;;

            "Windows")
                windowmanager="Explorer"
            ;;

            *)
                windowmanager="Unknown"
            ;;

        esac
    fi
}

# Get cpu
getcpu () {
    case "$os" in
        "Linux")
            # Get cpu name
            cpu="$(grep -F 'model name' /proc/cpuinfo)"
            cpu=${cpu/model name*: /}
            cpu=${cpu/ @*/}

            # Get cpu speed
            case "$distro" in
                *"buntu"* | "CentOS"* | "elementary"*)
                    speed=$(awk -F ': ' '/cpu MHz/ {printf $2; exit}' /proc/cpuinfo)
                    speed=${speed/\./}
                ;;

                *)
                    speed_type=${speed_type/rent/}
                    read -r speed < \
                        /sys/devices/system/cpu/cpu0/cpufreq/scaling_${speed_type}_freq
                ;;
            esac

            # Convert mhz to ghz without bc
            speed=$((speed / 100000))
            speed=${speed:0:1}.${speed:1}

            cpu="$cpu @ ${speed}GHz"
        ;;

        "Mac OS X")
            cpu="$(sysctl -n machdep.cpu.brand_string)"
        ;;

        *"BSD")
            case "$distro" in
                "OpenBSD")
                    # Get cpu name
                    cpu="$(sysctl -n hw.model)"
                    cpu=${cpu/ @*/}
                    cpu=${cpu//  /}
                    cpu=${cpu% }

                    # Get cpu speed
                    speed=$(sysctl -n hw.cpuspeed)
                    speed=$((speed / 100))
                ;;

                "FreeBSD")
                    # Get cpu name
                    cpu="$(sysctl -n hw.model)"
                    cpu=${cpu/ @*/}
                    cpu=${cpu//  /}
                    cpu=${cpu% }

                    # Get cpu speed
                    speed="$(sysctl -n hw.clockrate)"
                    speed=$((speed / 100))
                ;;

                "NetBSD")
                    # Get cpu name
                    cpu="$(grep -F 'model name' /proc/cpuinfo)"
                    cpu=${cpu/model name*: /}
                    cpu=${cpu/ @*/}
                    cpu=${cpu//  /}
                    cpu=${cpu% }

                    # Get cpu speed
                    speed="$(grep -F 'cpu MHz' /proc/cpuinfo)"
                    speed=${speed/cpu MHz*: /}
                    speed=${speed/\./}
                    speed=$((speed / 10000))
                ;;
            esac

            speed=${speed:0:1}.${speed:1}
            cpu="$cpu @ ${speed}GHz"
        ;;

        "Windows")
            # Get cpu name
            cpu="$(grep -F 'model name' /proc/cpuinfo)"
            cpu=${cpu/model name*: /}
            cpu=${cpu/ @*/}
            cpu=${cpu//  /}
            cpu=${cpu% }

            # Get cpu speed
            speed=$(grep -F 'cpu MHz' /proc/cpuinfo)
            speed=${speed/cpu MHz*: /}
            speed=${speed/\./}

            # Convert mhz to ghz without bc
            speed=$((speed / 100000))
            speed=${speed:0:1}.${speed:1}
            cpu="$cpu @ ${speed}GHz"
        ;;

        *)
            cpu="Unknown"
        ;;
    esac

    # Remove uneeded patterns from cpu output
    # This is faster than sed/gsub
    cpu=${cpu//(tm)/}
    cpu=${cpu//(TM)/}
    cpu=${cpu//(r)/}
    cpu=${cpu//(R)/}
    cpu=${cpu// CPU/}
    cpu=${cpu// Processor/}
    cpu=${cpu// Six-Core/}
}

getgpu () {
   case "$os" in
       "Linux" | "OpenBSD")
            gpu="$(lspci | grep "VGA")"
            gpu=${gpu/* VGA compatible controller: }
            gpu=${gpu/(rev*)}

            shopt -s nocasematch
            case "$gpu" in
                intel*)
                    gpu=${gpu/'Intel Corporation' }
                    gpu=${gpu/'Haswell-'??? }

                    brand="Intel"
                ;;

                advanced*)
                    gpu=${gpu/'Advanced Micro Devices, Inc.' }
                    gpu=${gpu/'[AMD/ATI]' }
                    gpu=${gpu/'Tahiti PRO'}
                    gpu=${gpu/'Seymour'}
                    gpu=${gpu/' ['}
                    gpu=${gpu/']'}

                    brand="AMD"
                ;;

                nvidia*)
                    gpu=${gpu/'NVIDIA Corporation' }
                    gpu=${gpu/'nVidia Corporation' }
                    gpu=${gpu/G????M }
                    gpu=${gpu/G???? }
                    gpu=${gpu/'['}
                    gpu=${gpu/']'}

                    brand="Nvidia"
                ;;
            esac

            gpu="$brand $gpu"
        ;;

        "Mac OS X")
            gpu=$( \
                system_profiler SPDisplaysDataType | \
                awk -F': ' '/^\ *Chipset Model:/ {printf $2}' | \
                awk '{ printf "%s / ", $0 }'
            )
            gpu=${gpu//'/ $'}
        ;;

        "BSD")
            case "$distro" in
                "FreeBSD")
                    gpu=$(pciconf -lv 2>/dev/null | grep -B 4 "VGA" | grep "device")
                    gpu=${gpu/device*= /}
                    gpu=${gpu//\'/}
                    gpu=${gpu//[[:space:]]/ }
                    gpu=${gpu//  /}
                ;;
            esac
        ;;


        "Windows")
            gpu=$(wmic path Win32_VideoController get caption)
            gpu=${gpu/Caption /}
            gpu=${gpu//[[:space:]]/ }
            gpu=${gpu//  /}
        ;;
    esac

    if [ "$gpu_shorthand" == "on" ]; then
        gpu=${gpu/'Rev. '?}
        gpu=${gpu/'AMD/ATI'/AMD}
        gpu=${gpu/'Tahiti' }
        gpu=${gpu/'PRO' }
        gpu=${gpu/'OEM' }
        gpu=${gpu/'Mars' }
        gpu=${gpu/'Series'}
        gpu=${gpu/\/*}
    fi
}

# Get memory
getmemory () {
    case "$os" in
        "Linux")
            # Read first 3 lines
            exec 6< /proc/meminfo
            read -r memtotal <&6
            read -r memfree <&6
            read -r memavail <&6
            exec 6<&-

            # Do some substitution on each line
            memtotal=${memtotal/MemTotal:/}
            memtotal=${memtotal/kB*/}
            memtotal=${memtotal// /}
            memfree=${memfree/MemFree:/}
            memfree=${memfree/kB*/}
            memfree=${memfree// /}
            memavail=${memavail/MemAvailable:/}
            memavail=${memavail/kB*/}
            memavail=${memavail// /}

            memused=$((memtotal - memavail))
            memory="$((memused / 1024))MB / $((memtotal / 1024))MB"
        ;;

        "Mac OS X")
            memtotal=$(printf "%s\n" "$(sysctl -n hw.memsize)"/1024^2 | bc)
            memactive=$(vm_stat | awk '/active / { printf $3 }')
            memcompressed=$(vm_stat | awk '/occupied/ { printf $5 }')
            memused=$(((${memactive//.} + ${memcompressed//.}) * 4 / 1024))
            memory="${memused}MB / ${memtotal}MB"
        ;;

        "OpenBSD" | "BSD")
            case "$distro" in
                "OpenBSD")
                    memtotal=$(dmesg | awk '/real mem/ {printf $5}')
                    memtotal=${memtotal/\(/}
                    memtotal=${memtotal/MB\)/}

                    memfree=$(top -d 1 | awk '/Real:/ {printf $6}')
                    memfree=${memfree/M/}

                    memused=$((memtotal - memfree))
                    memory="${memused}MB / ${memtotal}MB"
                ;;

                "FreeBSD")
                    memtotal=$(dmesg | awk '/real mem/ {printf $5}')
                    memtotal=${memtotal/\(/}
                    memtotal=${memtotal/MB\)/}

                    memfree=$(top -d 1 | awk '/Mem:/ {printf $10}')
                    memfree=${memfree/M/}

                    memused=$((memtotal - memfree))
                    memory="${memused}MB / ${memtotal}MB"
                ;;

                "NetBSD")
                    memfree=$(($(vmstat | awk 'END{printf $4}') / 1000))
                    memused=$(($(vmstat | awk 'END{printf $3}') / 1000))
                    memtotal=$((memused + memfree))

                    memused=$((memtotal - memfree))
                    memory="${memused}MB / ${memtotal}MB"
                ;;
            esac

        ;;

        "Windows")
            mem="$(awk 'NR < 3 {printf $2 " "}' /proc/meminfo)"

            # Split the string above into 2 vars
            # This is faster than using an array.
            set $mem

            memtotal=$1
            memfree=$2
            memavail=$((memtotal - memfree))
            memused=$((memtotal - memavail))
            memory="$((${memused%% *} / 1024))MB / "
            memory+="$((${memtotal%% *} / 1024))MB"
        ;;

        *)
            memory="Unknown"
        ;;
    esac
}

# Get song
getsong () {
    if type -p mpc >/dev/null 2>&1; then
        song="$(mpc current)"
    elif type -p cmus >/dev/null 2>&1; then
        song="$(cmus-remote -Q | grep "tag artist\|title")"
        song=${song/tag artist }
        song=${song/tag title/-}
        song=${song//[[:space:]]/ }
    else
        song="Unknown"
    fi
}

# Get Resolution
getresolution () {
    case "$os" in
        "Linux" | *"BSD")
            resolution=$(xdpyinfo 2>/dev/null | awk '/dimensions:/ {printf $2}')
        ;;

        "Mac OS X")
            resolution=$(system_profiler SPDisplaysDataType |\
                        awk '/Resolution:/ {printf $2"x"$4" "}')
        ;;
    esac

    [ -z "$resolution" ] && resolution="Unknown"
}

getgtk () {
    case "$1" in
        theme)
            name="gtk-theme-name"
            type="gtk"
        ;;

        icons)
            name="gtk-icon-theme-name"
            type="icons"
        ;;
    esac

    if [ -f "$HOME/.gtkrc-2.0" ]; then
        gtk2theme=$(grep "^[^#]*$name" $HOME/.gtkrc-2.0)
        gtk2theme=${gtk2theme/${name}=/}
        gtk2theme=${gtk2theme//\"/}
        gtk2theme="$gtk2theme"
        gtktheme="$gtk2theme [GTK2] "
    fi

    if [ -f "$HOME/.config/gtk-3.0/settings.ini" ]; then
        gtk3theme=$(grep "^[^#]*$name" $HOME/.config/gtk-3.0/settings.ini)
        gtk3theme=${gtk3theme/${name}=/}
        gtk3theme=${gtk3theme//\"/}
        gtk3theme="$gtk3theme"
        gtktheme="$gtk2theme $gtk3theme [GTK3]"
    else
        gtk3theme=$(gsettings get org.gnome.desktop.interface $type-theme 2>/dev/null)
        gtktheme="$gtk3theme [GTK3] "
    fi

    if [ "$gtk2theme" ] && [ "$gtk2theme" == "$gtk3theme" ]; then
        gtktheme="$gtk2theme [GTK2/3]"
    elif [ -z "$gtk2theme" ] && [ -z "$gtk3theme" ]; then
        gtktheme="None"
    fi

    if [ "$gtk_shorthand" == "on" ]; then
        gtktheme=${gtktheme/ [GTK2]/}
        gtktheme=${gtktheme/ [GTK3]/}
        gtktheme=${gtktheme/ [GTK2\/\3\]/}
    fi

    gtktheme=${gtktheme//\'}
}

getgtktheme () {
    getgtk theme
}

getgtkicons () {
    getgtk icons
    gtkicons="$gtktheme"
}

getcols () {
    if [ "$color_blocks" == "on" ]; then
        printf "${padding}%s"
        while [ $start -le $end ]; do
            printf "\e[48;5;${start}m%${block_width}s"
            start=$((start + 1))

            # Split the blocks at 8 colors
            [ $end -ge 9 ] && [ $start -eq 8 ] && \
                printf "\n%s${clear}${padding}"
        done

        # Clear formatting
        printf "%b%s" "$clear"
    fi
}


# Windows Specific Functions

getvisualstyle () {
    case "$os" in
        "Windows"*)
            path="/proc/registry/HKEY_CURRENT_USER/Software/Microsoft"
            path+="/Windows/CurrentVersion/Themes/CurrentTheme"
            visualstyle="$(head -n1 $path)"
            visualstyle="${visualstyle##*\\}"
            visualstyle="${visualstyle%.*}"
            visualstyle="${visualstyle^}"
        ;;

        *)
            visualstyle="This feature only works on Windows"
        ;;
    esac
}


# }}}


# Images {{{


getwallpaper () {
    case "$os" in
        "Linux" | *"BSD")
            if type -p feh >/dev/null 2>&1; then
                img="$(awk -F\' '/feh/ {printf $2}' "$HOME/.fehbg")"
            elif type -p nitrogen >/dev/null 2>&1; then
                img="$(awk -F'=' '/file/ {printf $2}' "$HOME/.config/nitrogen/bg-saved.cfg")"
            fi
        ;;

        "Mac OS X")
            img="$(osascript -e 'tell app "finder" to get posix path of (get desktop picture as text)')"
        ;;

        "Windows")
            case "$distro" in
                "Windows XP")
                    img="/cygdrive/c/Documents and Settings/${USER}"
                    img+="/Local Settings/Application Data/Microsoft"
                    img+="/Wallpaper1.bmp"
                ;;

                "Windows"*)
                    img="$APPDATA/Microsoft/Windows/Themes"
                    img+="/TranscodedWallpaper.jpg"
                ;;
            esac
        ;;
    esac
}

getshuffle () {
    img=$(find "$shuffledir" -type f \( -name '*.jpg' -o -name '*.png' \) -print0 |
    shuf -n1 -z)
}

getimage () {
    # Make the directory if it doesn't exist
    mkdir -p "$imgtempdir"

    # Image size is half of the terminal
    imgsize=$((columns * font_width / split_size))

    # Where to draw the image
    case "$image_position" in
        "left")
            # Padding is half the terminal width + gap
            padding="\e[$((columns / split_size + gap))C"
        ;;

        "right")
            padding="\e[0C"
            xoffset=$((columns * font_width / split_size - gap))
        ;;
    esac

    # If wall=on, Get image to display from current wallpaper.
    case "$image" in
        "wall")
            getwallpaper
        ;;

        "shuffle")
            getshuffle
        ;;

        *)
            img="$image"
        ;;
    esac

    # If $img is empty, reset padding to 0 and exit the function
    if [ -z "$img" ]; then
        padding="\e[0C"
        return
    fi

    # Get name of image and prefix it with it's crop mode and offset
    imgname="$crop_mode-$crop_offset-$imgsize-${img##*/}"

    # Check to see if the thumbnail exists before we do any cropping.
    if [ ! -f "$imgtempdir/$imgname" ]; then
        # Get image size so that we can do a better crop
        size=$(identify -format "%w %h" "$img")
        width=${size%% *}
        height=${size##* }

        # This checks to see if height is geater than width
        # so we can do a better crop of portrait images.
        if [ $height -gt $width ]; then
            size=$width
        else
            size=$height
        fi

        case "$crop_mode" in
            fit)
                c=$(convert "$img" \
                    -colorspace srgb \
                    -format "%[pixel:p{0,0}]" info:)

                convert \
                    "$img" \
                    -trim +repage \
                    -gravity south \
                    -background "$c" \
                    -extent "$size"x"$size" \
                    -scale "$imgsize"x"$imgsize" \
                    "$imgtempdir/$imgname"
            ;;

            fill)
                convert \
                    "$img" \
                    -trim +repage \
                    -scale "$imgsize"x"$imgsize"^ \
                    -extent "$imgsize"x"$imgsize" \
                    "$imgtempdir/$imgname"
            ;;

            *)
                convert \
                    "$img" \
                    -gravity $crop_offset \
                    -crop "$size"x"$size"+0+0 \
                    -quality 95 \
                    -scale "$imgsize"x"$imgsize" \
                    "$imgtempdir/$imgname"
            ;;
        esac
    fi

    # The final image
    img="$imgtempdir/$imgname"
}

scrot_path="$scrot_dir/$scrot_name"
takescrot () {
    $scrot_cmd "$scrot_path"
}

# }}}


# Text Formatting {{{


info () {
    # Call the function and update variable
    if [ -z "$2" ]; then
        get$1 2>/dev/null
        eval output="\$${1}"
    else
        get$2 2>/dev/null
        eval output="\$${2}"
    fi

    case "$1" in
        title)
            string="${bold}${title_color}${output}"
            string="${string/@/${at_color}@${title_color}}"
            length=${#output}
        ;;

        underline)
            string="${underline_color}${output}"
        ;;

        linebreak | cols)
            string=""
        ;;

        *)
            string="${bold}${subtitle_color}${1}${clear}"
            string+="${colon_color}: ${info_color}${output}"
            length=$((${#subtitle} +  ${#output} + 2))
        ;;
    esac

    printf "%b%s\n" "${padding}${string}${clear}"
}

prin () {
    case "$1" in
        *:*)
            subtitle=${1%%:*}
            output=${1#*: }

            string="${bold}${subtitle_color}${subtitle}${clear}"
            string+="${colon_color}: ${info_color}${output}"
            length=$((${#subtitle} +  ${#output} + 1))
        ;;

        *)
            string="${info_color}${1}"
            length=${#1}
        ;;
    esac

    printf "%b%s\n" "${padding}${string}${clear}"
}

getunderline () {
    underline=$(printf %"$length"s)
    underline=${underline// /$underline_char}
}

colors () {
    title_color="\e[38;5;${title_color}m"
    at_color="\e[38;5;${at_color}m"
    subtitle_color="\e[38;5;${subtitle_color}m"
    colon_color="\e[38;5;${colon_color}m"
    underline_color="\e[38;5;${underline_color}m"
    info_color="\e[38;5;${info_color}m"
}

color () {
   printf "\e[38;5;${1}m"
}

bold () {
    if [ "$bold" == "on" ]; then
        bold="\e[1m"
    else
        bold=""
    fi
}

clear="\e[0m"


# }}}


# Usage {{{


usage () { cat << EOF

 usage: ${0##*/} [--colors 1 2 3 4 5] [--kernel "\$\(uname -rs\)"]

    Info:
    --speed_type           Change the type of cpu speed to display.
                           Possible values: current, min, max
                           NOTE: This only support Linux with cpufreq.
    --uptime_shorthand     Shorten the output of uptime
    --gtk_shorthand on/off Shorten output of gtk theme/icons
    --gpu_shorthand on/off Shorten the output of GPU

    Text Colors:
    --colors 1 2 3 4 5 6   Change the color of text
                           (title, @, subtitle, colon, underline, info)
    --title_color num      Change the color of the title
    --at_color num         Change the color of "@" in title
    --subtitle_color num   Change the color of the subtitle
    --colon_color num      Change the color of the colons
    --underline_color num  Change the color of the underlines
    --info_color num       Change the color of the info

    Text Formatting:
    --underline on/off     Enable/Disable title underline
    --underline_char char  Character to use when underlineing title
    --line_wrap on/off     Enable/Disable line wrapping
    --bold on/off          Enable/Disable bold text
    --prompt_height num    Set this to your prompt height to fix
                           issues with the text going off screen at the top

    Color Blocks:
    --color_blocks on/off  Enable/Disable the color blocks
    --block_width num      Width of color blocks
    --block_range start end --v
                           Range of colors to print as blocks

    Image:
    --image                Image source. Where and what image we display.
                           Possible values: wall, shuffle, /path/to/img, off
    --image_backend          Which program to use to draw images.
    --shuffledir           Which directory to shuffle for an image.
    --font_width px        Used to automatically size the image
    --image_position       Where to display the image: (Left/Right)
    --split_size num       Width of img/text splits
                           A value of 2 makes each split half the terminal
                           width and etc
    --crop_mode            Which crop mode to use
                           Takes the values: normal, fit, fill
    --crop_offset value    Change the crop offset for normal mode.
                           Possible values: northwest, north, northeast,
                           west, center, east, southwest, south, southeast

    --xoffset px           How close the image will be
                           to the left edge of the window
    --yoffset px           How close the image will be
                           to the top edge of the window
    --gap num              Gap between image and text right side
                           to the top edge of the window
                           NOTE: --gap can take a negative value which will
                           move the text closer to the left side.
    --clean                Remove all cropped images

    Screenshot:
    --scrot /path/to/img   Take a screenshot, if path is left empty
                           the screenshot function will use
                           \$scrot_dir and \$scrot_name.
    --scrot_cmd            Screenshot program to launch

    Other:
    --help                 Print this text and exit

EOF
exit 1
}


# }}}


# Args {{{


while [ "$1" ]; do
    case $1 in
        # Info
        --speed_type) speed_type="$2" ;;
        --uptime_shorthand) uptime_shorthand="$2" ;;
        --gtk_shorthand) gtk_shorthand="$2" ;;
        --gpu_shorthand) gpu_shorthand="$2" ;;

        # Text Colors
        --colors) title_color=$2
            [ "$3" ] && subtitle_color=$3
            [ "$4" ] && at_color=$4
            [ "$5" ] && colon_color=$5
            [ "$6" ] && underline_color=$6
            [ "$7" ] && info_color=$7 ;;
        --title_color) title_color=$2 ;;
        --at_color) at_color=$2 ;;
        --subtitle_color) subtitle_color=$2 ;;
        --colon_color) colon_color=$2 ;;
        --underline_color) underline_color=$2 ;;
        --info_color) info_color=$2 ;;

        # Text Formatting
        --underline) underline="$2" ;;
        --underline_char) underline_char="$2" ;;
        --line_wrap) line_wrap="$2" ;;
        --bold) bold="$2" ;;
        --prompt_height) prompt_height="$2" ;;

        # Color Blocks
        --color_blocks) color_blocks="$2" ;;
        --block_range) start=$2; end=$3 ;;
        --block_width) block_width="$2" ;;

        # Image
        --image) image="$2" ;;
        --image_backend) image_backend="$2" ;;
        --shuffledir) shuffledir="$2" ;;
        --font_width) font_width="$2" ;;
        --image_position) image_position="$2" ;;
        --split_size) split_size="$2" ;;
        --crop_mode) crop_mode="$2" ;;
        --crop_offset) crop_offset="$2" ;;
        --xoffset) xoffset="$2" ;;
        --yoffset) yoffset="$2" ;;
        --gap) gap="$2" ;;
        --clean) rm -rf "$imgtempdir" || exit ;;

        # Screenshot
        --scrot | -s) scrot="on"; \
            [ "$2" ] && scrot_path="$2" ;;
        --scrot_cmd) scrot_cmd="$2" ;;

        # Other
        --help) usage ;;
    esac

    shift
done


# }}}


# Call Functions and Finish Up {{{


# Restore cursor and clear screen on ctrl+c
trap 'printf "\e[?25h"; clear; exit' 2

# Get lines and columns
lines=$(tput lines)
columns=$(tput cols)

# Clear the terminal
clear

# Hide the cursor
printf "\e[?25l"

# Get image
[ "$image" != "off" ] && getimage

# Disable line wrap
[ "$line_wrap" == "off" ] && printf "\e[?7l"

# Display the image
if [ "$image" != "off" ]; then
    case "$image_backend" in
        "w3m")
            printf "%b%s\n" "0;1;$xoffset;$yoffset;$imgsize;$imgsize;;;;;$img\n4;\n3;" |\
            $w3m_img_path
        ;;

        "iterm2")
            printf "%b%s\a\n" "\033]1337;File=width=${imgsize}px;height=${imgsize}px;inline=1:$(base64 < "$img")"
        ;;
    esac
fi

# Get colors / bold
colors
bold

# Move the cursor to the top and display the info
tput cup 0
printinfo

# Move the cursor to the bottom
case "$os" in
    "BSD") tput DO $lines ;;
    *) tput cup $lines ;;
esac

# Show the cursor
printf "\e[?25h"

# Enable line wrap again
[ "$line_wrap" == "off" ] && printf "\e[?7h"

# If enabled take a screenshot
[ "$scrot" == "on" ] && takescrot


# }}}