zk

#!/bin/bash
set -e
RED='\033[0;31m'
NC='\033[0m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m' 
zk_config="$HOME/.zettelkasten"


# multi-lined strings
USAGE=$(cat <<-END

Usage:	zk COMMAND

A note taking application following the Zettelkasten method.

Commands:
  n, new            Create a new zettel and use default editor
  nv, new-vi        Create a new zettel and edit with vi
  ne, new-emacs     Create a new zettel and edit with emacs
  nc, new-code      Create a new zettel and edit with Visual Studio Code
  o, open           Open an existing zettel in default editor
  ov, open-vi       Open an existing zettel in vi
  oe, open-emacs    Open an existing zettel in emacs
  oc, open-code     Open an existing zettel in Visual Studio Code
  ob, open-browser  Open an existing zettel in github using OS default browser
  p, push           Push zettels to GitHub
  c, cat            Print an existing zettel to terminal
  t, tag            Search zettels for a specific tag
  s, search         Search for a sub string within all zettels
  ls, list          List all zettels
  rm, remove        Remove a zettel
  ln, link          Link 2 zettels together
  rml, rm-link      Remove a link between 2 zettels
  home              Display zettelkasten home directory
  init              Initialize the $HOME/.zettelkasten
  variables         List all variables defined in $HOME/.zettelkasten
  update            Update to latest zk script
  add, add-media    Add specific media (images, music, pdf, etc) to kasten
  lsm, list-media   List all media zettels
  sync              Sync local zettelkasten with git zettelkasten
END
)

function new_zettel_default() {
  zettel_title="$1"
  default_tags=""
  zettel_template=$(cat <<-END
$zettel_title
$default_tags



## Links
END
)
  echo "$zettel_template"
}

# -- utils --
function echo_usage() {
  echo "$USAGE"
}

function fail() {
  echo -e "${RED}ERROR: $1${NC}" > /dev/tty
  exit 1
}

function echo_green() {
	echo -e "${GREEN}${1}${NC}" > /dev/tty
}

function echo_yellow() {
	echo -e "${YELLOW}${1}${NC}" > /dev/tty
}

function list_zettels() {
  set +e
  echo "$(find $ZETTELKASTEN_DIR  -type f -exec basename {} \;)"  > /dev/tty
  set -e
}

function find_zettel() {
  # validate search field were procided and create search fields for grep
  search_fields="$1"
  search_media="${2:-no}"
  if [[ -z "$search_fields" ]];then
    list_zettels
    fail "Could not find a zettel because search fields were not provided"
  fi
  search_fields=$(echo "$search_fields" | sed 's/ /|/g' | sed 's/,/|/g')

  # look for the zettel
  set +e
  if [ "$search_media" == "yes" ]; then
    zettels=$(ls -a $ZETTELKASTEN_DIR | grep -e "$search_fields")
  else
    zettels=$(ls $ZETTELKASTEN_DIR | grep -e "$search_fields")
  fi
  set -e

  # validate only 1 zettel was retutned
  if [[ -z "$zettels" ]]; then
    fail "Failed to find a zettel with search criteria '$search_fields'"
  fi
  number_zettels=$(echo "$zettels" | wc -l)
  if [ "$number_zettels" -gt "1" ]; then
    echo "$zettels" > /dev/tty
    fail "Multiple zettle's were returned matching the search criteria."
  fi

  echo "$zettels"
}

function git_push() {
  sync_zettelkasten
  if [[ "$ZETTELKASTEN_AUTO_GIT_PUSH" == "yes" ]]; then
    cwd=$(pwd)
    cd "$ZETTELKASTEN_DIR"
    # echo "$1" > /dev/tty
    git add ${@:2}
    git commit -m "$1" --quiet
    git push --quiet
    cd "$cwd"
  fi
}

function remove_zettel_link() {
  zettel="$1"
  link="$2"
  link="\- \[$link\]($link)"
  line_number=$(cat "$ZETTELKASTEN_DIR/$zettel" | grep -n "$link" | awk -F ':' '{print $1}' | head -n 1)
  sed -i.bak "${line_number}d" "$ZETTELKASTEN_DIR/$zettel"
  rm "$ZETTELKASTEN_DIR/$zettel.bak"
}

function get_os_environment_type() {
  # if '/prov/version' files exists then assume running in 'WSL'
  if [ -f "/proc/version" ]; then
    echo "wsl"
  else
    # default to osx
    echo "osx"
  fi
}

function fail_invalid_environment() {
  fail "Invalid environment '${environment}'. Valid environment: osx or wsl"
}

function get_default() {
  target_environment="${1}"
  current_environment="${2}"
  default_value="${3}"

  if [ "${target_environment}" = "${current_environment}" ]; then
    echo "${default_value}"
  fi
}

function get_default_md5() {
  environment="${1}"
  get_default "osx" "${environment}" "md5"
  get_default "wsl" "${environment}" "md5sum"
}

function get_default_basename() {
  environment="${1}"
  get_default "osx" "${environment}" "basename --"
  get_default "wsl" "${environment}" "basename -a"
}

function get_default_browser() {
  environment="${1}"
  get_default "osx" "${environment}" "open"
  get_default "wsl" "${environment}" "cmd.exe /C start"
}

function get_zettel_md5() {
  zettel="${1}"
  zettel_fname="${ZETTELKASTEN_DIR}/${zettel}"
  cat "$zettel_fname" | $ZETTELKASTEN_MD5_COMMAND
}

function editor_clean_up() {
  zettel="${1}"
  zettel_path="${ZETTELKASTEN_DIR}/${zettel}"

  rm -f "${zettel_path}~"
}

function validate_mandatory_parameter() {
  parameter="${1}"
  usage_message="${2}"
  failure_message="${3}"

  if [ -z "${parameter}" ]; then
    if [ ! -z "${usage_messages}" ]; then
      echo "${usage_message}"
    fi
    fail "${failure_message}"
  fi
}

function get_datestamp() {
  datestamp_format="${ZETTELKASTEN_DATE_TIME_STAMP_FORMAT}"
  if [ -z "${datestamp_format}" ]; then
      datestamp_format="+%s"
  fi
  datestamp=$(date "${datestamp_format}")
  echo "${datestamp}"
}

function validate_dir_is_git_repo() {
  if [ "${ZETTELKASTEN_AUTO_GIT_PUSH}" = "yes" ]; then
    directory="${1}"
    set +e
    cd "${directory}" && git rev-parse --is-inside-work-tree &>/dev/null
    if [ "${?}" != "0" ]; then
      fail "'${directory}' is not a git repository. If you do not want to use git set 'ZETTELKASTEN_AUTO_GIT_PUSH' in the '${zk_config}' to no."
    fi
    set -e
  fi
}

# -- commands --
function new_editor() {
  editor="${1}"
  title="${@:2}"

  # validate mandatory parameter
  usage="usage: $0 new <zettel title>"
  validate_mandatory_parameter "${title}" "${usage}" "Zettel title not provided"

  title=$(echo "$title" | sed 's/ /-/g')
  now=$(get_datestamp)
  zettel_title="# $now $title"
  zettel="$now-$title.md"
  zettel_fname="$ZETTELKASTEN_DIR/${zettel}"
  if [ -f "$zettel_fname" ]; then
    fail "zettel '$zettel_fname' already exists"
  fi

  zettel_template=$(new_zettel_default "$zettel_title")
  touch "$zettel_fname"
  echo "$zettel_template" > "$zettel_fname"

  before=$(get_zettel_md5 "${zettel}")
  $editor "$zettel_fname"
  after=$(get_zettel_md5 "${zettel}")

  if [[ "$before" != "$after" ]]; then
    git_push "added zettel ${zettel}" "${zettel_fname}"
    echo_green "created zettel '${zettel}'"
  else
    rm -f $zettel_fname
    echo_yellow "WARNING: Zettel was not created since the contents are empty"
  fi
  editor_clean_up "${zettel}"
}

function add_media() {
  media_file_path="${1}"

  usage="usage: $0 add-media <media file path>"
  error_message="Media file path not provided"
  validate_mandatory_parameter "${media_file_path}" "${usage}" "${error_message}"

  if [ ! -f "${media_file_path}" ]; then
    fail "'${media_file_path}' is not a valid file path!"
  fi

  basename=$($ZETTELKASTEN_BASENAME_COMMAND $(echo "${media_file_path}"))
  now=$(get_datestamp)

  media_zettel_name=".${now}-${basename}"
  media_fname="${ZETTELKASTEN_DIR}/${media_zettel_name}"

  cp "${media_file_path}" "${media_fname}"
  git_push "added zettel media ${media_zettel_name}" "${media_fname}"
  echo_green "added zettel media '${media_zettel_name}'"
}

function open_editor() {
  editor="${1}"
  search_fields="${2}"
  zettel=$(find_zettel "$search_fields" || exit)
  
  before=$(get_zettel_md5 "${zettel}")
  $editor "$ZETTELKASTEN_DIR/$zettel"
  after=$(get_zettel_md5 "${zettel}")
  
  if [[ "$before" != "$after" ]]; then
    git_push "updating zettel $zettel" "$zettel"
    echo_green "updated '$zettel'"
  fi
  editor_clean_up "${zettel}"
}

function open_media() {
  zettel="${1}"
  open "$ZETTELKASTEN_DIR/${zettel}"
}

function open_command() {
  editor="${1}"
  search_fields="${2}"

  # if found zettel starts with '.' then open as if it were media
  zettel=$(find_zettel "$search_fields" "yes" || exit)
  if [[ "$zettel" == .* ]]; then
    open_media "${zettel}"
    exit 0
  fi

  open_editor "${editor}" "${search_fields}"
}

function open_browser() {
  search_fields="$1"
  zettel=$(find_zettel "$search_fields" "yes" || exit)
  remote_url=$(cd $ZETTELKASTEN_DIR && git config --get remote.origin.url)
  # if remote_url contains a @ that means the repo was cloned using ssh key
  if [[ "$remote_url" = *"@"* ]]; then
    github_endpoint=$(echo "${remote_url}" | awk -F ':' '{print $2}')
  else
    github_endpoint=$(echo "${remote_url}" | awk -F '.com/' '{print $2}')
  fi
  github_endpoint=$(echo "${github_endpoint}" | sed 's/.git//g')
  $ZETTELKASTEN_BROWSER_COMMAND "https://github.com/$github_endpoint/tree/master/$ZETTELKASTEN_GIT_DIR/$zettel"
}

function push() {
    cwd=$(pwd)
    cd "$ZETTELKASTEN_DIR"
    msg="Regenerated at $(get_datestamp)"
    git add .
    git commit -m "$msg"
    git push --quiet
    cd "$cwd";
}

function link() {
  from_link=$1
  to_link=$2

  # validate mandatory parameters
  usage="usage: $0 link 1584648495 1584648508"
  validate_mandatory_parameter "${from_link}" "${usage}" "Empty from_link parameter"
  validate_mandatory_parameter "${to_link}" "${usage}" "Empty to_link parameter"

  from_fname=$(find_zettel "$from_link" "yes")
  to_fname=$(find_zettel "$to_link" "yes")
  
  # if file starts with '.' then assume it is media and it is not possible
  # to create link on a media file
  if [[ "$to_fname" != .* ]]; then
    echo "- [$from_fname]($from_fname)" >> "$ZETTELKASTEN_DIR/$to_fname"
  fi
  if [[ "$from_fname" != .* ]]; then
    echo "- [$to_fname]($to_fname)" >> "$ZETTELKASTEN_DIR/$from_fname"
  fi

  git_push \
    "added link between $from_fname and $to_fname" \
    "$from_fname" \
    "$to_fname"
  
  echo_green "linked zettels $to_fname <---> $from_fname"
}

function rm_link() {
  from_link=$1
  to_link=$2

  # validate mandatory parameters
  usage="usage: $0 link 1584648495 1584648508"
  validate_mandatory_parameter "${from_link}" "${usage}" "Empty from_link parameter"
  validate_mandatory_parameter "${to_link}" "${usage}" "Empty to_link parameter"

  # get zettel file names
  from_fname=$(find_zettel "$from_link")
  to_fname=$(find_zettel "$to_link")

  # remove the zettel links from both files
  remove_zettel_link $from_fname $to_fname
  remove_zettel_link $to_fname $from_fname

  git_push \
    "remove link between $from_fname and $to_fname" \
    "$from_fname" \
    "$to_fname"

  echo_green "removed link $to_fname <---> $from_fname"
}

function home() {
  new_home_dir=$1
  # if new home dir is empty then print out dir
  if [[ -z "$new_home_dir" ]]; then
    echo "Current Zettel directory: $ZETTELKASTEN_DIR"
  else
    echo "export ZETTELKASTEN_DIR=\"$new_home_dir\""
  fi
}

function append_to_zettelkasten_config() {
  key="${1}"
  value="${2}"

  echo "${key}=\"${value}\"" >> "${zk_config}"
}

function init() {
  read -p "Zettelkasten Directory: " zk_dir
  read -p "Zettelkasten auto git push[yes/no]: " zk_auto_git_push
  read -p "Zettelkasten git directory(optional): " zk_git_dir
  read -p "Default command line text editor[vi/emacs/nano]: " zk_text_editor

  if [ -z "${zk_text_editor}" ]; then
    zk_text_editor="vi"
  fi

  if [ ! -d "${zk_dir}" ]; then
    fail "Directory '${zk_dir}' does not exist"
  fi

  zk_auto_git_push=$(echo $zk_auto_git_push | tr '[:upper:]' '[:lower:]')
  if [[ "${zk_auto_git_push}" != "yes" ]]; then
    zk_auto_git_push="no"
  fi
  validate_dir_is_git_repo "${zk_git_dir}"

  environment=$(get_os_environment_type)
  md5_command=$(get_default_md5 "${environment}")
  basename_command=$(get_default_basename "${environment}")
  browser_command=$(get_default_browser "${environment}")
  rm -f "${zk_config}"

  # the values specified in the '~/.zettelkasten'
  # the directory in which all zettels reside
  append_to_zettelkasten_config "ZETTELKASTEN_DIR" "${zk_dir}"
  # auto push zettels to git when created, updated or deleted [yes|no]
  append_to_zettelkasten_config "ZETTELKASTEN_AUTO_GIT_PUSH" "${zk_auto_git_push}"
  # the directory in the git repo where the zettels reside. 
  # if zettels reside on repo root level then this does not need to be provided
  # this is only used when executing 'open-browser'
  append_to_zettelkasten_config "ZETTELKASTEN_GIT_DIR" "${zk_git_dir}"
  # the os environment in which the zk application is being run [osx|wsl]
  append_to_zettelkasten_config "ZETTELKASTEN_ENVIRONMENT" "${environment}"
  # the command used when md5 hashing zettels
  append_to_zettelkasten_config "ZETTELKASTEN_MD5_COMMAND" "${md5_command}"
  # the command used when getting the basename of zettels
  append_to_zettelkasten_config "ZETTELKASTEN_BASENAME_COMMAND" "${basename_command}"
  # the command used when using 'open-browser'
  append_to_zettelkasten_config "ZETTELKASTEN_BROWSER_COMMAND" "${browser_command}"
  # the command used when using 'open'
  append_to_zettelkasten_config "ZETTELKASTEN_DEFAULT_TEXT_EDITOR" "${zk_text_editor}"
  # the datetime stamp format used when creating the zettels
  append_to_zettelkasten_config "ZETTELKASTEN_DATE_TIME_STAMP_FORMAT" "+%s"
  # the vi command
  append_to_zettelkasten_config "ZETTELKASTEN_VI_COMMAND" "vi +2"
  # the emacs command
  append_to_zettelkasten_config "ZETTELKASTEN_EMACS_COMMAND" "emacs +2"
  # the visual studio code command
  append_to_zettelkasten_config "ZETTELKASTEN_VISUAL_STUDIO_CODE_COMMAND" "code --new-window --wait"
}

# perform a 'git pull' in the kasten directory
function sync_zettelkasten() {
  if [[ "$ZETTELKASTEN_AUTO_GIT_PUSH" == "yes" ]]; then
    cd $ZETTELKASTEN_DIR && git pull
    # after performing a git pull push all files that have been left behind
    # this should not need to be done but currently every once and a while a zettel is not pushed
    # after it has been created
    # untrackedFiles=$(cd $ZETTELKASTEN_DIR && git status -s || awk '{print $2}')
    # for file in $untrackedFiles; do
    #   cd $ZETTELKASTEN_DIR && git_push "Added zettel ${file}" "${file}"
    # done
  fi
}

# remove a specific zettel and make sure this is reflected in git
function remove() {
  search_fields="$1"
  zettel=$(find_zettel "$search_fields" || exit)
  rm -f "$ZETTELKASTEN_DIR/$zettel"
  git_push "removing zettel $zettel" "$zettel"
  echo_green "removed zettel $zettel"
}

function find_tag() {
  tag="${1}"
  tag="#${tag}\s"
  search_content "${tag}"
}

function search_content() {
  sub_string="${1}"
  result=$(grep -rnl "$ZETTELKASTEN_DIR" -e "${sub_string}" | sort | grep "^[^.]")
  if [[ ! -z $result ]]; then
    $ZETTELKASTEN_BASENAME_COMMAND $(echo "$result")
  fi
}

function list() {
  ls $ZETTELKASTEN_DIR | grep "^[^.]"
}

function list_media() {
  set +e
  find $ZETTELKASTEN_DIR -type f -exec basename {} \; | sort | grep "^\."
  set -e
}

function variables() {
  cat $HOME/.zettelkasten
}

function update() {
  SOURCE_PATH="/usr/local/bin/zk"
  SOURCE_URL="https://raw.githubusercontent.com/AndrewCopeland/zettelkasten/master/zk"
  current_zk_hash=$(cat $SOURCE_PATH | $ZETTELKASTEN_MD5_COMMAND)
  latest_zk=$(curl --fail -s $SOURCE_URL)
  latest_zk_hash=$(echo "${latest_zk}" | $ZETTELKASTEN_MD5_COMMAND)

  if [ "${current_zk_hash}" = "${latest_zk_hash}" ]; then
    echo_yellow "Latest '$SOURCE_PATH' script is already installed"
    exit 0
  fi

  echo "${latest_zk}" > $SOURCE_PATH
  chmod +x $SOURCE_PATH

  echo_green "Successfully updated '$SOURCE_PATH' to the latest version"
}

function random() {
  zettel=$(ls $ZETTELKASTEN_DIR | sort -R | head -n 1)
  open_browser "${zettel}"
}

function main() {
  action="${1}"

  # if action is init create the ~/.zettelkasten config file and exit
  if [ "${action}" = "init" ]; then
    init
    exit 0
  fi
  # if config does not exist then prompt user to run 'zk init'
  if [ ! -f "${zk_config}" ]; then
    echo "'${zk_config}' could not be found"
    echo "run 'zk init' to initialize the zettelkasten config"
    exit 1
  fi
  source "${zk_config}"
  validate_dir_is_git_repo "${ZETTELKASTEN_DIR}"

  # perform zettel actions
  # sync_zettelkasten &>/dev/null
  case $action in
    "new" | "n")
      new_editor "${ZETTELKASTEN_DEFAULT_TEXT_EDITOR}" "${@:2}"
      ;;

    "new-vi" | "nv")
      new_editor "${ZETTELKASTEN_VI_COMMAND}" "${@:2}"
      ;;

    "new-emacs" | "ne")
      new_editor "${ZETTELKASTEN_EMACS_COMMAND}" "${@:2}"
      ;;
    
    "new-code" | "nc")
      new_editor "${ZETTELKASTEN_VISUAL_STUDIO_CODE_COMMAND}" "${@:2}"
      ;;

    "open" | "o")
      open_command "${ZETTELKASTEN_DEFAULT_TEXT_EDITOR}" "${2}"
      ;;

    "open-vi" | "ov")
      open_editor "${ZETTELKASTEN_VI_COMMAND}" "${2}"  
      ;;

    "open-emacs" | "oe")
      open_editor "${ZETTELKASTEN_EMACS_COMMAND}" "${2}" 
      ;;

    "open-code" | "oc")
      open_editor "${ZETTELKASTEN_VISUAL_STUDIO_CODE_COMMAND}" "$2"
      ;;

    "open-browser" | "ob")
      open_browser "$2"
      ;;

    "push" | "p")
      push
      ;;

    "cat" | "c")
      open_editor "cat" "$2"
      ;;

    "link" | "ln")
      link "$2" "$3"
      ;;

    "remove-link" | "rm-link" | "rml")
      rm_link "$2" "$3"
      ;;

    "remove"  | "rm")
      remove "$2"
      ;;

    "tag" | "t")
      find_tag "$2"
      ;;

    "search"| "s")
      search_content "${2}"
      ;;
    
    "list" | "ls")
      list
      ;;

    "home")
      home "$2"
      ;;

    "variables")
      variables
      ;;

    "update")
      update
      ;;

    "add-media" | "add")
      add_media "$2"
      ;;

    "list-media" | "lsm")
      list_media
      ;;

    "sync")
      sync_zettelkasten
      ;;

    "random")
      random
      ;;

    *)
      echo "Invalid action '$action' check usage below."
      echo_usage
      ;;
  esac
}

main $@