setup

#!/usr/bin/env zsh
set -e

DOTFILES=$HOME/.dotfiles
source "$DOTFILES/zsh/tool_packages.zsh"

# --- argument parsing ---
DRY_RUN=0
for arg in "$@"; do
  case $arg in
    --dry-run) DRY_RUN=1 ;;
    *)
      echo "Usage: setup [--dry-run]" >&2
      exit 1
      ;;
  esac
done

# --- dry-run helpers ---
dry_mkdir() {
  if (( DRY_RUN )); then
    echo "[dry-run] mkdir -p $1"
  else
    mkdir -p "$1"
  fi
}

dry_rm() {
  if (( DRY_RUN )); then
    echo "[dry-run] rm -f $@"
  else
    rm -f "$@"
  fi
}

setup_link() {
  src="$DOTFILES/$1"
  dst="$HOME/$2"
  if [ "$src" -ef "$dst" ]; then
    return
  fi
  if [[ -e "$dst" || -h "$dst" ]]; then
    >&2 echo "WARNING: $dst exists, overwriting"
    if (( DRY_RUN )); then
      echo "[dry-run] rm -rf $dst"
    else
      rm -rf "$dst"
    fi
  fi
  if (( DRY_RUN )); then
    echo "[dry-run] $src -> $dst"
  else
    echo "$src -> $dst"
    ln -s "$src" "$dst"
  fi
}

_dotfiles_install_hint() {
  if [[ $OSTYPE == darwin* ]]; then
    echo "${_dotfiles_brew_pkg[$1]}"
  elif [[ $OSTYPE == linux* ]]; then
    echo "${_dotfiles_pacman_pkg[$1]}"
  fi
}

link_role() {
  if (( DRY_RUN )); then
    echo "[dry-run] Adding role $1"
  else
    echo "Adding role $1"
  fi
  role_dir=roles/$1
  if [ ! -d $DOTFILES/$role_dir ]; then
    echo "ERROR: No role dir at $role_dir"
    return
  fi

  # Check for required commands before running install/setup
  local requires_cmds_file="$DOTFILES/$role_dir/requires_cmds"
  if [ -f "$requires_cmds_file" ]; then
    local missing_cmds=()
    local cmd
    while IFS= read -r cmd; do
      [[ -z "$cmd" || "$cmd" = \#* ]] && continue
      if ! command -v "$cmd" >/dev/null 2>&1; then
        missing_cmds+=("$cmd")
      fi
    done < "$requires_cmds_file"

    if (( ${#missing_cmds} )); then
      for cmd in "${missing_cmds[@]}"; do
        local hint=$(_dotfiles_install_hint "$cmd")
        if [[ -n "$hint" ]]; then
          echo "Role '$1' requires '$cmd' — install with: $hint"
          if (( ! DRY_RUN )); then
            printf "Install now? [y/N] "
            read -r answer
            if [[ "$answer" == [yY]* ]]; then
              eval "$hint"
            fi
          fi
        else
          echo "Role '$1' requires '$cmd' (no install hint available)"
        fi
      done

      # Re-check after install attempts
      local still_missing=()
      while IFS= read -r cmd; do
        [[ -z "$cmd" || "$cmd" = \#* ]] && continue
        if ! command -v "$cmd" >/dev/null 2>&1; then
          still_missing+=("$cmd")
        fi
      done < "$requires_cmds_file"

      if (( ${#still_missing} )); then
        echo "WARNING: skipping role '$1' — missing required commands: ${still_missing[*]}"
        return
      fi
    fi
  fi

  install_file=$DOTFILES/$role_dir/install
  if [ -f $install_file ]; then
    if (( DRY_RUN )); then
      echo "[dry-run] would run install for $1"
    else
      (source $install_file) || >&2 echo "WARNING: install for role '$1' failed (exit $?), continuing..."
    fi
  fi
  setup_file=$DOTFILES/$role_dir/setup
  if [ -f $setup_file ]; then
    if (( DRY_RUN )); then
      echo "[dry-run] would run setup for $1"
    else
      # Run role setup in a subshell so failures don't abort the entire setup
      (source $setup_file) || >&2 echo "WARNING: setup for role '$1' failed (exit $?), continuing..."
    fi
  fi
  zsh_plugin_file="$role_dir/zsh_plugin"
  if [ -f $DOTFILES/$zsh_plugin_file ]; then
    setup_link $zsh_plugin_file                 ".zsh/plugins/$1.zsh"
  fi
}

# Resolve role dependencies via DFS topological sort.
# Populates _order array with roles in dependency-first order.
typeset -A _resolved _in_stack
_order=()

resolve_role() {
  local role=$1
  # Already fully processed
  (( ${+_resolved[$role]} )) && return 0
  # Cycle detection
  if (( ${+_in_stack[$role]} )); then
    echo "ERROR: dependency cycle detected involving role '$role'" >&2
    return 1
  fi
  _in_stack[$role]=1
  # Check role directory exists
  if [ ! -d "$DOTFILES/roles/$role" ]; then
    echo "ERROR: required role '$role' not found" >&2
    return 1
  fi
  # Recurse into dependencies
  local requires_file="$DOTFILES/roles/$role/requires"
  if [ -f "$requires_file" ]; then
    local dep
    while IFS= read -r dep; do
      # Skip empty lines and comments
      [[ -z "$dep" || "$dep" = \#* ]] && continue
      resolve_role "$dep" || return 1
    done < "$requires_file"
  fi
  unset "_in_stack[$role]"
  _resolved[$role]=1
  _order+=("$role")
}

source "$DOTFILES/lib/install_go_tools.zsh"

dry_mkdir $HOME/.gradle
setup_link "gradle/properties"                  ".gradle/gradle.properties"

setup_link "zsh/zshrc"                          ".zshrc"
dry_mkdir $HOME/.zsh
dry_mkdir $HOME/.zsh/var/
dry_mkdir $HOME/.zsh/plugins/
# clear any existing plugin links
if (( DRY_RUN )); then
  echo "[dry-run] rm -f $HOME/.zsh/plugins/*"
else
  rm -f $HOME/.zsh/plugins/*
fi
for ZSH_PLUGIN in $DOTFILES/zsh/plugins/*; do
  NAME=$(basename $ZSH_PLUGIN)
  setup_link "zsh/plugins/$NAME"                ".zsh/plugins/$NAME"
done
roles_file=$DOTFILES/hosts/$(hostname)/roles
if [ ! -f $roles_file ]; then
  roles_file=$HOME/.zshroles
fi
if [ -f $roles_file ]; then
  while IFS= read -r role; do
    [[ -z "$role" || "$role" = \#* ]] && continue
    resolve_role "$role" || exit 1
  done < $roles_file
  for role in "${_order[@]}"; do
    link_role $role
  done
fi

dry_mkdir $HOME/.ssh
setup_link "ssh/config"                         ".ssh/config"
ssh_host_config=hosts/$(hostname)/ssh_host_config
if [ -f $DOTFILES/$ssh_host_config ]; then
  setup_link "$ssh_host_config"                 ".ssh/host_config"
fi

dry_mkdir $HOME/.vim
for VIMFILE in $DOTFILES/vim/*; do
  NAME=$(basename $VIMFILE)
  setup_link "vim/$NAME"                        ".vim/$NAME"
done

dry_mkdir $HOME/.claude
setup_link "claude/CLAUDE.md"                     ".claude/CLAUDE.md"
dry_mkdir $HOME/.claude/skills
for SKILL_DIR in $DOTFILES/claude/skills/*/; do
  NAME=$(basename "$SKILL_DIR")
  setup_link "claude/skills/$NAME"                ".claude/skills/$NAME"
done

dry_mkdir $HOME/.pi
dry_mkdir $HOME/.pi/agent
dry_mkdir $HOME/.pi/agent/extensions
setup_link "pi/agent/settings.json"               ".pi/agent/settings.json"
setup_link "pi/agent/extensions/claude-memories.ts" ".pi/agent/extensions/claude-memories.ts"

dry_mkdir $HOME/.git
setup_link "git/config"                         ".gitconfig"
setup_link "git/ignore"                         ".git/ignore"

dry_mkdir $HOME/bin
for SCRIPT in $DOTFILES/scripts/*; do
  [[ -d "$SCRIPT" ]] && continue
  NAME=$(basename $SCRIPT)
  setup_link "scripts/$NAME"                    "bin/$NAME"
done

install_go_tools || true

# install pre-commit hook for the dotfiles repo itself
if [ -d "$DOTFILES/.git/hooks" ]; then
  hook_src="$DOTFILES/hooks/pre-commit"
  hook_dst="$DOTFILES/.git/hooks/pre-commit"
  if [ -f "$hook_src" ] && ! [ "$hook_src" -ef "$hook_dst" ]; then
    if (( DRY_RUN )); then
      echo "[dry-run] $hook_src -> $hook_dst"
    else
      echo "$hook_src -> $hook_dst"
      ln -sf "$hook_src" "$hook_dst"
    fi
  fi
fi

if [[ $OSTYPE == darwin* ]]; then
  brewfile=hosts/$(hostname)/brewfile

  if [ -f $DOTFILES/$brewfile ]; then
    setup_link "$brewfile"                      ".Brewfile"
  else
    if (( DRY_RUN )); then
      echo "[dry-run] touch $HOME/.Brewfile"
    else
      touch $HOME/.Brewfile
    fi
  fi

  if [ -f $DOTFILES/$brewfile-x86 ]; then
    setup_link "$brewfile-x86"                  ".Brewfile-x86"
  fi

  # symlink icloud drive to homedir
  if [ ! -e $HOME/iCloud ] && [ ! -L $HOME/iCloud ]; then
    if (( DRY_RUN )); then
      echo "[dry-run] ln -s ~/Library/Mobile Documents/com~apple~CloudDocs ~/iCloud"
    else
      ln -s ~/Library/Mobile\ Documents/com\~apple\~CloudDocs ~/iCloud
    fi
  fi
fi

setup_link "tmux/tmux.conf"                      ".tmux.conf"

dry_mkdir $HOME/.config
setup_link "starship/starship.toml"              ".config/starship.toml"

dry_mkdir $HOME/.config/gh
setup_link "gh/config.yml"                       ".config/gh/config.yml"

dry_mkdir $HOME/.codex/rules
setup_link "codex/config.toml"                   ".codex/config.toml"
setup_link "codex/rules/default.rules"           ".codex/rules/default.rules"

echo ""
if (( DRY_RUN )); then
  echo "Dry run complete. No changes were made."
else
  echo "Config files are setup."
  echo "Run 'reload-config' to re-source zsh config."
fi