#!/bin/bash
#
# The infection.
#

# Parameters
BASENAME="`basename $0`"
DIRNAME="$(cd `dirname $0` &> /dev/null && pwd)"
EXCLUDES="--exclude=local --exclude=stowpkg/tree"
DATE="`date +%Y%m%d%I%M%S`"
BACKUPS="$HOME/.backups/$DATE"

# Make sure we're running git directly and not any existing wrapper
GIT="/usr/bin/git"

# Usage
function infection_usage {
  echo "usage: $BASENAME <action> [options]"
  exit 1
}

# Initialize
function infection_init {
  (
    cd $DIRNAME &> /dev/null

    echo "Initializing submodules..."
    $GIT submodule sync          --recursive
    $GIT submodule update --init --recursive

    # Convert to new dotfiles layout
    #
    # This way we can easily check the integrity of our dotfiles
    # once the integrity of the apps repo is checked
    if [ -e "$HOME/.dotfiles" ]; then
       if [ ! -h "$HOME/.dotfiles" ] || [ "`readlink $HOME/.dotfiles`" != "apps/dotfiles" ]; then
         mkdir -p $BACKUPS
         mv $HOME/.dotfiles $BACKUPS/
         ( cd $HOME &> /dev/null && ln -s apps/dotfiles .dotfiles )
      fi
    else
      ( cd $HOME &> /dev/null && ln -s apps/dotfiles .dotfiles )
    fi

    #if [ ! -e "$HOME/.dotfiles" ]; then
    #  echo "Cloning default dotfiles..."
    #  ./metadot/metadot clone default
    #else
    #  echo "Updating dotfiles..."
    #  ./metadot/metadot fetch
    #fi

    #echo "Checking latest tag..."
    #cd $HOME/.dotfiles
    #$DIRNAME/utils-git/git-check-tag

    #echo "Checking out the latest tag..."
    #$DIRNAME/utils-git/git-checkout-tag

    #echo "Checking dotfiles..."
    #$DIRNAME/metadot/metadot version
  )

  #echo ""
  #echo "Please manually verify dotfiles version and tag from the above output."
  #echo "If everything is fine, proceed running this command again with the 'load' parameter."

  #cd -
}

# Load
function infection_load {
  (
    cd $DIRNAME &> /dev/null

    BUNDLE="$3"
    DEPENDENCIES="$4"

    if [ "$BUNDLE" == "--all" ]; then
      echo "Loading all dotfiles..."
      ./metadot/metadot load --all

      if [ "$DEPENDENCIES" == "--deps" ]; then
        ./metadot/metadot deps --all
      fi
    elif [ ! -z "$BUNDLE" ]; then
      echo "Loading $BUNDLE dotfiles..."
      ./metadot/metadot load-bundle $BUNDLE

      if [ "$DEPENDENCIES" == "--deps" ]; then
        ./metadot/metadot deps-bundle $BUNDLE
      fi
    fi
  )

  echo "Done. Logout and login again to apply all changes."
}

# Install
function infection_install {
  #$0 init
  $0 load $*
}

# Deploy
function infection_deploy {
  if [ ! -z "$2" ]; then
    REMOTES="$*"

    for REMOTE in $REMOTES; do
      REMOTE="$2"
      MODULES="`$DIRNAME/metadot/metadot installed | xargs`"

      # Sync apps
      if [ -e "$HOME/apps" ]; then
        rsync -avz --delete $EXCLUDES $HOME/apps/ $REMOTE:apps/
      fi

      # Sync dotfiles
      if [ -e "$HOME/.dotfiles" ]; then
        rsync -avz --delete $HOME/.dotfiles/ $REMOTE:.dotfiles/
      fi

      # Sync loaded modules
      ssh -T $REMOTE <<EOF
      ##### BEGIN REMOTE SCRIPT #####
      \$HOME/apps/infection load
      for module in $MODULES; do
        \$HOME/apps/metadot/metadot load \$module
      done
      ##### END REMOTE SCRIPT #######
EOF
    done
  fi
}

# Version information
function infection_version {
  echo "master branch:"
  echo "=============="
  echo ""
  ( cd $DIRNAME && $GIT log --show-signature -n 1 )

  echo ""
  echo "origin/master branch:"
  echo "====================="
  echo ""
  ( cd $DIRNAME && $GIT log --show-signature -n 1 --remotes --branches=origin/master )
}

# Fetch
function infection_fetch {
  ( cd $DIRNAME && $GIT fetch --all && $GIT log --show-signature -n 1 --remotes --branches=origin/master )
}

# Merge
function infection_merge {
  (
  cd $DIRNAME && $GIT merge origin/master                 && \
                 $GIT submodule sync          --recursive && \
                 $GIT submodule update --init --recursive
  )
}

# Repository status
function infection_status {
  ( cd $DIRNAME && git status --ignored && git submodule foreach --recursive git status --ignored )
}

# Check
if [ -z "$1" ]; then
  infection_usage
  exit 1
fi

# Initialize
infection_init

# Main
if [ "$1" == "load" ]; then
  infection_load $*
#elif [ "$1" == "init" ]; then
#  infection_init
elif [ "$1" == "install" ]; then
  infection_install $*
elif [ "$1" == "deploy" ]; then
  infection_deploy $*
elif [ "$1" == "version" ]; then
  infection_version
elif [ "$1" == "fetch" ]; then
  infection_fetch
elif [ "$1" == "merge" ]; then
  infection_merge
elif [ "$1" == "status" ]; then
  infection_status
else
  infection_usage
fi