setup

#!/bin/bash
# Install all dotfiles into the home directory

set -eo pipefail

SKIP_AFTER_SETUP=
if [[ "${1:-}" = "--skip-after-setup" ]]; then
  SKIP_AFTER_SETUP=1
  shift
fi

if [[ -L "$0" ]]; then
  SCRIPTSETUP="$(readlink "$0")"
else
  SCRIPTSETUP="$0"
fi

DOTFILESDIRREL="${SCRIPTSETUP%/*}"
[[ "${DOTFILESDIRREL}" = "${SCRIPTSETUP}" ]] && DOTFILESDIRREL="."
cd "${DOTFILESDIRREL}"/.. || exit
DOTFILESDIR=$(pwd -P)

UNAME_S="$(uname -s)"
[[ "${UNAME_S}" = "Darwin" ]] && export MACOS=1
[[ "${UNAME_S}" = "Linux" ]] && export LINUX=1
[[ "${UNAME_S}" == *_NT-* ]] && export WINDOWS=1
[[ -n "${LINUX}" ]] && grep -qEi "(Microsoft|WSL)" /proc/version && export WSL=1
command -v "brew" &>/dev/null && brew list --cask superset &>/dev/null && export SUPERSET=1

VSCODES=()
CURSORS=()
ZEDS=()

if [[ -n "${MACOS}" ]]; then
  VSCODES=("${HOME}/Library/Application Support/Code/User")
  CURSORS=("${HOME}/Library/Application Support/Cursor/User")
  ZEDS=("${HOME}/.config/zed")
elif [[ -n "${LINUX}" ]]; then
  VSCODES=("${HOME}/.config/Code/User")
  CURSORS=("${HOME}/.config/Cursor/User")
  ZEDS=("${HOME}/.config/zed")
  if [[ -n "${WSL}" && -d "/mnt/c/Users/${USER}" ]]; then
    VSCODES+=("/mnt/c/Users/${USER}/AppData/Roaming/Code/User")
    CURSORS+=("/mnt/c/Users/${USER}/AppData/Roaming/Cursor/User")
    ZEDS+=("/mnt/c/Users/${USER}/AppData/Roaming/Zed")
  fi
elif [[ -n "${WINDOWS}" ]]; then
  VSCODES=("${APPDATA}/Code/User")
  CURSORS=("${APPDATA}/Cursor/User")
  ZEDS=("${APPDATA}/Zed")
  set -x
fi

for DOTFILE in *; do
  HOMEFILE="${HOME}/.${DOTFILE}"
  HOMEFILES=()
  if [[ -d "${DOTFILE}" ]]; then
    DOTFILE="${DOTFILE}/"
    IS_DIR=1
  else
    IS_DIR=
  fi
  DIRFILE="${DOTFILESDIR}/${DOTFILE}"

  # Don't mess with Codespaces' default SSH setup.
  if [[ -n "${CODESPACES}" && "${DOTFILE}" = "ssh/" ]]; then
    continue
  fi

  # Don't try to install some unneeded paths
  case "${DOTFILE}" in
    bin/|bundle/|claude/|codex/|homebrew/|script/|tmp/|opencode.json|*.txt|*.md)
      continue
      ;;
  esac

  # Only install host-specific files on matching hosts
  case "${DOTFILE}" in
    gitconfig.local.macos|gitconfig.local.wsl|gitconfig.local.linux)
      case "${DOTFILE}" in
        gitconfig.local.macos)
          [[ -z "${MACOS}" ]] && continue
          ;;
        gitconfig.local.wsl)
          [[ -z "${WSL}" ]] && continue
          ;;
        gitconfig.local.linux)
          [[ -z "${LINUX}" || -n "${CODESPACES}" || -n "${WSL}" ]] && continue
          ;;
      esac
      HOMEFILE="${HOME}/.gitconfig.local"
      ;;
    crontab.macos)
      [[ -z "${MACOS}" ]] && continue
      HOMEFILE="${HOME}/.crontab"
      ;;
    *vscode-settings*)
      for VSCODE in "${VSCODES[@]}"; do
        HOMEFILES+=("${VSCODE}/settings.json")
        [[ -d "${VSCODE}" ]] || mkdir -p "${VSCODE}"
      done
      ;;
    *cursor-settings*)
      for CURSOR in "${CURSORS[@]}"; do
        HOMEFILES+=("${CURSOR}/settings.json")
        [[ -d "${CURSOR}" ]] || mkdir -p "${CURSOR}"
      done
      ;;
    *cursor-keybindings*)
      for CURSOR in "${CURSORS[@]}"; do
        HOMEFILES+=("${CURSOR}/keybindings.json")
        [[ -d "${CURSOR}" ]] || mkdir -p "${CURSOR}"
      done
      ;;
    *zed-settings*)
      for ZED in "${ZEDS[@]}"; do
        HOMEFILES+=("${ZED}/settings.json")
        [[ -d "${ZED}" ]] || mkdir -p "${ZED}"
      done
      ;;
  esac

  if [[ "${DOTFILE}" = *.sh ]]; then
    HOMEFILE="${HOME}/.${DOTFILE%.sh}"
  fi

  case "${DOTFILE}" in
    *rubocop-work.yml)
      HOMEWORK="${HOME}/Work"
      [[ -d "${HOMEWORK}" ]] || continue
      HOMEFILE="${HOMEWORK}/.rubocop.yml"
      ;;
    *rubocop-oss.yml)
      HOMEOSS="${HOME}/OSS"
      [[ -d "${HOMEOSS}" ]] || continue
      HOMEFILE="${HOMEOSS}/.rubocop.yml"
      ;;
  esac

  [[ "${#HOMEFILES[@]}" -gt 0 ]] || HOMEFILES=("${HOMEFILE}")

  for HOMEFILE in "${HOMEFILES[@]}"; do
    LINKFILE="${DIRFILE}"

    if [[ -z "${IS_DIR}" ]]; then
      if [[ -n "${WSL}" && "${HOMEFILE}" = /mnt/* ]]; then
        cmp -s "${HOMEFILE}" "${DIRFILE}" && continue
        rm -rf "${HOMEFILE}" 2>/dev/null || true
        cp -fv "${DIRFILE}" "${HOMEFILE}"
        continue
      fi
      [[ "${HOMEFILE}" -ef "${DIRFILE}" ]] && continue
      if [[ -L "${HOMEFILE}" ]]; then
        ln -sf "${LINKFILE}" "${HOMEFILE}"
      elif [[ -d "${HOMEFILE}" ]]; then
        rm -rfv "${HOMEFILE}" 2>/dev/null
        ln -sv "${LINKFILE}" "${HOMEFILE}"
      else
        ln -svf "${LINKFILE}" "${HOMEFILE}"
      fi
    elif [[ "${HOMEFILE}" -ef "${DIRFILE}" ]]; then
      continue
    elif [[ -L "${HOMEFILE}" ]]; then
      rm -r "${HOMEFILE}" 2>/dev/null
      ln -s "${LINKFILE}" "${HOMEFILE}"
    else
      rm -rfv "${HOMEFILE}" 2>/dev/null
      ln -sv "${LINKFILE}" "${HOMEFILE}"
    fi
  done
done

if [[ -L "${HOME}/.cursor-keybindings.json" &&
      "$(readlink "${HOME}/.cursor-keybindings.json")" = "${DOTFILESDIR}/cursor-keybindings.json" ]]; then
  rm -v "${HOME}/.cursor-keybindings.json"
fi

HOMEDOTFILES="${HOME}/.dotfiles"
if ! [[ "${HOMEDOTFILES}" -ef "${DOTFILESDIR}" ]]; then
  rm -f "${HOMEDOTFILES}"
  ln -sf "${DOTFILESDIR}" "${HOMEDOTFILES}"
fi

link_if_needed() {
  [[ -d "${1%/*}" ]] || mkdir -p "${1%/*}"
  if [[ "${1}" -ef "${2}" ]]; then
    return
  elif [[ -L "${1}" ]]; then
    ln -sf "${2}" "${1}"
  else
    ln -svf "${2}" "${1}"
  fi
}

link_if_needed "${HOME}/.homebrew/trust.json" "${DOTFILESDIR}/homebrew/trust.json"
link_if_needed "${HOME}/.config/opencode/opencode.json" "${DOTFILESDIR}/opencode.json"
if [[ -n "${SUPERSET}" ]]; then
  link_if_needed "${HOME}/.superset/hooks/opencode/opencode.json" "${DOTFILESDIR}/opencode.json"
fi
if [[ -n "${MACOS}" ]]; then
  crontab "${DOTFILESDIR}/crontab.macos"
fi

dotdir_files() {
  find "${1}" -type f | sort
}

merge_codex_statusline_config() {
  command -v "ruby" &>/dev/null || return
  "${DOTFILESDIR}/bin/toml-merge" "${1}/.codex/config.toml" "${DOTFILESDIR}/codex/statusline.config.toml"
}

chown_sandvault_if_needed() {
  [[ -e "${1}" ]] || return
  if [[ "$(/usr/bin/stat -f "%Su:%Sg" "${1}")" != "${SANDVAULT_USER}:${SANDVAULT_USER}" ]]; then
    sudo /usr/sbin/chown "${SANDVAULT_USER}:${SANDVAULT_USER}" "${1}"
  fi
}

AGENTS_GLOBAL="${DOTFILESDIR}/AGENTS-GLOBAL.md"
for HOMEFILE in "${HOME}/.claude/CLAUDE.md" "${HOME}/.codex/AGENTS.md"; do
  link_if_needed "${HOMEFILE}" "${AGENTS_GLOBAL}"
done

for DOTDIR in claude codex; do
  for DOTFILE in $(dotdir_files "${DOTDIR}"); do
    if [[ "${DOTFILE}" = "codex/hooks.json" && -z "${SUPERSET}" ]]; then
      if [[ -L "${HOME}/.${DOTFILE}" && "$(readlink "${HOME}/.${DOTFILE}")" = "${DOTFILESDIR}/${DOTFILE}" ]]; then
        rm -v "${HOME}/.${DOTFILE}"
      fi
      continue
    fi
    link_if_needed "${HOME}/.${DOTFILE}" "${DOTFILESDIR}/${DOTFILE}"
  done
done

merge_codex_statusline_config "${HOME}"

# Setup my home directory how I like it
[[ -d ~/OSS ]] || mkdir -pv ~/OSS
if ! [[ -d ~/OSS/dotfiles ]]; then
  ln -vsf "${DOTFILESDIR}" ~/OSS/dotfiles
fi

# Helper function to copy a file only when its contents change
sync_if_changed() {
  if ! [[ -f "${2}" ]] || ! cmp -s "${1}" "${2}"; then
    cp -vf "${1}" "${2}"
  fi
}

if command -v "brew" >/dev/null; then
  if ! [[ -d ~/OSS/Homebrew ]]; then
    ln -vsf "$(brew --repository)" ~/OSS/Homebrew
  fi

  # Sync selected dotfiles into Sandvault guest home if that directory exists.
  if command -v "sv" >/dev/null; then
    SANDVAULT_USER="sandvault-${USER}"
    SANDVAULT_GUEST_HOME="/Users/Shared/sv-${USER}/user"
    SANDVAULT_HOME="/Users/${SANDVAULT_USER}"
    mkdir -p "${SANDVAULT_GUEST_HOME}"

    for i in shrc shprofile logout zprofile zshrc zlogout; do
      sync_if_changed "${DOTFILESDIR}/${i}.sh" "${SANDVAULT_GUEST_HOME}/.${i}"
    done

    for i in gitconfig gitconfig.local.gh-credential gitignore; do
      sync_if_changed "${DOTFILESDIR}/${i}" "${SANDVAULT_GUEST_HOME}/.${i}"
    done
    sync_if_changed "${DOTFILESDIR}/gitconfig.local.sandvault" "${SANDVAULT_GUEST_HOME}/.gitconfig.local"
    [[ -d "${SANDVAULT_GUEST_HOME}/.config/opencode" ]] || mkdir -p "${SANDVAULT_GUEST_HOME}/.config/opencode"
    sync_if_changed "${DOTFILESDIR}/opencode.json" "${SANDVAULT_GUEST_HOME}/.config/opencode/opencode.jsonc"
    [[ -d "${SANDVAULT_GUEST_HOME}/.homebrew" ]] || mkdir -p "${SANDVAULT_GUEST_HOME}/.homebrew"
    sync_if_changed "${DOTFILESDIR}/homebrew/trust.json" "${SANDVAULT_GUEST_HOME}/.homebrew/trust.json"

    for DOTDIR in bundle claude codex; do
      for DOTFILE in $(dotdir_files "${DOTDIR}"); do
        [[ "${DOTFILE}" = "codex/hooks.json" ]] && continue
        [[ -d "${SANDVAULT_GUEST_HOME}/.${DOTFILE%/*}" ]] || mkdir -p "${SANDVAULT_GUEST_HOME}/.${DOTFILE%/*}"
        sync_if_changed "${DOTFILESDIR}/${DOTFILE}" "${SANDVAULT_GUEST_HOME}/.${DOTFILE}"
      done
    done

    if [[ -n "${SUPERSET}" && -f "${HOME}/.superset/hooks/notify.sh" ]]; then
      [[ -d "${SANDVAULT_GUEST_HOME}/.superset/hooks" ]] || mkdir -p "${SANDVAULT_GUEST_HOME}/.superset/hooks"
      sync_if_changed "${HOME}/.superset/hooks/notify.sh" "${SANDVAULT_GUEST_HOME}/.superset/hooks/notify.sh"

      [[ -d "${DOTFILESDIR}/tmp" ]] || mkdir -p "${DOTFILESDIR}/tmp"
      sed \
        -e "s|${HOME}/|/Users/sandvault-${USER}/|g" \
        -e "s|/Users/${USER}/|/Users/sandvault-${USER}/|g" \
        "${DOTFILESDIR}/codex/hooks.json" > "${DOTFILESDIR}/tmp/sandvault-codex-hooks.json"
      sync_if_changed "${DOTFILESDIR}/tmp/sandvault-codex-hooks.json" "${SANDVAULT_GUEST_HOME}/.codex/hooks.json"
    fi

    for i in ".claude/CLAUDE.md" ".codex/AGENTS.md"; do
      sync_if_changed "${AGENTS_GLOBAL}" "${SANDVAULT_GUEST_HOME}/${i}"
    done

    if cmp -s "${SANDVAULT_GUEST_HOME}/.codex/config.toml" "${DOTFILESDIR}/codex/statusline.config.toml"; then
      rm -v "${SANDVAULT_GUEST_HOME}/.codex/config.toml"
    fi

    merge_codex_statusline_config "${SANDVAULT_GUEST_HOME}"

    if [[ -d "${SANDVAULT_HOME}" ]]; then
      for i in ".claude" ".codex" ".codex/rules" ".codex/config.toml" ".claude/CLAUDE.md" ".codex/AGENTS.md"; do
        chown_sandvault_if_needed "${SANDVAULT_HOME}/${i}"
      done

      for DOTDIR in claude codex; do
        for DOTFILE in $(dotdir_files "${DOTDIR}"); do
          chown_sandvault_if_needed "${SANDVAULT_HOME}/.${DOTFILE}"
        done
      done
    fi
  fi
fi

if [[ -n "${LINUX}" && -z "${SKIP_AFTER_SETUP}" ]]; then
  exec script/linux-after-setup
elif [[ -n "${CI}" && -n "${MACOS}" ]]; then
  exec script/strap-after-setup
fi