setup.sh

#!/bin/bash
#=================================================================
# DXSBash - Enhanced Shell Environment for Debian and Ubuntu
# Repository: https://github.com/digitalxs/dxsbash
# Author: Luis Miguel P. Freitas
# Website: https://digitalxs.ca
# License: GPL-3.0
#=================================================================

# Strict mode + pipefail so piped failures surface
set -Eeuo pipefail

#=================================================================
# Color definitions for rich terminal output
#=================================================================
RC='\033[0m'          # Reset Color
RED='\033[1;31m'      # Bold Red
YELLOW='\033[1;33m'   # Bold Yellow
GREEN='\033[1;32m'    # Bold Green
BLUE='\033[1;34m'     # Bold Blue
CYAN='\033[1;36m'     # Bold Cyan
WHITE='\033[1;37m'    # Bold White

#=================================================================
# Error trap — log the failing line and command
#=================================================================
on_error() {
  local ec=$?
  echo -e "${RED}✗ setup.sh failed (exit $ec) at line ${BASH_LINENO[0]}: ${BASH_COMMAND}${RC}" >&2
  [ -n "${LOG_FILE:-}" ] && echo -e "${YELLOW}  See log: $LOG_FILE${RC}" >&2
  exit "$ec"
}
trap on_error ERR

#=================================================================
# Who are we running as, and whose HOME should we touch?
#
# If invoked via sudo, SUDO_USER is set to the invoking user and
# $HOME points to /root. We always want the *real* user's home.
#=================================================================
# SUDO_USER only means "the invoking user" when we actually run as root
# (it can linger in the environment, e.g. after sudo -iu <user>)
if [ "$(id -u)" -eq 0 ] && [ -n "${SUDO_USER:-}" ]; then
  REAL_USER="$SUDO_USER"
else
  REAL_USER="$(id -un)"
fi
USER_HOME="$(getent passwd "$REAL_USER" 2>/dev/null | cut -d: -f6)"
[ -n "$USER_HOME" ] || USER_HOME="${HOME:-/tmp}"
REAL_GROUP="$(id -gn "$REAL_USER" 2>/dev/null || echo "$REAL_USER")"

# Helper: run a command as the real user (strips root if we were sudo'd)
as_user() {
  if [ "$(id -u)" -eq 0 ] && [ -n "${SUDO_USER:-}" ]; then
    sudo -u "$REAL_USER" -H "$@"
  else
    "$@"
  fi
}

#=================================================================
# Operation mode (install | repair | uninstall)
#
# Can be selected via CLI flag, env var DXSBASH_MODE, or an
# interactive menu when no choice is provided.
#=================================================================
MODE=""
ASSUME_YES=0
NONINTERACTIVE=0
DRY_RUN=0

parse_args() {
  while [ $# -gt 0 ]; do
    case "$1" in
      --install)    MODE="install" ;;
      --repair)     MODE="repair" ;;
      --uninstall)  MODE="uninstall" ;;
      --doctor)     MODE="doctor" ;;
      -y|--yes)     ASSUME_YES=1; NONINTERACTIVE=1 ;;
      --dry-run)    DRY_RUN=1 ;;
      --shell)
        shift
        case "${1:-}" in
          bash|zsh|fish) SELECTED_SHELL="$1" ;;
          *) echo "Invalid --shell value: ${1:-}" >&2; exit 2 ;;
        esac
        ;;
      -h|--help)
        cat <<'USAGE'
DXSBash setup

Usage: setup.sh [MODE] [options]

Modes:
  --install     Install DXSBash (default when interactive)
  --repair      Re-link configs, re-install helper commands
  --uninstall   Remove DXSBash and restore /etc/skel defaults
  --doctor      Run a health check and report problems (no changes)

Options:
  --shell X     Choose shell (bash|zsh|fish); overrides menu
  -y, --yes     Do not prompt; assume yes (non-interactive)
  --dry-run     Print actions without making changes (install only)
  -h, --help    Show this help

Environment:
  DXSBASH_MODE       Same as a mode flag
  DXSBASH_SHELL      Same as --shell
  DXSBASH_SKIP_FONT  Set to 1 to skip the Nerd Font download (CI)
USAGE
        exit 0
        ;;
      *)
        echo "Unknown option: $1" >&2
        exit 2
        ;;
    esac
    shift
  done
  if [ -z "$MODE" ] && [ -n "${DXSBASH_MODE:-}" ]; then
    MODE="$DXSBASH_MODE"
  fi
  if [ -z "${SELECTED_SHELL:-}" ] && [ -n "${DXSBASH_SHELL:-}" ]; then
    case "$DXSBASH_SHELL" in
      bash|zsh|fish) SELECTED_SHELL="$DXSBASH_SHELL" ;;
      *) echo "Invalid DXSBASH_SHELL: $DXSBASH_SHELL" >&2; exit 2 ;;
    esac
  fi
}

#=================================================================
# Display welcome banner
#=================================================================
display_banner() {
  echo -e "${BLUE}╔════════════════════════════════════════════════════════╗${RC}"
  echo -e "${BLUE}║                                                        ║${RC}"
  echo -e "${BLUE}║  ${WHITE}██████╗ ██╗  ██╗███████╗██████╗  █████╗ ███████╗██╗  ██╗${BLUE}  ${RC}"
  echo -e "${BLUE}║  ${WHITE}██╔══██╗╚██╗██╔╝██╔════╝██╔══██╗██╔══██╗██╔════╝██║  ██║${BLUE}  ${RC}"
  echo -e "${BLUE}║  ${WHITE}██║  ██║ ╚███╔╝ ███████╗██████╔╝███████║███████╗███████║${BLUE}  ${RC}"
  echo -e "${BLUE}║  ${WHITE}██║  ██║ ██╔██╗ ╚════██║██╔══██╗██╔══██║╚════██║██╔══██║${BLUE}  ${RC}"
  echo -e "${BLUE}║  ${WHITE}██████╔╝██╔╝ ██╗███████║██████╔╝██║  ██║███████║██║  ██║${BLUE}  ${RC}"
  echo -e "${BLUE}║  ${WHITE}╚═════╝ ╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝${BLUE}  ${RC}"
  echo -e "${BLUE}║                                                        ║${RC}"
  echo -e "${BLUE}║  ${CYAN}Enhanced Shell Environment for Debian & Ubuntu${BLUE}        ║${RC}"
  echo -e "${BLUE}║  ${YELLOW}  $(date +%Y) digitalxs.ca${BLUE}                                   ║${RC}"
  echo -e "${BLUE}║                                                        ║${RC}"
  echo -e "${BLUE}╚════════════════════════════════════════════════════════╝${RC}"
  echo ""
}

#=================================================================
# Initialize environment and check prerequisites
#
# Safe when re-run in place: if setup.sh is running *from* the
# target directory, we `git pull` instead of `rm -rf` + clone, which
# would otherwise delete the running script.
#=================================================================
initialize() {
  echo -e "${CYAN}▶ Initializing setup...${RC}"

  # Ensure .config exists in the *real* user's home
  CONFIGDIR="$USER_HOME/.config"
  if [ ! -d "$CONFIGDIR" ]; then
    echo -e "${YELLOW}  Creating .config directory: ${WHITE}$CONFIGDIR${RC}"
    as_user mkdir -p "$CONFIGDIR"
    echo -e "${GREEN}  ✓ .config directory created${RC}"
  fi

  LINUXTOOLBOXDIR="$USER_HOME/linuxtoolbox"
  if [ ! -d "$LINUXTOOLBOXDIR" ]; then
    echo -e "${YELLOW}  Creating linuxtoolbox directory: ${WHITE}$LINUXTOOLBOXDIR${RC}"
    as_user mkdir -p "$LINUXTOOLBOXDIR"
  fi

  local target="$LINUXTOOLBOXDIR/dxsbash"
  local script_dir
  script_dir="$(dirname "$(realpath "$0")")"

  # Self-wipe guard: don't delete the directory we're running from.
  if [ -d "$target" ] && [ "$script_dir" = "$(realpath "$target" 2>/dev/null || echo /nonexistent)" ]; then
    echo -e "${YELLOW}  Running from $target — pulling updates in place${RC}"
    if [ "$DRY_RUN" -eq 0 ]; then
      if ( cd "$target" && as_user git pull --ff-only origin main ); then
        echo -e "${GREEN}  ✓ Repository updated${RC}"
      else
        echo -e "${YELLOW}  ⚠ git pull failed; continuing with current checkout${RC}"
      fi
    fi
  elif [ -d "$target" ]; then
    echo -e "${YELLOW}  Cleaning existing installation at $target${RC}"
    [ "$DRY_RUN" -eq 0 ] && rm -rf "$target"
    if [ "$DRY_RUN" -eq 0 ]; then
      if ! as_user git clone https://github.com/digitalxs/dxsbash "$target"; then
        echo -e "${RED}  ✗ Failed to clone repository${RC}"
        exit 1
      fi
    fi
    echo -e "${GREEN}  ✓ Repository ready${RC}"
  else
    echo -e "${YELLOW}  Cloning DXSBash repository...${RC}"
    if [ "$DRY_RUN" -eq 0 ]; then
      if ! as_user git clone https://github.com/digitalxs/dxsbash "$target"; then
        echo -e "${RED}  ✗ Failed to clone repository. Check your internet connection.${RC}"
        exit 1
      fi
    fi
    echo -e "${GREEN}  ✓ Repository cloned successfully${RC}"
  fi

  cd "$target" 2>/dev/null || true
  # Link everything from the managed clone (the one update-dxsbash
  # pulls), never from wherever setup.sh was launched: with the manual
  # "git clone … && cd dxsbash && ./setup.sh" install, ~/.bashrc & co.
  # used to point into that throwaway checkout and broke when it was
  # deleted — and never received updates.
  if [ -f "$target/setup.sh" ]; then
    GITPATH="$target"
  fi
  echo -e "${GREEN}▶ Initialization complete${RC}"
  echo ""
}

# Main variables that will be used across functions
SUDO_CMD=""
GITPATH=""
SELECTED_SHELL="${SELECTED_SHELL:-}"
# Distro family: debian (incl. Ubuntu), arch, fedora (incl. RHEL-likes),
# or unknown. Set by detectDistro().
DISTRO="unknown"
LOG_FILE=""

# Parse CLI arguments up front
parse_args "$@"

#=================================================================
# Install logging — mirror stdout/stderr to a dated log file under
# ~/.dxsbash/logs/ so post-mortems are possible.
#=================================================================
setup_logging() {
  local log_dir="$USER_HOME/.dxsbash/logs"
  as_user mkdir -p "$log_dir"
  LOG_FILE="$log_dir/install-$(date +%Y%m%d-%H%M%S).log"
  as_user touch "$LOG_FILE"
  # Tee both streams; keep stderr distinguishable in the log
  exec > >(tee -a "$LOG_FILE") 2> >(tee -a "$LOG_FILE" >&2)
  echo "=== DXSBash setup started $(date) ===" >> "$LOG_FILE"
  echo "    args: $*"                          >> "$LOG_FILE"
  echo "    user: $REAL_USER ($USER_HOME)"     >> "$LOG_FILE"
}
setup_logging "$@"

# Display welcome banner
display_banner

#=================================================================
# Interactive mode selection
#=================================================================
select_mode() {
  if [ -n "$MODE" ]; then
    return
  fi
  if [ "$NONINTERACTIVE" -eq 1 ] || [ ! -t 0 ]; then
    MODE="install"
    return
  fi

  echo -e "${CYAN}╔════════════════════════════════════════════════════════╗${RC}"
  echo -e "${CYAN}║             What would you like to do?                 ║${RC}"
  echo -e "${CYAN}╚════════════════════════════════════════════════════════╝${RC}"
  echo -e "  ${WHITE}1)${RC} ${GREEN}Install${RC}     ${YELLOW}(default — fresh install of DXSBash)${RC}"
  echo -e "  ${WHITE}2)${RC} ${GREEN}Repair${RC}      ${YELLOW}(fix broken symlinks/commands)${RC}"
  echo -e "  ${WHITE}3)${RC} ${GREEN}Uninstall${RC}   ${YELLOW}(remove and restore Debian defaults)${RC}"
  echo -e "  ${WHITE}4)${RC} ${GREEN}Doctor${RC}      ${YELLOW}(check installation health, read-only)${RC}"
  echo -e "  ${WHITE}5)${RC} Cancel"
  echo ""
  read -p "  Enter your choice [1-5] (default: 1): " mode_choice
  case "$mode_choice" in
    2) MODE="repair" ;;
    3) MODE="uninstall" ;;
    4) MODE="doctor" ;;
    5) echo -e "${YELLOW}Cancelled.${RC}"; exit 0 ;;
    *) MODE="install" ;;
  esac
  echo ""
}

select_mode

#=================================================================
# Dispatch: repair / uninstall delegate to their dedicated scripts
# living next to this file so setup.sh stays a single entry point.
#=================================================================
SCRIPT_DIR="$(dirname "$(realpath "$0")")"

if [ "$MODE" = "repair" ]; then
  REPAIR_ARGS=()
  [ "$ASSUME_YES" -eq 1 ] && REPAIR_ARGS+=(--deps)
  if [ -x "$SCRIPT_DIR/repair.sh" ]; then
    exec "$SCRIPT_DIR/repair.sh" "${REPAIR_ARGS[@]}"
  elif [ -x "$USER_HOME/linuxtoolbox/dxsbash/repair.sh" ]; then
    exec "$USER_HOME/linuxtoolbox/dxsbash/repair.sh" "${REPAIR_ARGS[@]}"
  else
    echo -e "${RED}repair.sh not found. Is DXSBash installed?${RC}"
    exit 1
  fi
fi

if [ "$MODE" = "uninstall" ]; then
  UNINSTALL_ARGS=()
  [ "$ASSUME_YES" -eq 1 ] && UNINSTALL_ARGS+=(--yes)
  if [ -x "$SCRIPT_DIR/uninstall.sh" ]; then
    exec "$SCRIPT_DIR/uninstall.sh" "${UNINSTALL_ARGS[@]}"
  elif [ -x "$USER_HOME/linuxtoolbox/dxsbash/uninstall.sh" ]; then
    exec "$USER_HOME/linuxtoolbox/dxsbash/uninstall.sh" "${UNINSTALL_ARGS[@]}"
  else
    echo -e "${RED}uninstall.sh not found. Is DXSBash installed?${RC}"
    exit 1
  fi
fi

if [ "$MODE" = "doctor" ]; then
  if [ -x "$SCRIPT_DIR/doctor.sh" ]; then
    exec "$SCRIPT_DIR/doctor.sh"
  elif [ -x "$USER_HOME/linuxtoolbox/dxsbash/doctor.sh" ]; then
    exec "$USER_HOME/linuxtoolbox/dxsbash/doctor.sh"
  else
    echo -e "${RED}doctor.sh not found. Is DXSBash installed?${RC}"
    exit 1
  fi
fi

# Default: install — pre-checks, pre-flight and initialize happen
# inside main() at the bottom so all helper functions are defined.

#=================================================================
# Already-installed detection
#
# If all expected symlinks/commands look healthy, suggest repair
# instead of a fresh install — avoids accidental reclone + rechsh.
#=================================================================
is_installed() {
  local shell_rc=""
  case "$SELECTED_SHELL" in
    bash) shell_rc="$USER_HOME/.bashrc" ;;
    zsh)  shell_rc="$USER_HOME/.zshrc" ;;
    fish) shell_rc="$USER_HOME/.config/fish/config.fish" ;;
    *)    shell_rc="$USER_HOME/.bashrc" ;;
  esac

  [ -d "$USER_HOME/linuxtoolbox/dxsbash" ] || return 1
  [ -L "$shell_rc" ] && readlink "$shell_rc" | grep -q dxsbash || return 1
  [ -x /usr/local/bin/update-dxsbash ] || return 1
  return 0
}

if [ -z "${SELECTED_SHELL:-}" ] && [ -L "$USER_HOME/.bashrc" ] && \
   readlink "$USER_HOME/.bashrc" | grep -q dxsbash; then
  DETECTED_INSTALLED_SHELL="bash"
elif [ -L "$USER_HOME/.zshrc" ] && \
     readlink "$USER_HOME/.zshrc" | grep -q dxsbash; then
  DETECTED_INSTALLED_SHELL="zsh"
elif [ -L "$USER_HOME/.config/fish/config.fish" ] && \
     readlink "$USER_HOME/.config/fish/config.fish" | grep -q dxsbash; then
  DETECTED_INSTALLED_SHELL="fish"
else
  DETECTED_INSTALLED_SHELL=""
fi

if [ -n "$DETECTED_INSTALLED_SHELL" ]; then
  echo -e "${YELLOW}  DXSBash is already installed (${DETECTED_INSTALLED_SHELL}).${RC}"
  if [ "$NONINTERACTIVE" -eq 1 ]; then
    echo -e "${YELLOW}  --yes set: proceeding with reinstall anyway.${RC}"
    echo ""
  else
    echo -e "  ${WHITE}1)${RC} Reinstall (reclones, overwrites)"
    echo -e "  ${WHITE}2)${RC} Repair    ${YELLOW}(recommended)${RC}"
    echo -e "  ${WHITE}3)${RC} Cancel"
    read -p "  Choice [1-3] (default: 2): " _existing_choice
    case "$_existing_choice" in
      1) ;;                                    # fall through to install
      3) echo -e "${YELLOW}Cancelled.${RC}"; exit 0 ;;
      *)
        REPAIR_ARGS=()
        if [ -x "$SCRIPT_DIR/repair.sh" ]; then
          exec "$SCRIPT_DIR/repair.sh" "${REPAIR_ARGS[@]}"
        else
          exec "$USER_HOME/linuxtoolbox/dxsbash/repair.sh" "${REPAIR_ARGS[@]}"
        fi
        ;;
    esac
    echo ""
  fi
fi

#=================================================================
# Pre-flight summary (called from main() after shell is chosen)
#=================================================================
show_preflight() {
  local shell_label="${SELECTED_SHELL:-bash}"
  echo -e "${BLUE}╔════════════════════════════════════════════════════════╗${RC}"
  echo -e "${BLUE}║  ${WHITE}Install plan${BLUE}                                          ║${RC}"
  echo -e "${BLUE}╚════════════════════════════════════════════════════════╝${RC}"
  echo -e "  ${CYAN}User:${RC}          $REAL_USER"
  echo -e "  ${CYAN}Home:${RC}          $USER_HOME"
  echo -e "  ${CYAN}Shell target:${RC}  $shell_label"
  echo -e "  ${CYAN}Repo dir:${RC}      $USER_HOME/linuxtoolbox/dxsbash"
  echo -e "  ${CYAN}Log file:${RC}      $LOG_FILE"
  [ "$DRY_RUN" -eq 1 ] && echo -e "  ${YELLOW}DRY-RUN: no changes will be made${RC}"
  echo ""
  echo -e "${CYAN}Will install/link:${RC}"
  echo -e "  • ~/.${shell_label}rc (or equivalent) → dxsbash repo"
  echo -e "  • ~/.config/starship.toml, ~/.config/fastfetch/config.jsonc"
  echo -e "  • /usr/local/bin/{dxsbash,dxsbash-gui,update-dxsbash,dxsbash-config,dxsbash-doctor,"
  echo -e "                    dxsbash-audit,dxsbash-repair,dxsbash-uninstall,reset-shell-profile}"
  echo -e "  • System packages via apt/nala (requires sudo)"
  echo -e "  • FiraCode Nerd Font, starship, zoxide, fzf"
  echo ""

  if [ "$NONINTERACTIVE" -eq 0 ] && [ -t 0 ]; then
    read -p "  Proceed? (Y/n): " _ok
    if [[ "$_ok" =~ ^[Nn]$ ]]; then
      echo -e "${YELLOW}Aborted.${RC}"
      exit 0
    fi
    echo ""
  fi
}

#=================================================================
# Utility functions
#=================================================================
command_exists() {
  command -v "$1" >/dev/null 2>&1
}

#=================================================================
# Environment checking
#=================================================================
# Which desktop is installed (kde | xfce | other | empty), using the
# shared detection in settings-lib.sh — in a subshell so the library's
# globals stay out of setup's environment. KDE Plasma and XFCE are found
# even when setup runs over SSH or from a text console.
desktop_kind() {
  local lib="${GITPATH:-$(dirname "$(realpath "$0")")}/settings-lib.sh"
  [ -f "$lib" ] || return 0
  bash -c 'source "$1" && detect_desktop' _ "$lib" 2>/dev/null
}

# Install the settings GUI (zenity, menu entry, update notifications)?
# Headless servers get none of it (no GTK stack pulled in). Override
# with DXSBASH_DESKTOP=1 or =0.
has_desktop() {
  case "${DXSBASH_DESKTOP:-auto}" in
    1|yes|true) return 0 ;;
    0|no|false) return 1 ;;
  esac
  [ -n "$(desktop_kind)" ]
}

checkEnv() {
  echo -e "${CYAN}▶ Checking environment requirements...${RC}"

  ## Check for required tools
  REQUIREMENTS='curl sudo git'
  for req in $REQUIREMENTS; do
    if ! command_exists "$req"; then
      echo -e "${RED}  ✗ Required tool missing: ${WHITE}$req${RC}"
      echo -e "${YELLOW}  Please install the following requirements and try again: ${WHITE}$REQUIREMENTS${RC}"
      exit 1
    fi
  done
  echo -e "${GREEN}  ✓ All required tools are installed${RC}"

  ## Check for privilege escalation tool
  if command_exists sudo; then
    SUDO_CMD="sudo"
  else
    echo -e "${RED}  ✗ sudo is required for this installation${RC}"
    exit 1
  fi
  echo -e "${GREEN}  ✓ Using ${WHITE}$SUDO_CMD${GREEN} for privilege escalation${RC}"

  ## Check if the current directory is writable
  GITPATH=$(dirname "$(realpath "$0")")
  if [ ! -w "$GITPATH" ]; then
    echo -e "${RED}  ✗ Cannot write to directory: ${WHITE}$GITPATH${RC}"
    exit 1
  fi

  ## Ensure user can escalate privileges: root passes outright (root is
  ## not in the sudo group, so the old group check wrongly rejected
  ## 'sudo ./setup.sh'); otherwise accept sudo/wheel/admin membership.
  if [ "$(id -u)" -ne 0 ] && ! groups | grep -qwE "sudo|wheel|admin"; then
    echo -e "${RED}  ✗ You need to be a member of the ${WHITE}sudo${RED} (or wheel) group to run this script!${RC}"
    exit 1
  fi

  echo -e "${GREEN}▶ Environment check passed${RC}"
  echo ""
}

#=================================================================
# Distribution detection
#=================================================================
detectDistro() {
  echo -e "${CYAN}▶ Detecting Linux distribution...${RC}"

  # Family-level detection from os-release: ID first, then ID_LIKE so
  # derivatives (Mint, Manjaro, Rocky, ...) map to their parent family.
  # Same logic the shell rc files use at runtime.
  local os_id="" os_like="" os_name=""
  if [ -r /etc/os-release ]; then
    os_id=$(. /etc/os-release && echo "${ID:-}")
    os_like=$(. /etc/os-release && echo "${ID_LIKE:-}")
    os_name=$(. /etc/os-release && echo "${PRETTY_NAME:-${ID:-}}")
  fi
  case "$os_id" in
    debian|ubuntu)                     DISTRO="debian" ;;
    arch|manjaro|endeavouros)          DISTRO="arch" ;;
    fedora|rhel|centos|rocky|almalinux) DISTRO="fedora" ;;
    *)
      case " $os_like " in
        *debian*|*ubuntu*) DISTRO="debian" ;;
        *arch*)            DISTRO="arch" ;;
        *fedora*|*rhel*)   DISTRO="fedora" ;;
      esac
      ;;
  esac
  # Minimal chroots may lack os-release; the marker file still works.
  if [ "$DISTRO" = "unknown" ] && [ -f /etc/debian_version ]; then
    DISTRO="debian"
    os_name="Debian $(cat /etc/debian_version)"
  fi

  case "$DISTRO" in
    debian) echo -e "${GREEN}  ✓ Detected ${WHITE}${os_name:-Debian/Ubuntu}${GREEN} — using apt${RC}" ;;
    arch)   echo -e "${GREEN}  ✓ Detected ${WHITE}${os_name:-Arch Linux}${GREEN} — using pacman${RC}" ;;
    fedora) echo -e "${GREEN}  ✓ Detected ${WHITE}${os_name:-Fedora}${GREEN} — using dnf${RC}" ;;
    *)
      echo -e "${RED}  ⚠ Warning: DXSBash supports Debian, Ubuntu, Arch Linux and Fedora.${RC}"
      echo -e "${YELLOW}  Your system appears to be running a different distribution.${RC}"
      echo -e "${YELLOW}  Some features may not work as expected.${RC}"
      echo ""
      if [ "$NONINTERACTIVE" -eq 1 ]; then
        echo -e "${YELLOW}  Continuing anyway (--yes)${RC}"
      else
        read -p "  Do you want to continue anyway? (y/N): " continue_install
        if [[ ! "$continue_install" =~ ^[Yy]$ ]]; then
          echo -e "${RED}  Installation aborted.${RC}"
          exit 1
        fi
      fi
      ;;
  esac
  echo ""
}

#=================================================================
# Dependency installation
#=================================================================
installDepend() {
  echo -e "${CYAN}▶ Installing dependencies...${RC}"

  ## Check for dependencies.
  COMMON_DEPENDENCIES='bash tar bat tree multitail curl wget unzip fontconfig joe git nano zoxide fzf pwgen ripgrep fastfetch'

  # Shell-specific dependencies
  BASH_DEPENDENCIES="bash bash-completion btop"
  ZSH_DEPENDENCIES="zsh zsh-autosuggestions zsh-syntax-highlighting"
  FISH_DEPENDENCIES="fish"

  # Combine dependencies based on the selected shell.
  # nala is a Debian/Ubuntu apt frontend and only exists there.
  DEPENDENCIES="$COMMON_DEPENDENCIES plocate trash-cli powerline"
  if [ "$DISTRO" = "debian" ]; then
    DEPENDENCIES="$DEPENDENCIES nala"
  fi

  # Add shell-specific dependencies
  if [ "$SELECTED_SHELL" = "bash" ]; then
    DEPENDENCIES="$DEPENDENCIES $BASH_DEPENDENCIES"
  elif [ "$SELECTED_SHELL" = "zsh" ]; then
    DEPENDENCIES="$DEPENDENCIES $ZSH_DEPENDENCIES"
  elif [ "$SELECTED_SHELL" = "fish" ]; then
    DEPENDENCIES="$DEPENDENCIES $FISH_DEPENDENCIES"
  fi

  if ! command_exists nvim; then
    DEPENDENCIES="${DEPENDENCIES} neovim"
  fi

  # Graphical settings (dxsbash-gui) — desktops only
  if has_desktop; then
    DEPENDENCIES="${DEPENDENCIES} zenity"
  fi

  echo -e "${YELLOW}  Installing required packages: ${WHITE}$DEPENDENCIES${RC}"
  if [ "$DISTRO" = "debian" ]; then
    # First check if nala is installed; fall back to apt if it can't be.
    # 'update' failures are tolerated: unrelated third-party repos with
    # broken metadata (dead PPAs, changed labels, expired keys) are
    # common on real systems and must not abort the install — package
    # installation still works from the existing lists.
    if ! command_exists nala; then
      echo -e "${YELLOW}  Installing nala package manager...${RC}"
      ${SUDO_CMD} apt update || \
        echo -e "${YELLOW}  ⚠ apt update reported errors; continuing with existing package lists${RC}"
      ${SUDO_CMD} apt install -y nala || \
        echo -e "${YELLOW}  ⚠ Could not install nala; falling back to apt${RC}"
    fi

    # Prefer nala only when it actually works: a broken python-apt
    # (e.g. after installing a non-default python3) leaves the nala
    # binary present but unusable.
    local pkg_mgr="apt"
    if command_exists nala && nala --version >/dev/null 2>&1; then
      pkg_mgr="nala"
    fi
    ${SUDO_CMD} "$pkg_mgr" update || \
      echo -e "${YELLOW}  ⚠ ${pkg_mgr} update reported errors; continuing with existing package lists${RC}"

    # Filter out packages that don't exist on this release (for example
    # fastfetch on Debian 12 / Ubuntu 24.04) so one missing package
    # doesn't abort the whole install under 'set -e'.
    local available_pkgs="" unavailable_pkgs=""
    local pkg
    for pkg in $DEPENDENCIES; do
      if apt-cache show "$pkg" >/dev/null 2>&1; then
        available_pkgs="$available_pkgs $pkg"
      else
        unavailable_pkgs="$unavailable_pkgs $pkg"
      fi
    done
    if [ -n "$unavailable_pkgs" ]; then
      echo -e "${YELLOW}  ⚠ Not available on this release (skipped):${WHITE}$unavailable_pkgs${RC}"
    fi
    # shellcheck disable=SC2086  # word splitting of the package list is intended
    if ! ${SUDO_CMD} "$pkg_mgr" install -y $available_pkgs; then
      if [ "$pkg_mgr" = "nala" ]; then
        echo -e "${YELLOW}  ⚠ nala install failed; retrying with apt${RC}"
        # shellcheck disable=SC2086
        ${SUDO_CMD} apt install -y $available_pkgs
      else
        echo -e "${RED}  ✗ Package installation failed${RC}"
        exit 1
      fi
    fi
  elif [ "$DISTRO" = "arch" ]; then
    # Refresh the sync database, then filter out packages this system's
    # repos don't carry so one miss doesn't abort the transaction.
    ${SUDO_CMD} pacman -Sy --noconfirm || \
      echo -e "${YELLOW}  ⚠ pacman -Sy reported errors; continuing with existing sync db${RC}"
    local available_pkgs="" unavailable_pkgs=""
    local pkg
    for pkg in $DEPENDENCIES; do
      if pacman -Si "$pkg" >/dev/null 2>&1; then
        available_pkgs="$available_pkgs $pkg"
      else
        unavailable_pkgs="$unavailable_pkgs $pkg"
      fi
    done
    if [ -n "$unavailable_pkgs" ]; then
      echo -e "${YELLOW}  ⚠ Not in the configured repos (skipped):${WHITE}$unavailable_pkgs${RC}"
    fi
    # -Su alongside the install list: installing new packages against a
    # stale system is a partial upgrade, which Arch does not support —
    # one transaction that upgrades and installs avoids broken libs.
    # shellcheck disable=SC2086  # word splitting of the package list is intended
    if ! ${SUDO_CMD} pacman -Su --needed --noconfirm $available_pkgs; then
      echo -e "${RED}  ✗ Package installation failed${RC}"
      exit 1
    fi
  elif [ "$DISTRO" = "fedora" ]; then
    # Same availability filter for dnf (RHEL-likes may lack e.g.
    # fastfetch or powerline without EPEL).
    local available_pkgs="" unavailable_pkgs=""
    local pkg
    for pkg in $DEPENDENCIES; do
      if dnf info -q "$pkg" >/dev/null 2>&1; then
        available_pkgs="$available_pkgs $pkg"
      else
        unavailable_pkgs="$unavailable_pkgs $pkg"
      fi
    done
    if [ -n "$unavailable_pkgs" ]; then
      echo -e "${YELLOW}  ⚠ Not in the configured repos (skipped):${WHITE}$unavailable_pkgs${RC}"
    fi
    # shellcheck disable=SC2086  # word splitting of the package list is intended
    if ! ${SUDO_CMD} dnf install -y $available_pkgs; then
      echo -e "${RED}  ✗ Package installation failed${RC}"
      exit 1
    fi
  else
    # Unknown distro: fall back to apt if available, otherwise ask the
    # user to install manually.
    if command_exists apt; then
      ${SUDO_CMD} apt update
      ${SUDO_CMD} apt install -y $DEPENDENCIES
    else
      echo -e "${RED}  ✗ Unable to find a supported package manager.${RC}"
      echo -e "${YELLOW}  Please install the following packages manually: ${WHITE}$DEPENDENCIES${RC}"
      read -p "  Press Enter to continue..."
    fi
  fi

  echo -e "${GREEN}  ✓ Dependencies installed successfully${RC}"

  # Install FiraCode Nerd Font if missing.
  # Set DXSBASH_SKIP_FONT=1 to skip the ~30 MB download (useful in CI).
  FONT_NAME="FiraCode Nerd Font"
  if [ "${DXSBASH_SKIP_FONT:-0}" = "1" ]; then
    echo -e "${YELLOW}  Skipping font installation (DXSBASH_SKIP_FONT=1)${RC}"
  elif fc-list | grep -q "FiraCode"; then
    echo -e "${GREEN}  ✓ Font '$FONT_NAME' is already installed${RC}"
  else
    echo -e "${YELLOW}  Installing font '$FONT_NAME'...${RC}"
    local FONT_URL="https://github.com/ryanoasis/nerd-fonts/releases/download/v3.3.0/FiraCode.zip"
    local FONT_DIR="$USER_HOME/.local/share/fonts"

    if wget -q --spider "$FONT_URL"; then
      local TEMP_DIR
      TEMP_DIR=$(mktemp -d)
      if wget -q --show-progress "$FONT_URL" -O "$TEMP_DIR/FiraCode.zip"; then
        if unzip -q "$TEMP_DIR/FiraCode.zip" -d "$TEMP_DIR"; then
          as_user mkdir -p "$FONT_DIR/FiraCode"
          # Support both flat-zip (v3.x) and nested layouts
          find "$TEMP_DIR" -type f -name '*.ttf' -exec mv {} "$FONT_DIR/FiraCode/" \; 2>/dev/null || true
          if [ "$(id -u)" -eq 0 ]; then
            chown -R "$REAL_USER:$REAL_GROUP" "$FONT_DIR/FiraCode" 2>/dev/null || true
          fi
          as_user fc-cache -f "$FONT_DIR" >/dev/null 2>&1 || true
          echo -e "${GREEN}  ✓ Font '$FONT_NAME' installed successfully${RC}"
        else
          echo -e "${YELLOW}  ⚠ Failed to unzip font; continuing without it${RC}"
        fi
      else
        echo -e "${YELLOW}  ⚠ Font download failed; continuing without it${RC}"
      fi
      rm -rf "$TEMP_DIR"
    else
      echo -e "${YELLOW}  ⚠ Font URL not accessible; continuing without font${RC}"
    fi
  fi

  echo -e "${GREEN}▶ All dependencies installed${RC}"
  echo ""
}

#=================================================================
# Additional tools installation
#=================================================================
installStarshipAndFzf() {
  echo -e "${CYAN}▶ Installing Starship prompt...${RC}"
  if command_exists starship; then
    echo -e "${GREEN}  ✓ Starship already installed${RC}"
  else
    echo -e "${YELLOW}  Installing Starship prompt...${RC}"
    # Pass -y when running unattended: the installer's confirmation
    # prompt cannot be answered without a terminal.
    local starship_yes=""
    if [ "$NONINTERACTIVE" -eq 1 ] || [ ! -t 0 ]; then
      starship_yes="-y"
    fi
    if curl -sS https://starship.rs/install.sh | sh -s -- ${starship_yes}; then
      echo -e "${GREEN}  ✓ Starship installed successfully${RC}"
    else
      echo -e "${RED}  ✗ Something went wrong during Starship installation!${RC}"
      echo -e "${YELLOW}  Continuing without Starship...${RC}"
    fi
  fi

  echo -e "${CYAN}▶ Installing FZF...${RC}"
  if command_exists fzf; then
    echo -e "${GREEN}  ✓ FZF already installed${RC}"
  else
    echo -e "${YELLOW}  Installing FZF...${RC}"
    if [ -d "$USER_HOME/.fzf" ]; then
      echo -e "${YELLOW}  ~/.fzf already exists; skipping clone${RC}"
    else
      as_user git clone --depth 1 https://github.com/junegunn/fzf.git "$USER_HOME/.fzf"
    fi
    as_user "$USER_HOME/.fzf/install" --all --no-update-rc >/dev/null || \
      echo -e "${YELLOW}  ⚠ fzf installer returned non-zero; continuing${RC}"
    echo -e "${GREEN}  ✓ FZF installed successfully${RC}"
  fi
  echo ""
}

installZoxide() {
  echo -e "${CYAN}▶ Installing Zoxide...${RC}"
  if command_exists zoxide; then
    echo -e "${GREEN}  ✓ Zoxide already installed${RC}"
    return
  fi

  echo -e "${YELLOW}  Installing Zoxide...${RC}"
  if curl -sS https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | sh; then
    echo -e "${GREEN}  ✓ Zoxide installed successfully${RC}"
  else
    echo -e "${RED}  ✗ Something went wrong during Zoxide installation!${RC}"
    echo -e "${YELLOW}  Continuing without Zoxide...${RC}"
  fi
  echo ""
}

#=================================================================
# Shell selection
#
# Honours (in order): --shell flag, DXSBASH_SHELL env var, interactive
# prompt. Non-interactive runs without a shell choice default to bash.
#=================================================================
selectShell() {
  # Already chosen via --shell or DXSBASH_SHELL
  if [ -n "$SELECTED_SHELL" ]; then
    echo -e "${GREEN}  ✓ Using shell: ${WHITE}$SELECTED_SHELL${RC}"
    echo ""
    return
  fi

  if [ "$NONINTERACTIVE" -eq 1 ] || [ ! -t 0 ]; then
    SELECTED_SHELL="bash"
    echo -e "${GREEN}  ✓ Non-interactive: defaulting to ${WHITE}bash${RC}"
    echo ""
    return
  fi

  echo -e "${CYAN}╔════════════════════════════════════════════════════════╗${RC}"
  echo -e "${CYAN}║             Select your preferred shell:               ║${RC}"
  echo -e "${CYAN}╚════════════════════════════════════════════════════════╝${RC}"
  echo -e "  ${WHITE}1)${RC} ${GREEN}Bash${RC}      ${YELLOW}(default, most compatible)${RC}"
  echo -e "  ${WHITE}2)${RC} ${GREEN}Zsh${RC}       ${YELLOW}(enhanced features, popular alternative)${RC}"
  echo -e "  ${WHITE}3)${RC} ${GREEN}Fish${RC}      ${YELLOW}(modern, user-friendly, less POSIX-compatible)${RC}"
  echo ""

  read -p "  Enter your choice [1-3] (default: 1): " shell_choice

  case "$shell_choice" in
    2) SELECTED_SHELL="zsh"  ;;
    3) SELECTED_SHELL="fish" ;;
    *) SELECTED_SHELL="bash" ;;
  esac

  echo -e "${GREEN}  ✓ Selected shell: ${WHITE}$SELECTED_SHELL${RC}"
  echo ""
}

#=================================================================
# Configuration setup
#=================================================================
create_fastfetch_config() {
  echo -e "${CYAN}▶ Setting up fastfetch configuration...${RC}"

  if [ ! -d "$USER_HOME/.config/fastfetch" ]; then
    as_user mkdir -p "$USER_HOME/.config/fastfetch"
  fi
  # Check if the fastfetch config file exists
  if [ -e "$USER_HOME/.config/fastfetch/config.jsonc" ]; then
    rm -f "$USER_HOME/.config/fastfetch/config.jsonc"
  fi
  ln -svf "$GITPATH/config.jsonc" "$USER_HOME/.config/fastfetch/config.jsonc" || {
    echo -e "${RED}  ✗ Failed to create symbolic link for fastfetch config${RC}"
    echo -e "${YELLOW}  Using direct copy instead...${RC}"
    cp -f "$GITPATH/config.jsonc" "$USER_HOME/.config/fastfetch/config.jsonc"
  }
  echo -e "${GREEN}  ✓ Fastfetch configuration set up successfully${RC}"
  echo ""
}

setupShellConfig() {
  echo -e "${CYAN}▶ Setting up shell configuration for ${WHITE}$SELECTED_SHELL${CYAN}...${RC}"

  # Make sure all required directories exist (owned by the real user)
  as_user mkdir -p "$USER_HOME/.config/fish"
  as_user mkdir -p "$USER_HOME/.zsh"

  # Backup existing config files and set up new ones based on selected shell
  if [ "$SELECTED_SHELL" = "bash" ]; then
    if [ -e "$USER_HOME/.bashrc" ]; then
      BACKUP_FILE="$USER_HOME/.bashrc.bak.$(date +%Y%m%d%H%M%S)"
      echo -e "${YELLOW}  Backing up old bash config to ${WHITE}$BACKUP_FILE${RC}"
      cp -f "$USER_HOME/.bashrc" "$BACKUP_FILE"
    fi

    # Link Bash config
    echo -e "${YELLOW}  Creating bash configuration links...${RC}"
    ln -svf "$GITPATH/.bashrc" "$USER_HOME/.bashrc" || {
      echo -e "${YELLOW}  Using direct copy for .bashrc...${RC}"
      cp -f "$GITPATH/.bashrc" "$USER_HOME/.bashrc"
    }
    ln -svf "$GITPATH/.bashrc_help" "$USER_HOME/.bashrc_help" || {
      echo -e "${YELLOW}  Using direct copy for .bashrc_help...${RC}"
      cp -f "$GITPATH/.bashrc_help" "$USER_HOME/.bashrc_help"
    }

    # Link Bash aliases file
    if [ -f "$GITPATH/.bash_aliases" ]; then
      ln -svf "$GITPATH/.bash_aliases" "$USER_HOME/.bash_aliases" || {
        echo -e "${YELLOW}  Using direct copy for .bash_aliases...${RC}"
        cp -f "$GITPATH/.bash_aliases" "$USER_HOME/.bash_aliases"
      }
      echo -e "${GREEN}  ✓ Added .bash_aliases file${RC}"
    else
      # Create a minimal .bash_aliases file if it doesn't exist in the repository
      echo "# Custom user aliases - Created by dxsbash setup" > "$USER_HOME/.bash_aliases"
      echo "# Add your personal aliases below" >> "$USER_HOME/.bash_aliases"
      echo "" >> "$USER_HOME/.bash_aliases"
      echo -e "${GREEN}  ✓ Created basic .bash_aliases file${RC}"
    fi

    echo -e "${GREEN}  ✓ Bash configuration completed${RC}"

  elif [ "$SELECTED_SHELL" = "zsh" ]; then
    # Check if .zshrc exists and handle accordingly
    if [ -e "$USER_HOME/.zshrc" ]; then
      # Backup existing .zshrc
      BACKUP_FILE="$USER_HOME/.zshrc.bak.$(date +%Y%m%d%H%M%S)"
      echo -e "${YELLOW}  Backing up old zsh config to ${WHITE}$BACKUP_FILE${RC}"
      cp -f "$USER_HOME/.zshrc" "$BACKUP_FILE"
    fi

    # Link Zsh config
    echo -e "${YELLOW}  Installing dxsbash Zsh configuration...${RC}"
    ln -svf "$GITPATH/.zshrc" "$USER_HOME/.zshrc" || {
      echo -e "${YELLOW}  Using direct copy for .zshrc...${RC}"
      cp -f "$GITPATH/.zshrc" "$USER_HOME/.zshrc"
    }

    ln -svf "$GITPATH/.zshrc_help" "$USER_HOME/.zshrc_help" || {
      echo -e "${YELLOW}  Using direct copy for .zshrc_help...${RC}"
      cp -f "$GITPATH/.zshrc_help" "$USER_HOME/.zshrc_help"
    }

    # Install Oh My Zsh if not already installed.
    # KEEP_ZSHRC=yes is essential: without it the installer moves the
    # dxsbash ~/.zshrc symlink aside and replaces it with its own
    # template, so fresh zsh installs would boot with stock OMZ.
    if [ ! -d "$USER_HOME/.oh-my-zsh" ]; then
      echo -e "${YELLOW}  Installing Oh My Zsh...${RC}"
      KEEP_ZSHRC=yes sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" "" --unattended
      echo -e "${GREEN}  ✓ Oh My Zsh installed${RC}"
    else
      echo -e "${GREEN}  ✓ Oh My Zsh already installed${RC}"
    fi

    echo -e "${GREEN}  ✓ Zsh configuration completed${RC}"

  elif [ "$SELECTED_SHELL" = "fish" ]; then
    if [ -e "$USER_HOME/.config/fish/config.fish" ]; then
      BACKUP_DIR="$USER_HOME/.config/fish/backup"
      mkdir -p "$BACKUP_DIR"
      BACKUP_FILE="$BACKUP_DIR/config.fish.$(date +%Y%m%d%H%M%S)"
      echo -e "${YELLOW}  Backing up old fish config to ${WHITE}$BACKUP_FILE${RC}"
      cp -f "$USER_HOME/.config/fish/config.fish" "$BACKUP_FILE"
    fi

    # Link Fish config
    echo -e "${YELLOW}  Installing dxsbash Fish configuration...${RC}"
    ln -svf "$GITPATH/config.fish" "$USER_HOME/.config/fish/config.fish" || {
      echo -e "${YELLOW}  Using direct copy for config.fish...${RC}"
      cp -f "$GITPATH/config.fish" "$USER_HOME/.config/fish/config.fish"
    }

    # Create help file for fish
    ln -svf "$GITPATH/fish_help" "$USER_HOME/.config/fish/fish_help" || {
      echo -e "${YELLOW}  Using direct copy for fish_help...${RC}"
      cp -f "$GITPATH/fish_help" "$USER_HOME/.config/fish/fish_help"
    }

    # Setup Fisher plugin manager if not already installed.
    # NOTE: the old https://git.io/fisher redirect was shut down by
    # GitHub in 2022; install directly from the canonical location.
    if ! fish -c "type -q fisher" 2>/dev/null; then
      echo -e "${YELLOW}  Installing Fisher plugin manager for Fish...${RC}"
      local FISHER_URL="https://raw.githubusercontent.com/jorgebucaran/fisher/main/functions/fisher.fish"
      if fish -c "curl -sSfL $FISHER_URL | source && fisher install jorgebucaran/fisher"; then
        echo -e "${GREEN}  ✓ Fisher installed${RC}"

        echo -e "${YELLOW}  Installing Fish plugins...${RC}"
        fish -c "fisher install PatrickF1/fzf.fish" || \
          echo -e "${YELLOW}  ⚠ Could not install fzf.fish${RC}"
        fish -c "fisher install jethrokuan/z"      || \
          echo -e "${YELLOW}  ⚠ Could not install jethrokuan/z${RC}"
        fish -c "fisher install IlanCosman/tide@v5" || \
          echo -e "${YELLOW}  ⚠ Could not install tide${RC}"
        echo -e "${GREEN}  ✓ Fish plugins installed${RC}"
      else
        echo -e "${YELLOW}  ⚠ Fisher install failed; continuing without plugins${RC}"
      fi
    else
      echo -e "${GREEN}  ✓ Fisher already installed${RC}"
    fi

    echo -e "${GREEN}  ✓ Fish configuration completed${RC}"
  fi

  # Link starship.toml for all shells
  echo -e "${YELLOW}  Setting up Starship prompt configuration...${RC}"
  ln -svf "$GITPATH/starship.toml" "$USER_HOME/.config/starship.toml" || {
    echo -e "${YELLOW}  Using direct copy for starship.toml...${RC}"
    cp -f "$GITPATH/starship.toml" "$USER_HOME/.config/starship.toml"
  }
  echo -e "${GREEN}  ✓ Starship configuration completed${RC}"
  echo ""
}

#=================================================================
# Set default shell
#=================================================================
setDefaultShell() {
  echo -e "${CYAN}▶ Setting ${WHITE}$SELECTED_SHELL${CYAN} as your default shell...${RC}"

  SHELL_PATH=""
  case "$SELECTED_SHELL" in
    bash)
      SHELL_PATH=$(which bash)
      ;;
    zsh)
      SHELL_PATH=$(which zsh)
      ;;
    fish)
      SHELL_PATH=$(which fish)
      ;;
  esac

  if [ -z "$SHELL_PATH" ]; then
    echo -e "${RED}  ✗ Error: Could not find path to $SELECTED_SHELL.${RC}"
    echo -e "${YELLOW}  Please set it as your default shell manually after installation.${RC}"
    return 1
  fi

  # Check if the shell is in /etc/shells
  if ! grep -q "^$SHELL_PATH$" /etc/shells; then
    echo -e "${YELLOW}  Adding $SHELL_PATH to /etc/shells...${RC}"
    echo -e "$SHELL_PATH" | ${SUDO_CMD} tee -a /etc/shells > /dev/null
  fi

  # Change the default shell. Disable errexit locally so a chsh
  # failure (PAM, shell not yet in /etc/shells on some distros, etc.)
  # does not abort the rest of the install.
  echo -e "${YELLOW}  Changing default shell to ${WHITE}$SHELL_PATH${RC}"
  local chsh_rc=0
  if [ "$DRY_RUN" -eq 1 ]; then
    echo -e "  ${YELLOW}[dry-run]${RC} ${SUDO_CMD} chsh -s $SHELL_PATH $REAL_USER"
  else
    set +e
    ${SUDO_CMD} chsh -s "$SHELL_PATH" "$REAL_USER"
    chsh_rc=$?
    set -e
  fi

  if [ "$chsh_rc" -eq 0 ]; then
    echo -e "${GREEN}  ✓ Successfully set $SELECTED_SHELL as your default shell${RC}"
  else
    echo -e "${RED}  ✗ Failed to set $SELECTED_SHELL as your default shell (chsh rc=$chsh_rc).${RC}"
    echo -e "${YELLOW}  You can set it manually with:${RC}"
    echo -e "${WHITE}    chsh -s $SHELL_PATH${RC}"
  fi
  echo ""
}

#=================================================================
# Install utility scripts
#=================================================================
installResetScript() {
  echo -e "${CYAN}▶ Installing reset-shell-profile script...${RC}"

  # Link the repo's script for the selected shell (like every other
  # command) — earlier versions linked a copy in ~/linuxtoolbox that
  # updates never refreshed
  local src="$GITPATH/reset-${SELECTED_SHELL:-bash}-profile.sh"
  [ -f "$src" ] || src="$GITPATH/reset-bash-profile.sh"
  if [ -f "$src" ]; then
    chmod +x "$GITPATH"/reset-*-profile.sh 2>/dev/null
    ${SUDO_CMD} ln -sf "$src" /usr/local/bin/reset-shell-profile
    # Remove the stale copies older installs left in ~/linuxtoolbox
    rm -f "$LINUXTOOLBOXDIR"/reset-bash-profile.sh "$LINUXTOOLBOXDIR"/reset-zsh-profile.sh \
          "$LINUXTOOLBOXDIR"/reset-fish-profile.sh
    echo -e "${GREEN}  ✓ Reset script installed successfully${RC}"
    echo -e "    You can run it with: ${WHITE}sudo reset-shell-profile [username]${RC}"
  else
    echo -e "${RED}  ✗ Reset script not found in $GITPATH${RC}"
  fi
  echo ""
}

installUpdaterCommand() {
  echo -e "${CYAN}▶ Installing dxsbash updater script...${RC}"

  if [ -f "$GITPATH/updater.sh" ]; then
    chmod +x "$GITPATH/updater.sh"

    # System-wide: /usr/local/bin/update-dxsbash points at the repo copy
    # so updates self-propagate.
    ${SUDO_CMD} ln -sf "$GITPATH/updater.sh" /usr/local/bin/update-dxsbash

    # Convenience symlink in the real user's home
    as_user ln -sf "$GITPATH/updater.sh" "$USER_HOME/update-dxsbash.sh"

    echo -e "${GREEN}  ✓ Updater script installed successfully${RC}"
    echo -e "    Run ${WHITE}update-dxsbash${RC} to pull the latest version."
  else
    echo -e "${RED}  ✗ Updater script not found in $GITPATH${RC}"
    echo -e "${YELLOW}  You will need to update manually${RC}"
  fi
  echo ""
}

installConfigCommand() {
  echo -e "${CYAN}▶ Installing dxsbash-config command...${RC}"

  if [ -f "$GITPATH/dxsbash-config.sh" ]; then
    # Link the repo copy (as updater.sh and repair.sh do) so updates take
    # effect immediately; it loads settings-lib.sh from next to itself.
    chmod +x "$GITPATH/dxsbash-config.sh"
    ${SUDO_CMD} ln -sf "$GITPATH/dxsbash-config.sh" /usr/local/bin/dxsbash-config
    # Remove the stale copy older versions placed in ~/linuxtoolbox
    rm -f "$LINUXTOOLBOXDIR/dxsbash-config.sh"

    echo -e "${GREEN}  ✓ Configuration tool installed${RC}"
    echo -e "    Run ${WHITE}dxsbash-config${RC} to customise your environment."
  else
    echo -e "${RED}  ✗ dxsbash-config.sh not found in $GITPATH${RC}"
  fi
  echo ""
}

installLifecycleCommands() {
  echo -e "${CYAN}▶ Installing repair/uninstall/doctor/audit commands...${RC}"
  for src in repair.sh uninstall.sh doctor.sh secaudit.sh dxsbash.sh dxsbash-gui.sh; do
    if [ -f "$GITPATH/$src" ]; then
      chmod +x "$GITPATH/$src"
      case "$src" in
        repair.sh)    link_name="dxsbash-repair" ;;
        uninstall.sh) link_name="dxsbash-uninstall" ;;
        doctor.sh)    link_name="dxsbash-doctor" ;;
        secaudit.sh)  link_name="dxsbash-audit" ;;
        dxsbash.sh)   link_name="dxsbash" ;;
        dxsbash-gui.sh) link_name="dxsbash-gui" ;;
      esac
      ${SUDO_CMD} ln -sf "$GITPATH/$src" "/usr/local/bin/$link_name"
      echo -e "${GREEN}  ✓ /usr/local/bin/$link_name${RC}"
    else
      echo -e "${YELLOW}  ⚠ $src missing in repo${RC}"
    fi
  done

  # secsummary.sh is invoked by the shell rc files at login, not a
  # user-facing command — just make sure it is executable.
  [ -f "$GITPATH/secsummary.sh" ] && chmod +x "$GITPATH/secsummary.sh"
  [ -f "$GITPATH/gui-askpass.sh" ] && chmod +x "$GITPATH/gui-askpass.sh"
  echo ""
}

# Menu entry "DXSBash Settings" (System category) + icon, per user
installDesktopEntry() {
  if ! has_desktop; then
    echo -e "${YELLOW}  No graphical desktop detected — skipping the settings menu entry${RC}"
    echo -e "    (add it later with: ${WHITE}dxsbash-gui --install-desktop${RC})"
    echo ""
    return 0
  fi
  case "$(desktop_kind)" in
    kde)  echo -e "${CYAN}▶ KDE Plasma detected — installing DXSBash Settings (System menu)...${RC}" ;;
    xfce) echo -e "${CYAN}▶ XFCE detected — installing DXSBash Settings (System menu)...${RC}" ;;
    *)    echo -e "${CYAN}▶ Adding DXSBash Settings to the application menu...${RC}" ;;
  esac
  if as_user bash "$GITPATH/dxsbash-gui.sh" --install-desktop >/dev/null; then
    echo -e "${GREEN}  ✓ Menu entry installed (System → DXSBash Settings)${RC}"
    command_exists zenity || \
      echo -e "${YELLOW}  ⚠ zenity is not installed — the settings window needs it${RC}"
  else
    echo -e "${YELLOW}  ⚠ Could not install the menu entry${RC}"
  fi
  echo ""
}

#=================================================================
# Configure terminal
#=================================================================
configure_terminal() {
  echo -e "${CYAN}▶ Configuring terminal emulators...${RC}"

  # Resolve the command to run inside Konsole/Yakuake profiles so that
  # the selected shell (bash|zsh|fish) is actually launched instead of
  # the system default /usr/bin/bash.
  case "${SELECTED_SHELL:-bash}" in
    zsh)  PROFILE_SHELL_CMD="$(command -v zsh  2>/dev/null || echo /usr/bin/zsh)"  ;;
    fish) PROFILE_SHELL_CMD="$(command -v fish 2>/dev/null || echo /usr/bin/fish)" ;;
    *)    PROFILE_SHELL_CMD="$(command -v bash 2>/dev/null || echo /bin/bash)"     ;;
  esac

  # Helper: ensure DefaultProfile=DXSBash.profile lives under [Desktop Entry]
  # in the given rc file (konsolerc / yakuakerc), creating the file or
  # section as needed.
  set_default_profile() {
    local rcfile="$1"
    mkdir -p "$(dirname "$rcfile")"
    if [ ! -f "$rcfile" ]; then
      cat > "$rcfile" <<EOL
[Desktop Entry]
DefaultProfile=DXSBash.profile
EOL
    elif grep -q "^\[Desktop Entry\]" "$rcfile"; then
      if grep -q "^DefaultProfile=" "$rcfile"; then
        sed -i "s|^DefaultProfile=.*|DefaultProfile=DXSBash.profile|" "$rcfile"
      else
        sed -i "/^\[Desktop Entry\]/a DefaultProfile=DXSBash.profile" "$rcfile"
      fi
    else
      printf '\n[Desktop Entry]\nDefaultProfile=DXSBash.profile\n' >> "$rcfile"
    fi
    if [ "$(id -u)" -eq 0 ]; then
      chown "$REAL_USER:$REAL_GROUP" "$rcfile"
    fi
  }

  # Configure Konsole if present
  if command_exists konsole; then
    echo -e "${YELLOW}  Configuring Konsole terminal...${RC}"

    # Create Konsole profile directory if it doesn't exist
    KONSOLE_DIR="$USER_HOME/.local/share/konsole"
    mkdir -p "$KONSOLE_DIR"

    # Create/update Konsole profile with FiraCode Nerd Font
    PROFILE_NAME="DXSBash.profile"
    PROFILE_PATH="$KONSOLE_DIR/$PROFILE_NAME"

    # Create profile file. Command= pins the shell to the one selected
    # during setup so new Konsole tabs launch zsh/fish when chosen.
    cat > "$PROFILE_PATH" << EOL
[Appearance]
ColorScheme=Breeze
Font=FiraCode Nerd Font,12,-1,5,50,0,0,0,0,0

[General]
Command=$PROFILE_SHELL_CMD
Name=DXSBash
Parent=FALLBACK/
TerminalCenter=false
TerminalMargin=1

[Scrolling]
HistoryMode=2
ScrollBarPosition=2

[Terminal Features]
BlinkingCursorEnabled=true
EOL

    # Set correct permissions (only relevant when running under sudo)
    if [ "$(id -u)" -eq 0 ]; then
      chown "$REAL_USER:$REAL_GROUP" "$PROFILE_PATH"
    fi

    # Color scheme matching the prompt theme (DXSBASH_TERM_COLORS);
    # keeps Breeze if the user turned the feature off
    if [ -f "$GITPATH/dxsbash-gui.sh" ]; then
      as_user bash "$GITPATH/dxsbash-gui.sh" --apply-colors >/dev/null 2>&1 || true
    fi

    # Update konsolerc to use this profile as the default
    set_default_profile "$USER_HOME/.config/konsolerc"

    echo -e "${GREEN}  ✓ Konsole configured${RC}"
  fi

  # Configure Yakuake if present (shares Konsole profiles)
  if command_exists yakuake; then
    echo -e "${YELLOW}  Configuring Yakuake terminal...${RC}"

    set_default_profile "$USER_HOME/.config/yakuakerc"

    echo -e "${GREEN}  ✓ Yakuake configured${RC}"
  fi

  # No special configuration for generic terminals
  echo -e "${GREEN}  ✓ Terminal configuration completed${RC}"
  echo ""
}

#=================================================================
# Final setup and cleanup
#=================================================================
# Updated finalSetup() function that fixes the file copying issue

finalSetup() {
  echo -e "${CYAN}▶ Performing final setup tasks...${RC}"

  # Create runtime logs dir in the real user's home
  echo -e "${YELLOW}  Creating log directory...${RC}"
  as_user mkdir -p "$USER_HOME/.dxsbash/logs"
  as_user touch   "$USER_HOME/.dxsbash/logs/dxsbash.log"
  as_user chmod 644 "$USER_HOME/.dxsbash/logs/dxsbash.log"

  # Copy the utilities file only if source and destination are different
  if [ -f "$GITPATH/dxsbash-utils.sh" ]; then
    # Get the full path of both files to compare
    SOURCE="$(realpath "$GITPATH/dxsbash-utils.sh")"
    DEST="$(realpath "$LINUXTOOLBOXDIR/dxsbash/dxsbash-utils.sh")"

    # Only copy if they are different files
    if [ "$SOURCE" != "$DEST" ]; then
      echo -e "${YELLOW}  Installing utility scripts...${RC}"
      cp -f "$SOURCE" "$DEST"
      chmod +x "$DEST"
    else
      echo -e "${YELLOW}  Utility script already in place, ensuring executable permission...${RC}"
      chmod +x "$DEST"
    fi
  fi

  echo -e "${GREEN}  ✓ Final setup completed${RC}"
  echo ""
}

#=================================================================
# Main installation flow
#=================================================================
main() {
  # Check environment
  checkEnv

  # Detect distribution
  detectDistro

  # Select shell (honours --shell / DXSBASH_SHELL / prompt)
  selectShell

  # Show plan and ask for confirmation
  show_preflight

  # Clone or pull repo (safe when re-run from inside)
  initialize

  # Install dependencies
  installDepend

  # Install additional tools
  installStarshipAndFzf
  installZoxide

  # Configure the system
  create_fastfetch_config
  setupShellConfig
  setDefaultShell
  installResetScript
  installUpdaterCommand
  installConfigCommand
  installLifecycleCommands
  installDesktopEntry
  configure_terminal

  # Final setup
  finalSetup

  # Display completion message
  echo -e "${BLUE}╔════════════════════════════════════════════════════════╗ ${RC}"
  echo -e "${BLUE}║                                                          ${RC}"
  echo -e "${BLUE}║  ${GREEN}Installation Complete!${BLUE}                   ${RC}"
  echo -e "${BLUE}║                                                          ${RC}"
  # shellcheck disable=SC2088  # literal tilde is intentional (display only)
  local config_label="~/.${SELECTED_SHELL}rc"
  # shellcheck disable=SC2088
  [ "$SELECTED_SHELL" = "fish" ] && config_label="~/.config/fish/config.fish"
  echo -e "${BLUE}║  ${WHITE}• Shell:${YELLOW} $SELECTED_SHELL${BLUE}        ${RC}"
  echo -e "${BLUE}║  ${WHITE}• Config:${YELLOW} ${config_label}${BLUE} ${RC}"
  echo -e "${BLUE}║  ${WHITE}• Settings:${YELLOW} dxsbash-gui (menu: System → DXSBash Settings)${BLUE} ${RC}"
  echo -e "${BLUE}║  ${WHITE}• Update:${YELLOW} update-dxsbash${BLUE}             ${RC}"
  echo -e "${BLUE}║  ${WHITE}• Repair:${YELLOW} dxsbash-repair${BLUE}             ${RC}"
  echo -e "${BLUE}║  ${WHITE}• Doctor:${YELLOW} dxsbash-doctor${BLUE}             ${RC}"
  echo -e "${BLUE}║  ${WHITE}• Uninstall:${YELLOW} dxsbash-uninstall${BLUE}          ${RC}"
  echo -e "${BLUE}║  ${WHITE}• Reset:${YELLOW} sudo reset-shell-profile [username]${BLUE} ${RC}"
  echo -e "${BLUE}║                                                          ${RC}"
  echo -e "${BLUE}║  ${YELLOW}Please log out and log back in to use your new shell${BLUE} ${RC}"
  echo -e "${BLUE}║                                                          ${RC}"
  if [ "$DISTRO" = "unknown" ]; then
    echo -e "${BLUE}║  ${RED}Note: DXSBash targets Debian, Ubuntu, Arch and Fedora${BLUE} ${RC}"
    echo -e "${BLUE}║  ${RED}Some features may not work as expected on your system${BLUE} ${RC}"
    echo -e "${BLUE}║                                                        ${RC}"
  fi
  echo -e "${BLUE}║  ${RED}This Software is GNU/GPLv3${BLUE}                 ${RC}"
  echo -e "${BLUE}║                                                          ${RC}"
  echo -e "${BLUE}╚════════════════════════════════════════════════════════╝ ${RC}"
  echo -e "  ${CYAN}Made by Luis Miguel P. Freitas - DigitalXS.ca - 2025${RC}"
  echo ""
}

# Run the main installation
main