#!/bin/bash
#
# Metadot: a dotfile management system.
#
# Copyright (C) 2013 Silvio Rhatto - rhatto at riseup.net
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published
# by the Free Software Foundation, either version 3 of the License,
# or any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

# Set real home folder
if [ ! -z "$PREFIX" ]; then
  if [ ! -d "$PREFIX" ]; then
    echo "Destination folder not found: $PREFIX"
  else
    DEST="$PREFIX"
  fi
else
  DEST="$HOME"
fi

# Parameters
OPT="$1"
DATE="`date +%Y%m%d%I%M%S`"
BASENAME="`basename $0`"
DIRNAME="`dirname $0`"
DOT="$DEST/.dotfiles"
MODULES="$DOT/modules"
BACKUPS="$DEST/.backups/$DATE"
DEFAULT="https://git.fluxo.info/rhatto/dotfiles"

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

# Backup a file
function metadot_backup {
  local file="$DEST/$1"
  
  if [ -e "$file" ] || [ -h "$file" ]; then
    local folder="$BACKUPS/`dirname $1`"

    #echo "Backing up `basename $1`..."
    mkdir -p $folder
    mv $file $folder
  fi
}

# Find contents of a module
function __metadot_find {
  local module="$1"
  ( cd $MODULES/$module && find -name '*.link' -or -name '*.dot.link' ) | grep -v '.git/modules' | sed -e 's|./||'
}

# Load a module
function metadot_load {
  local module="$1"
  local destname
  local dirname

  if [ -d "$MODULES/$module" ]; then

    echo "Loading module $module..."

    for file in `__metadot_find $module`; do
      echo "Processing $file..."

      # Get the dirname, replacing string.dot with .string
      dirname="`echo $file | sed -e 's|\([^/]*\).dot/|.\1/|g'`"
      dirname="`dirname $dirname`"

      if echo $file | grep -q '.dot.link'; then
        destname=".`basename $file .dot.link`"
      else
        destname="`basename $file .link`"
      fi

      if [ "$dirname" != "." ]; then
        #echo "Creating $DEST/$dirname..."
        mkdir -p $DEST/$dirname
      else
        dirname=""
      fi

      metadot_backup "$dirname/$destname"

      #echo "Installing symlink $dirname/$destname..."
      ln -s $MODULES/$module/$file $DEST/$dirname/$destname

    done
  else
    echo "No such module $module"
  fi
}

# Load a module
function metadot_deps {
  local module="$1"
  local destname
  local dirname
  local deps_to_install

  if [ -d "$MODULES/$module" ]; then
    echo "Resolving dependencies for $module.."

    if [ -e "/etc/debian_version" ] && [ -e "$MODULES/$module/dependencies/debian" ]; then
      deps="`grep -v '^#' $MODULES/$module/dependencies/debian | xargs`"

      # Remove installed packages from list
      for dep in $deps; do
        if ! dpkg-query -W -f='${Status}' $dep | grep -q '^install ok'; then
          deps_to_install="$deps_to_install $dep"
        fi
      done

      LC_ALL=C DEBIAN_FRONTEND=noninteractive sudo apt-get install -y $deps_to_install
    fi

  else
    echo "No such module $module"
  fi
}

# Create a new module
function metadot_create {
  mkdir -p $MODULES/$1
  (
    cd $MODULES/$1
    git init

    echo "# $1 dotfile module"                                 > README.md
    echo ""                                                   >> README.md
    echo "This is the repository for $1 configuration."       >> README.md
    echo "More information at https://git.fluxo.info/metadot" >> README.md

    #echo "TODO"                > TODO.md
    #echo "===="               >> TODO.md
    #echo ""                   >> TODO.md
    #echo "* Nothing here? :P" >> TODO.md

    echo "# As we are handling with config files, it might be better to"  > .gitignore
    echo "# use a paranoid config by default."                           >> .gitignore
    echo "#"                                                             >> .gitignore
    echo "# Comment that while in development."                          >> .gitignore
    echo '*'                                                             >> .gitignore

    cp $DIRNAME/LICENSE .

    git add -f .
  )
  echo "Metadot skeleton module $1 created at $MODULES/$1"
}

# Fetch dotfiles
function metadot_fetch {
  if [ -d "$DOT/.git" ]; then
    ( cd $DOT && $GIT fetch --all && $GIT log --show-signature -n 1 --remotes --branches=origin/master )
  fi
}

# Merge
function metadot_merge {
  if [ -d "$DOT/.git" ]; then
    (
    cd $DOT && $GIT merge origin/master                 && \
               $GIT submodule sync          --recursive && \
               $GIT submodule update --init --recursive
    )
  fi
}

# Update your dotfiles
function metadot_update {
  echo "please run 'metadot fetch && metadot merge' instead"
  exit 1
  #if [ -d "$DOT/.git" ]; then
  #  ( cd $DOT && git pull origin master && git submodule update --init --recursive )
  #else
  #  for module in `ls $MODULES`; do
  #    ( cd $MODULES/$module && git pull origin master && git submodule update --init --recursive )
  #  done
  #fi
}

# Basic usage
function metadot_usage {
  echo "usage: $BASENAME <option> [arguments]"
  echo ""
  echo "available actions:"
  echo ""
  grep "^function metadot_" $0 | cut -d ' ' -f 2 | sed -e 's/metadot_/\t/' -e 's/_/-/g' | sort
  echo ""
  exit 1
}

# List modules
function metadot_ls {
  ls -1 $MODULES
}

# Clone a module
function metadot_clone {
  shift
  if [ "$1" == "default" ]; then
    metadot_backup $DOT
    git clone --recursive $DEFAULT $DOT
    echo "Backups saved at $BACKUPS."
  elif [ "`basename $1 .git`" == "dotfiles" ]; then
    metadot_backup $DOT
    git clone --recursive $1 $DOT
    echo "Backups saved at $BACKUPS."
  else
    mkdir -p $MODULES
    git clone --recursive $1 $MODULES/`basename $1 .git`
  fi
}

# List installed modules
function metadot_installed {
  # Complete, slow version
  #find $HOME -lname '*.dotfiles*' -exec ls -la {} | \
  #grep .dotfiles/modules | sed -e 's|.*.dotfiles/||g' | cut -d '/' -f 2 | sort | uniq

  # Simple, incomplete version
  ls -ag $HOME/ | grep .dotfiles/modules | sed -e 's|.*.dotfiles/||g' | cut -d '/' -f 2 | sort | uniq
}

# Process modules
function __metadot_process_modules {
  if [ -z "$1" ]; then
    echo "usage: $BASENAME $OPT [module(s)|--all]"
  fi

  if [ "$1" == "--all" ]; then
    modules="`ls $MODULES`"
  else
    modules="$*"
  fi

  for module in $modules; do
    metadot_$OPT $module
  done

  if [ "$OPT" == "load" ]; then
    echo "Backups saved at $BACKUPS."
  fi
}

# Process bundle
function __metadot_process_bundle {
  local bundle="$1"
  local dependency
  local option

  if [ -z "$bundle" ]; then
    echo "usage: $BASENAME $OPT [bundle]"
    exit 1
  fi

  if [ ! -e "$DOT/bundles/$bundle" ]; then
    echo "$BASENAME: bundle not found: $bundle"
    exit 1
  fi

  cat $DOT/bundles/$bundle | while read item; do
    if echo $item | grep -q "^bundles/"; then
      option="$OPT"
      dependency="`echo $item | sed -e 's|bundles/||g'`"
    elif echo $item | grep -q "^modules/"; then
      option="`echo $OPT | sed -e 's|-bundle||g'`"
      dependency="`echo $item | sed -e 's|modules/||g'`"
    else
      echo "Skipping invalid item $item..."
      continue
    fi

    $DIRNAME/$BASENAME $option $dependency
  done
}

# Display bundle contents
function metadot_ls_bundle {
  local bundle="$1"

  if [ -z "$bundle" ] && [ -d "$DOT/bundles" ]; then
    ls $DOT/bundles
    exit
  fi

  if [ ! -e "$DOT/bundles/$bundle" ]; then
    echo "$BASENAME: bundle not found: $bundle"
    exit 1
  fi

  cat $DOT/bundles/$bundle
}

# Display version
function metadot_version {
  echo "master branch:"
  echo "=============="
  echo ""
  ( cd $DOT && $GIT log --show-signature -n 1 )

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

# Load a bundle
function metadot_load_bundle {
  __metadot_process_bundle $*
}

# Process bundle dependencies
function metadot_deps_bundle {
  __metadot_process_bundle $*
}

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

# Parsing
if [ -z "$OPT" ]; then
  metadot_usage
elif [ "$OPT" == "usage" ]; then
  metadot_usage
elif [ "$OPT" == "ls" ]; then
  metadot_ls
elif [ "$OPT" == "ls-bundle" ]; then
  shift
  metadot_ls_bundle $*
elif [ "$OPT" == "version" ]; then
  metadot_version
elif [ "$OPT" == "update" ]; then
  metadot_update
elif [ "$OPT" == "backup" ]; then
  shift
  metadot_backup $*
elif [ "$OPT" == "clone" ]; then
  metadot_clone $*
elif [ "$OPT" == "create" ]; then
  shift
  metadot_create $*
elif [ "$OPT" == "load" ] || [ "$OPT" == "deps" ]; then
  shift
  __metadot_process_modules $*
elif [ "$OPT" == "load-bundle" ]; then
  shift
  metadot_load_bundle $*
elif [ "$OPT" == "deps-bundle" ]; then
  shift
  metadot_deps_bundle $*
elif [ "$OPT" == "installed" ]; then
  metadot_installed
elif [ "$OPT" == "fetch" ]; then
  metadot_fetch
elif [ "$OPT" == "merge" ]; then
  metadot_merge
elif [ "$OPT" == "status" ]; then
  metadot_status
else
  metadot_usage
fi