sour

#!/bin/bash

function usage {
cat <<EOF
sour: usage:

    -h | --help              help
    -s | --select            select area (does scrot -s)
    -f | --forum             also make thumbnail, output with BBCode 
    -k | --keep              keep images when done, don't remove
    -u | --url {URL}         don't scrot; download {URL} instead
    -e | --existing {PATH}   don't scrot; use image in {PATH}
    -p | --prefix "MSG: "    result is "MSG: URL" (not compatible with -t or -f)

    - options must be used separately (i.e.: "-s -f", not "-sf")
    - when using an existing image, it won't be removed regardless of your
        usage of --keep (thumbnails do get removed unless you use -k or --keep)
EOF
}

if [[ $1 == '-h' || $1 == '--help' || $1 == '-?' ]]; then
    usage
    exit 0
fi

function setDefaults {
    TMPDIR=${TMPDIR:-/tmp}
    location=$(mktemp -d "$TMPDIR/XXXXXXXXXXXXXX") ||\
        { echo "ERROR could not create temporary directory" >&2; exit 1; }
    working_dir="$PWD"

    logdestfile="$HOME/.sour/log/$(date +"%m-%d-%y").log"
    keyfile="$HOME/.sour/key"
    datestamp="$(date +"%F_%H-%M-%S")"

    # For createNeededFiles
    needed_files=("$logdestfile")
    needed_dirs=("$HOME/.sour" "$HOME/.sour/log")
    default_key='https://raw.github.com/wolfcore/sour/master/key'

    thumbcommand=''
    selectioncommand=''
    forum=false
    keep=false
    download=false
    existing=false

    # this will be changed depending on if there is a download or use of an
    # existing image
    extension='png'
    prefix=''
    largeimageurl=''
    largeimagedel=''
    smallimageurl=''
    smallimagedel=''

    firstdone=false
}

# Files and directories needed for successful execution:
#   - .sour/
#   - .sour/log/
#   - .sour/key
#   - .sour/log/(datestamp).log

# Creating directories before populating with needed_files.
function createNeededFiles {
    for directory in "${needed_dirs[@]}"; do
        if [[ ! -d "$directory" ]]; then
            if ! mkdir "$directory" &> /dev/null; then
                echo "ERROR: could not create directory $directory" >&2
                exit 1
            fi
        fi
    done

    for file in "${needed_files[@]}"; do
        if [[ ! -e "$file" ]]; then
            if ! touch "$file" &> /dev/null; then
                echo "ERROR: could not create $file" >&2
                exit 1
            fi
        fi
    done

    # File exists and is a regular file, file exists and isn't empty
    if [[ ! -f "$keyfile" || ! -s "$keyfile" ]]; then
        curl $default_key -o $keyfile > /dev/null 2>&1
    fi
    source $keyfile
}

function moveTo {
    local file="$1"
    local dest="$2"

    # checking that the file exists before moving
    if [[ -e $file ]]; then
        if ! mv $file $dest &> /dev/null; then
            # Try sending the file to home dir.
            if [[ ! $dest == $HOME ]]; then
                echo "failed to move $file to $dest...sending to $HOME" >&2
                moveTo $file $HOME
            else
                die "ERROR: failed to move $file to $dest"
            fi
        fi
    fi
}

function removeTemporaries {
    if [[ $keep == true ]]; then
        if [[ $existing == true ]]; then

            if [[ $forum == true ]]; then
                moveTo $smallimagelocation $working_dir
            else
                # If the if keep == true, existing == true, and forum ==
                # false, that means that the only image that was used was not
                # created by the program, but already existed, so we leave it.
                # Do nothing
                :
            fi

        # existing == false, but we need to keep whatever images we have.
        else

            if [[ $forum == true ]]; then
                moveTo $smallimagelocation $working_dir
            fi
            # Regardless of the thumbnail, we still need to move the regular
            # image
            moveTo $largeimagelocation $working_dir
        fi

    # keep == false, remove everything
    else
        rm --force --recursive $location
    fi
}

function setTraps {
    trap 'removeTemporaries' EXIT
}

function die {
    echo -e "ERROR: $@\a" >&2
    echo '' | xclip
    exit 1
}

function sendOutput {
    echo "$datestamp: $largeimageurl $largeimagedel\
 $smallimageurl $smallimagedel" >> "$logdestfile"

    if [[ $forum == true ]]; then
        echo "[url=$largeimageurl][img]$smallimageurl[/img][/url]"
    else
        # The prefix is equal to '' if it was not changed by the user.
        echo "${prefix}${largeimageurl}"
    fi
}

function uploadFile {
    curl -s -F "image=@$1" -F "key=$key" http://imgur.com/api/upload.xml
}

function parseAndReturn {
    local resp="$@"
    if [[ $resp = *error* ]]; then
        die "error found in response"
    fi

    url=${resp#*<original_image>}
    url=${url%</original_image>*}
    
    del=${resp#*<delete_page>}
    del=${del%</delete_page>*}

    # If correct, url will be length of 28
    local url_length="${#url}"
    (( url_length != 28))  && die "url too large or equal to zero"

    if [[ $firstdone == false ]]; then
        largeimageurl="$url"
        largeimagedel="$del"
        firstdone=true
    else
        smallimageurl="$url"
        smallimagedel="$del"
    fi

}
    
function makeImageUpload {
    largeimageresponse=$(uploadFile "$largeimagelocation")
    parseAndReturn "$largeimageresponse"
    checkAndMakeThumb
}

function checkAndMakeThumb {
    if [[ $forum == true ]]; then
        if [[ $download == true || $existing == true ]]; then
            cp "$largeimagelocation" "$smallimagelocation"
            mogrify -path "$location" -resize 250x250 "$smallimagelocation"
        fi
        smallimageresponse=$(uploadFile "$smallimagelocation")
        parseAndReturn "$smallimageresponse"
    fi
}

function takeShot {
    # These have to be defined after $extension has been changed by the option
    # parsing.
    largeimagelocation="$location/$datestamp.$extension"
    smallimagelocation="$location/$datestamp-thumb.$extension"

    if [[ $download == false && $existing == false ]]; then
        scrot $selectioncommand "$largeimagelocation" $thumbcommand
    elif [[ $download == true ]]; then
        curl "$dl_source" -o "$largeimagelocation" > /dev/null 2>&1
    elif [[ $existing == true ]]; then
        largeimagelocation="$ex_source"
    fi

    setTraps
}

function setExtension {
    extension="${1##*.}"
}

setDefaults

while :
do
    case $1 in
        -f | --forum)
            forum=true
            thumbcommand='--thumb 20'
            shift
            ;;
        -s | --select)
            selectioncommand='--select'
            shift
            ;;
        -k | --keep)
            keep=true
            shift
            ;;
        -u | --url)
            download=true
            dl_source="$2"
            setExtension "$dl_source"
            shift 2
            ;;
        -e | --existing)
            existing=true
            ex_source="$2"
            setExtension "$ex_source"
            shift 2
            ;;
        -p | --prefix)
            prefix="$2"
            shift
            ;;
        --) shift
            break
            ;;
        -*) echo -e "unknown option: $1\n" >&2
            usage
            exit 1
            shift
            ;;
        *) break
            ;;
    esac
done

createNeededFiles
takeShot
makeImageUpload
sendOutput