setup

#!/usr/bin/env bash

# Error logging.
function e_error() {
    printf "$(tput setaf 1)✘ %s$(tput sgr0)\n" "$@"
}

# Header logging.
function e_header() {
    printf "$(tput setaf 5)%s$(tput sgr0)\n" "$@"
}

# Info logging.
function e_info() {
    printf "$(tput setaf 6)%s$(tput sgr0)\n" "$@"
}

# Success logging.
function e_success() {
    printf "$(tput setaf 2)✔ %s$(tput sgr0)\n" "$@"
}

# If we are trying to clone the repo into the $HOME directory, clone it into
# `~/ssh` instead.
if [ "$PWD" == "$HOME" ]; then
    mkdir "$HOME/ssh"
    cd $HOME/ssh
fi

# Initialize the git repository if it's missing.
if [ ! -d .git ]; then

    # Fetch the repo.
    e_header "Fetching repo..."
    git clone https://github.com/whitneyit/ssh.git temp

    # Info the user where the repo is located.
    e_info "Repo located at: \"$PWD\""

    # If we are running inside a `cygwin` environment, we need to change the
    # "group" on the files so that we can change the permissions of the files.
    if [ "$(uname -s | grep -c CYGWIN)" -gt 0 ]; then
        chgrp -R Users $PWD

    # And here we do the same for a `vagrant` environment.
    elif [ -d /home/vagrant ]; then
        chown -R vagrant:vagrant $PWD
    fi

    # Do some fancy footwork to move the repo into this given directory. This
    # works even if the directory is not empty, so a point of caution there...
    mv temp/.git ./.git
    rm -rf temp

    # Now we restore the repo.
    git reset --hard

    # And remove old files.
    git clean -dfx

    # Now we modify the origin url to use our `ssh` address. We do this so that
    # when we modify the repo we don't have to worry about passwords.
    e_info "Updating origin url..."
    git remote set-url origin git@github.com:whitneyit/ssh.git

fi

# If the `~/.ssh` folder doesn't already exist, create it now.
if [ ! -d $HOME/.ssh ]; then
    mkdir -p $HOME/.ssh
fi

# Open up the `~/.ssh` folder for editing. We do this outside of the check
# above so that even when the directory does exist, we will reset the folders
# permissions and ensure that we can edit the contents.
chmod 755 $HOME/.ssh

# If a previous `~/.ssh/config` file exists, back it up now.
if [ -f $HOME/.ssh/config ]; then

    # Define our directories to work with
    TIMESTAMP_DIRECTORY="$(date +%Y-%m-%d_%H-%M-%S)"
    BACKUP_DIRECTORY="$HOME/.ssh/backups/$TIMESTAMP_DIRECTORY"

    # If the user is spamming this command more than once per second, we should
    # just bail now. What this is actually saying is if the directory already
    # exists, (defined down to the second), when then just kill the shell.
    if [ -d "$BACKUP_DIRECTORY" ]; then
        exit 0
    fi

    # Create the timestamped backup directory.
    mkdir -p "$BACKUP_DIRECTORY"

    # Test to make sure that our directory was created.
    if [ ! -d "$BACKUP_DIRECTORY" ]; then
        e_error "Unable to create \"Backup directory\": $BACKUP_DIRECTORY.  Aborting"
        exit 0
    fi

    # Backup the file.
    mv $HOME/.ssh/config "$BACKUP_DIRECTORY"

    # Inform the user that we are backing up the `config` file.
    e_info "Backed up \"~/.ssh/config\" to \"~/.ssh/backups/$TIMESTAMP_DIRECTORY/config\""

fi

# If we are running inside a vagrant box we do not need to create any ssh keys
# because they should already be forwarded from the host box.
if [ ! -d /home/vagrant ]; then

    # Read the keys.
    KEYS="$(cat "$HOME/.keys")"

    # Here we loop over each line in the file.
    for line in $KEYS;  do

        # Here we convert the line of the file into a real variable.
        key=$(eval echo "$line")

        # Handle empty lines or comments
        if [ -z "$key" ]; then
            continue
        fi

        # See if the key exists.
        if [ -f "$HOME/.ssh/$key" ]; then

            # If we are running inside a cygwin box, we need to set the group.
            if [ "$(uname -s | grep -c CYGWIN)" -gt 0 ]; then
                chgrp Users "$HOME/.ssh/$key"
                chgrp Users "$HOME/.ssh/$key.pub"
            fi

        # If the $key doesn't exist.
        else

            # Generate a new key.
            ssh-keygen -t rsa -C "$key" -f "$key" -N ""
            mv "$key" "$HOME/.ssh"
            mv "$key.pub" "$HOME/.ssh"
            e_info "Created key: $key at $HOME/.ssh/$key"

        fi

        # Set the permissions of the key.
        chmod 600 "$HOME/.ssh/$key"
        chmod 600 "$HOME/.ssh/$key.pub"

        # Add the key to the `ssh-agent`.
        eval ssh-add "$HOME/.ssh/$key"

    done

fi

# If we are missing a `authorized_keys` file, create one now.
if [ ! -f $HOME/.ssh/authorized_keys ]; then
    touch $HOME/.ssh/authorized_keys
fi
chmod 644 $HOME/.ssh/authorized_keys

# Same goes with `hosts_file` file.
if [ ! -f $HOME/.ssh/known_hosts ]; then
    touch $HOME/.ssh/known_hosts
fi
chmod 644 $HOME/.ssh/known_hosts

# Copy over the new `config` file and set its permissions.
cp config $HOME/.ssh/config
chmod 644 $HOME/.ssh/config

# When running in `cygwin`, change the group of the `~/.ssh` folder and all of
# its children folders and files. More information on why you need to change the
# group can be found here:
# http://superuser.com/questions/397288
if [ "$(uname -s | grep -c CYGWIN)" -gt 0 ]; then
    chgrp -R Users $HOME/.ssh
elif [ -d /home/vagrant ]; then
    chown -R vagrant:vagrant $HOME/.ssh
fi

# If we are using vagrant change the group for vagrant's main ssh key.
if [ -f $HOME/.vagrant.d/insecure_private_key ]; then
    chgrp Users $HOME/.vagrant.d/insecure_private_key
    chmod 600 $HOME/.vagrant.d/insecure_private_key
fi

# Ensure that we have a folder for our soon to be created `ssh_setup` file.
if [ ! -d /usr/local/bin ]; then

    # User sudo if it is available.
    if [ "$(type -P sudo)" ]; then
        sudo mkdir -p /usr/local/bin
    else
        mkdir -p /usr/local/bin
    fi

fi

# Set the ownership of `/usr/local/bin` correctly.
if [ "$(uname -s | grep -c CYGWIN)" -gt 0 ]; then
    chgrp Users /usr/local/bin
elif [ -d /home/vagrant ]; then
    sudo chown vagrant:vagrant /usr/local/bin
fi

# With everything now complete, we can "close" the `~/.ssh` folder. The `~/.ssh`
# folder needs to be 700 and any ssh keys as well as the config file must, be
# set to 600.
chmod 700 $HOME/.ssh
chmod 600 $HOME/.ssh/config

# And finally that's it. Repo updated!
e_success "SSH setup complete"

# vim: set syn=sh :