# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
  command -v "$@" >/dev/null 2>&1
}

#
# Check if the user is root and set sudo variable if necessary
check_root() {
  if [[ "${EUID}" -ne 0 ]]; then
    if command_exists sudo; then
      echo_info "User <$(whoami)> is not root. Using sudo for privileged operations."
      _sudo="sudo"
    else
      echo_error "No sudo found and you're not root! Can't install packages."
    fi
  else
    echo_info "Root access confirmed."
    _sudo=""
  fi
}

# ───────────────────────────────────< Message storage >─────────────────────────────────
typeset -A _MESSAGES
_MESSAGES=(
  [error]=""
  [warn]=""
  [info]=""
)

# Define color variables
RED='\033[0;31m'
YELLOW='\033[0;33m'
CYAN='\033[0;36m'
GREEN='\033[1;32m'
NC='\033[0m' # No Color
BOLD='\033[1m'

# Functions to store messages
echo_error() {
  _MESSAGES[error]+="${RED}❌ $1${NC}\n"
}

echo_warning() {
  _MESSAGES[warn]+="${YELLOW}⚠️  $1${NC}\n"
}

echo_info() {
  _MESSAGES[info]+="${CYAN}ℹ️  $1${NC}\n"
}

# Display stored messages
error_log() {
  [[ -z "${_MESSAGES[error]}${_MESSAGES[warn]}${_MESSAGES[info]}" ]] && return 0

  typeset -A headers colors
  headers=(
    error "❌ Errors"
    warn "⚠️  Warnings"
    info "ℹ️  Info"
  )
  colors=(
    error "$RED"
    warn "$YELLOW"
    info "$CYAN"
  )

  for type in error warn info; do
    [[ -n "${_MESSAGES[$type]}" ]] && {
      printf "\n${BOLD}${colors[$type]}=== ${headers[$type]} ===${NC}\n"
      printf "${_MESSAGES[$type]}"
    }
  done
}

__shell_qol__() {
  if command_exists oh-my-posh; then
    # eval "$(oh-my-posh init zsh --config 'https://git.k4li.de/dotfiles/oh-my-posh/raw/branch/main/amro.toml')"
    eval "$(oh-my-posh init zsh --config '~/.zsh/themes/power10k_edit.toml')"
  else
    curl -s https://ohmyposh.dev/install.sh | $_sudo bash --norc -s -- -d /usr/bin/
  fi

  # ─< init fzf for zsh >───────────────────────────────────────────────────────────────────
  if command_exists fzf; then
    source <(fzf --zsh)
  fi

  if command_exists zoxide; then
    eval "$(zoxide init zsh)"
    eval "$(zoxide init zsh --cmd cd)"
  fi
}

__get_Packager__() {
  # Load OS release information
  [ -f /etc/os-release ] && . /etc/os-release || return 1

  DISTRO="${ID}:${ID_LIKE}"

  case "$DISTRO" in
  *debian*)
    if command_exists nala; then
      alias search="nala search"
      alias install="$_sudo nala install --assume-yes"
      alias update="$_sudo nala update && $_sudo nala upgrade --full"
      alias remove="$_sudo nala purge"
    else
      alias search="apt-cache search"
      alias install="$_sudo apt install --yes"
      alias update="$_sudo apt update && $_sudo apt upgrade"
      alias remove="$_sudo apt purge"
    fi
    alias unbreak="$_sudo dpkg --configure -a"
    ;;
  *arch*)
    if command_exists paru; then
      alias search="paru -Ss"
      alias install="paru -S --noconfirm"
      alias update="paru -Syu"
      alias remove="paru -R"
    elif command_exists yay; then
      alias search="yay -Ss --color always"
      alias install="yay -S --noconfirm --color always"
      alias update="yay -Syu --color always"
      alias remove="yay -R --color always"
    else
      alias search="$_sudo pacman -Ss"
      alias install="$_sudo pacman -S --noconfirm"
      alias update="$_sudo pacman -Syu"
      alias remove="$_sudo pacman -R"
    fi
    ;;
  *rhel* | *fedora*)
    alias search="dnf search"
    alias install="$_sudo dnf install -y --skip-missing"
    alias update="$_sudo dnf update -y"
    alias remove="$_sudo dnf remove -y"
    ;;
  *suse*)
    alias search="zypper search"
    alias install="$_sudo zypper install --no-confirm"
    alias update="$_sudo zypper update"
    alias remove="$_sudo zypper remove"
    ;;
  *alpine*)
    alias install="$_sudo apk add"
    alias update="$_sudo apk update && $_sudo apk upgrade"
    alias remove="$_sudo apk del"
    ;;
  *nixos*)
    echo_info "Using NIX!!"
    alias update="$_sudo nixos-rebuild switch"
    # alias install="$_sudo nix-env -iA nixos."
    install() {
      "$_sudo nix-end -iA nixos.$@"
    }
    alias edit="$_sudo -E $EDITOR /etc/nixos/configuration.nix"
    ;;
  *)
    echo_error "Unsupported distro: $ID"
    ;;
  esac
}

__podman__() {
  alias up="podman-compose up"
  alias down="podman-compose down"
  alias pull="podman-compose pull"
  alias dr="podman run --rm -it"
  alias drs="podman-compose down && podman-compose up -d --remove-orphans --force-recreate"
  alias ds="podman ps -a --format 'table {{.ID}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'"
  alias dcs="podman-compose ps -a --format 'table {{.Name}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'"
  alias dl="podman-compose logs -f"
  alias dc="podman-compose"
}

__docker__() {
  alias up="docker compose up"
  alias down="docker compose down"
  alias pull="docker compose pull"
  alias d="docker"
  alias dr="docker run --rm -it"
  alias drs="docker compose down && docker compose up -d --remove-orphans --force-recreate"
  alias ds="docker ps -a --format 'table {{.ID}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'"
  alias dcs="docker compose ps -a --format 'table {{.Name}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'"
  alias dl="docker compose logs -f"
  alias dc="docker compose"
  # check_for_updates() {
  #   if ! command -v jq &>/dev/null; then
  #     echo -e "${RED}Error: jq is required but not installed. Please install jq.${NC}"
  #     return 1
  #   fi
  #
  #   if ! docker compose version &>/dev/null; then
  #     echo -e "${RED}Error: docker compose is not available.${NC}"
  #     return 1
  #   fi
  #
  #   local updated=false
  #   local images
  #   images=$(docker compose config --format json | jq -r '.services[] | .image' 2>/dev/null)
  #
  #   if [[ -z "$images" ]]; then
  #     echo -e "${RED}Error: No Docker images found in the compose configuration.${NC}"
  #     return 1
  #   fi
  #
  #   for image in $images; do
  #     echo -e "${CYAN}Checking for updates for image: ${YELLOW}$image${NC}"
  #
  #     # Get local image digest
  #     local local_digest
  #     local_digest=$(docker image inspect "$image" --format '{{index .RepoDigests 0}}') # 2>/dev/null
  #
  #     # If no local digest exists, force check
  #     if [[ -z "$local_digest" ]]; then
  #       echo -e "${YELLOW}Image not present locally. Update needed.${NC}"
  #       updated=true
  #       continue
  #     fi
  #
  #     # Get remote digest using pull --dry-run
  #     local remote_digest
  #     remote_digest=$(docker pull --quiet "$image" 2>/dev/null | awk '/Digest:/{print $2}')
  #
  #     # Fallback to manifest inspect if dry-run fails
  #     if [[ -z "$remote_digest" ]]; then
  #       remote_digest=$(DOCKER_CLI_EXPERIMENTAL=enabled docker manifest inspect -v "$image" | jq -r '.Descriptor.digest')
  #     fi
  #
  #     if [[ -z "$remote_digest" ]]; then
  #       echo -e "${RED}Failed to retrieve remote digest. Performing forced check...${NC}"
  #       # Fallback method: Pull image and compare before/after digests
  #       local pre_pull_digest=$(docker image inspect "$image" --format '{{index .RepoDigests 0}}')
  #       docker pull --quiet "$image" >/dev/null
  #       local post_pull_digest=$(docker image inspect "$image" --format '{{index .RepoDigests 0}}')
  #
  #       if [[ "$pre_pull_digest" != "$post_pull_digest" ]]; then
  #         echo -e "${GREEN}Update found during forced pull${NC}"
  #         updated=true
  #       fi
  #       continue
  #     fi
  #
  #     # Compare digests
  #     if [[ "$local_digest" != "$remote_digest" ]]; then
  #       echo -e "${GREEN}Update available for $image${NC}"
  #       updated=true
  #     else
  #       echo -e "${YELLOW}No update available for $image${NC}"
  #     fi
  #   done
  #
  #   if $updated; then
  #     echo -e "${CYAN}Pulling updates and recreating containers...${NC}"
  #     docker compose pull --quiet && docker compose up -d --force-recreate
  #   else
  #     echo -e "${GREEN}All images are up to date. No action needed.${NC}"
  #   fi
  # }
  # Check for required dependencies
  check_for_updates() {
    local compose_cmd
    # Determine available compose command
    if command -v docker-compose &>/dev/null; then
      compose_cmd="docker-compose"
    elif docker compose version &>/dev/null; then
      compose_cmd="docker compose"
    else
      echo "Error: docker-compose or docker compose not found."
      return 1
    fi

    # Check for compose file
    if [ ! -f docker-compose.yml ] && [ ! -f docker-compose.yaml ] && [ ! -f compose.yml ]; then
      echo "Error: No docker-compose.yml/yaml found in current directory."
      return 1
    fi

    # Pull images and capture output
    local pull_output
    if ! pull_output=$(LC_ALL=C $compose_cmd pull 2>&1); then
      echo "Error pulling images:"
      echo "$pull_output"
      return 1
    fi

    # Check for updated images
    local updated=0
    if echo "$pull_output" | grep -q "Downloaded newer image"; then
      updated=1
    fi

    # Update containers if needed
    if [ $updated -eq 1 ]; then
      echo "Updates found. Updating containers..."
      $compose_cmd up -d
      echo "Cleaning up old images..."
      docker system prune -f
      echo "Update completed."
    else
      echo "All containers are up to date. Current versions:"
      $compose_cmd images | awk '{if(NR>1) print $2, $3, $4}'
    fi
  }
  alias appupdate="check_for_updates"

  if ! command_exists gmd; then
    alias gmd='bash -c "$(curl -sLo- https://raw.githubusercontent.com/ajayd-san/gomanagedocker/main/install.sh)" && "$SHELL"'
  fi
}

__git__() {
  # ─< lazygit >────────────────────────────────────────────────────────────────────────────
  if command_exists lazygit; then
    alias lg="lazygit"
  fi

  # ───────────────────────────────────────< aliases >─────────────────────────────────────
  alias g="git"
  alias gs="git status -sb"
  alias gsl="git status"
  alias gm='git checkout main && git merge'
  alias gc="git clone --recurse-submodule"
  alias gd="git diff"
  alias ga="gd $1 && git add"
  alias gp='echo "${CYAN}Updating submodules..${NC}" && git submodule update --init --recursive && echo "${CYAN}Pulling down submodules..${NC}" && git pull --recurse-submodule'
  alias gms='git maintenance start'
  alias gcm="git commit -m"
  alias gpu="git push --recurse-submodule=on-demand"

  # ──────────────────────────────────────< functions >────────────────────────────────────
  gcl() {
    if [ -z "$2" ]; then
      git clone --depth=1 "https://github.com/$1"
    else
      git clone --depth=1 "https://github.com/$1" "$2"
    fi
  }
  gck() {
    if [ -z "$2" ]; then
      git clone --recurse-submodules --depth=1 "https://git.k4li.de/$1"
    else
      git clone --recurse-submodules --depth=1 "https://git.k4li.de/$1" "$2"
    fi
  }
  gcs() {
    if [ -z "$2" ]; then
      git clone --recurse-submodules --depth=1 "git@git.k4li.de:$1"
    else
      git clone --recurse-submodules --depth=1 "git@git.k4li.de:$1" "$2"
    fi
  }
  gsu() {
    echo "${CYAN}Updating submodules recursively with -> ${YELLOW}${BOLD}git submodule update --init --recursive${NC}"
    git submodule update --init --recursive &&
      echo "${CYAN}${BOLD}-- Updated submodules recursively --${NC}"

    echo "${CYAN}${BOLD}-- Checking submodule branches... --${NC}"
    git submodule foreach '
        branch=$(git symbolic-ref --short HEAD 2>/dev/null || echo "detached")
        if [ "$branch" = "detached" ]; then
          default_branch=$(git config -f $toplevel/.gitmodules submodule.$name.branch || echo "main")
          echo "${RED}${BOLD}Submodule $name is detached. Checking out ${YELLOW} $default_branch${RED}...${NC}"
          git checkout $default_branch
        else
          echo "${GREEN}${BOLD}Submodule $name is on branch $branch.${NC}"
        fi
      '

    echo "${CYAN}Pulling down updates recursively with -> ${YELLOW}${BOLD}git submodule foreach git pull --recurse-submodule${NC}"
    git submodule foreach git pull --recurse-submodule &&
      echo "${GREEN}${BOLD}-- pulled down submodules recursively --${NC}"

    gUpdateModules() {
      if ! git diff --exit-code .; then
        echo "${CYAN}${BOLD}Staging changes...${NC}"
        git add . || echo "GIT ADD MISSFUNCTION"
        sleep 0.3
        if git commit -m " update: submodules"; then
          echo "${GREEN}${BOLD}commit message ${RED}' update: submodules'${GREEN} successfully commited${NC}"
        else
          echo "${RED}${BOLD}Failed to commit changes.${NC}"
          return 1
        fi
      else
        echo "${GREEN}${BOLD}No changes to commit.${NC}"
        return 1
      fi
    }

    if gUpdateModules; then
      if git push; then
        echo "${GREEN}${BOLD}Push successful.${NC}"
      else
        echo "${RED}${BOLD}Failed to push changes.${NC}"
        return 1
      fi
    fi
  }

  gwip() {
    # Fetch the latest changes from the remote
    git fetch

    # Get the current branch name
    local branch
    branch=$(git rev-parse --abbrev-ref HEAD)

    # Check if there are any changes on the remote branch
    if git diff --quiet "$branch" "origin/$branch"; then
      local commit_message="${1:-wip}"
      echo "${CYAN}No changes on the remote branch. Adding changes and pushing with ${RED}${BOLD}'$commit_message'${NC}${CYAN} commit.${NC}"
      git add .
      git commit -m "$commit_message"
      git push
    else
      echo "${RED}${BOLD}There are changes on the remote branch. Please pull the latest changes first.${NC}"
    fi
  }
}

__alias__() {
  __get_Packager__

  alias please="sudo"
  alias untar="tar -xf"

  # ─< easier dir up >────────────────────────────────────────────────────────────────────────
  alias ..="cd .."

  # ─< weather >──────────────────────────────────────────────────────────────────────────────
  alias www="curl wttr.in/Ulm"

  # ─< colored ip >───────────────────────────────────────────────────────────────────
  alias ip="ip --color=always"

  # ─< check for rg >─────────────────────────────────────────────────────────────────────────
  if command_exists rg; then
    alias grep="rg --color=always"
    alias hl="rg --passthrough"
  else
    alias grep="grep --color=always"
    alias hl="grep --passthrough"
  fi

  # ─< define copy command >────────────────────────────────────────────────────────────────
  if command_exists wl-copy; then
    copy() {
      if cat "$1"; then
        command cat "$1" | wl-copy
      else
        "$1" | wl-copy
      fi
    }
  elif command_exists xclip; then
    copy() {
      if cat "$1"; then
        command cat "$1" | wl-copy
      else
        "$1" | xclip -selection clipboard
      fi
    }
  else
    echo_warning "No clipboard utility found. Please install wl-copy or xclip."
  fi

  # ─< linutil >────────────────────────────────────────────────────────────────────────────
  alias linutil="curl -fsSL https://christitus.com/linux | sh"
  alias "linutil-dev"="curl -fsSL https://christitus.com/linuxdev | sh"

  # ─< telnet (starwars) >────────────────────────────────────────────────────────────────────
  if command_exists telnet; then
    alias starwars="telnet -a telehack.com"
  fi

  if command_exists hyprpanel; then
    alias get_cpu='for i in /sys/class/hwmon/hwmon*/temp*_input; do echo "$(<$(dirname $i)/name): $(cat ${i%_*}_label 2>/dev/null || echo $(basename ${i%_*})) $(readlink -f $i)"; done'
  fi

  # ─< rsync >────────────────────────────────────────────────────────────────────────────────
  if command_exists rsync; then
    alias scp="rsync -avP"
    alias cp="rsync -avP"
  fi

  [[ -f "$HOME/go/bin/lazygit" ]] &&
    alias lazygit="$HOME/go/bin/lazygit" &&
    alias lg="lazygit"

  # ─< cli explorer >───────────────────────────────────────────────────────────────────────
  if command_exists yazi; then
    echo_info "yazi is the explorer of choice"
    alias lf="yazi || ya pack -i"
    # ─< yazi move when exit >────────────────────────────────────────────────────────────────
    function y() {
      local tmp="$(mktemp -t "yazi-cwd.XXXXXX")" cwd
      yazi "$@" --cwd-file="$tmp"
      if cwd="$(command cat -- "$tmp")" && [ -n "$cwd" ] && [ "$cwd" != "$PWD" ]; then
        builtin cd -- "$cwd"
      fi
      rm -f -- "$tmp"
    }
  elif command_exists ranger; then
    echo_info "ranger is the explorer of choice"
    alias lf="ranger"
  elif command_exists lf; then
    echo_info "lf is the explorer of choice"
  fi

  # ─< colorized ls >─────────────────────────────────────────────────────────────────────────
  if command_exists exa; then
    alias ls="exa --icons -l --git"
    alias l="exa --long --no-filesize --no-permissions --no-time --git --colour-scale --icons"
    alias ll="exa --all --long --no-filesize --no-permissions --no-time --git --colour-scale --icons"
    alias tree="exa --icons -l --tree"
  elif command_exists lsd; then
    alias ls="lsd -l -1 -h1 --almost-all --git"
    alias l="lsd -1"
    alias ll="lsd -1 --almost-all"
    alias clearl="command clear && l"
    alias tree="lsd --tree"
  elif command_exists eza; then
    alias ls="eza --icons --long --git"
    alias l="eza --icons -l"
    alias ll="eza --icons -laa"
    alias tree="eza --icons -l --tree"
  else
    alias ls="ls --color=always -lAph"
    alias l="ls --color=always -lph -w1"
    alias ll="ls --color=always -lph"
  fi

  # ─< t stands for trash(-cli) >───────────────────────────────────────────────────────────────
  if command_exists trash; then
    alias rm="trash"
    alias t="trash"
  elif command_exists trash-cli; then
    alias rm="trash-cli"
    alias t="trash-cli"
  else
    echo_error "-- You do not have trash or trash-cli installed! Your 'rm' will be permanent! --"
  fi

  # ─< bat alias >────────────────────────────────────────────────────────────────────────────
  if command_exists batcat; then
    alias cat="batcat --color=always -p --paging=never"
    alias less="batcat --paging always --color=always"
    # alias gd="batcat --diff"
  elif command_exists bat; then
    alias cat="bat --color=always -p"
    alias less="bat --paging always --color=always"
    # alias gd="bat --diff"
  fi

  # ─< wireshark / termshark alias >────────────────────────────────────────────────────────
  if command_exists termshark; then
    alias ws="$_sudo termshark"
  fi

  # ─< fastfetch >────────────────────────────────────────────────────────────────────────────
  if command_exists fastfetch; then
    alias ff="fastfetch"
    alias clearff="command clear & fastfetch"
    alias clearf="command clear & fastfetch"
    if fastfetch --config os >/dev/null 2>&1; then
      alias f="fastfetch --config os"
    else
      git clone https://git.k4li.de/mirrors/fastfetch.git "$HOME/.local/share/fastfetch" >/dev/null 2>&1
      exec "$SHELL"
    fi
  fi

  # ─< d stands for docker >──────────────────────────────────────────────────────────────────
  if command_exists docker; then
    echo_warning "󰡨 Using docker!"
    __docker__
  elif command_exists podman-compose; then
    echo_warning " Using podman!! "
    __podman__
  fi

  # ─< g stands for GIT >─────────────────────────────────────────────────────────────────────
  if command_exists git; then
    __git__
  fi

  # ─< install lazydocker >─────────────────────────────────────────────────────────────────
  alias inst_lazydocker="curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash"

  # ─< Function to determine which Neovim command to use >──────────────────────────────────
  choose_nvim() {
    if [ -n "$TMUX" ]; then
      # If inside an active tmux session, use nvim
      echo "command nvim"
      return
    elif [ -n "$DISPLAY" ] || [ -n "$WAYLAND_DISPLAY" ]; then
      # If in a graphical environment, use Neovide
      if command_exists neovide; then
        echo "neovide --fork"
        return
      fi
    fi
    # Default to nvim
    echo "command nvim"
  }

  # Set up Neovim aliases based on environment
  if command_exists nvim; then
    alias cnvim="command nvim"
    alias nvim="$(choose_nvim)"
    nv() {
      NVIM_APPNAME="$1" command nvim "${@:2}"
    }

    if [ -d "$HOME/.config/nvdev" ]; then
      alias nvdev='NVIM_APPNAME="nvdev" command nvim'
      alias neodev='NVIM_APPNAME="nvdev" neovide --fork'
    fi
  fi

  # Tmux session manager
  if command_exists tmux; then
    ta() {
      if tmux list-sessions >/dev/null 2>&1; then
        echo "-- tmux session active! | Connecting to active session --"
        sleep 0.3
        tmux attach
      else
        echo "-- No tmux session found! | Creating one --"
        sleep 0.3
        tmux
      fi
    }

    alias ts="tmux source $HOME/.tmux.conf"
  fi
}

_coding_() {
  # ─< h stands for HUGO >──────────────────────────────────────────────────────────────────
  if command_exists hugo; then
    alias h='hugo'
    alias hs='hugo server -D --noHTTPCache --disableFastRender' # --bind "$(get_ip)"'
  fi
  # ─< c stands for bin/cake >──────────────────────────────────────────────────────────────
  # alias cake='bin/cake'
  # alias c='cake'
  # alias cs='c server -p 1313'
  # ─< VSCodium >─────────────────────────────────────────────────────────────────────────────
  if command_exists codium; then
    alias code="codium"
    export EDITOR="codium"
  fi

  cursor_exe="/mnt/c/Users/piecka/AppData/Local/Programs/cursor/Cursor.exe"
  if [ -e "$cursor_exe" ]; then
    alias code="$cursor_exe"
  fi

  # Function to get the IP address
  get_ip() {
    ip a | grep 'inet ' | grep -v '127.0.0.1' | awk '{print $2}' | cut -d/ -f1 | head -n 1
  }

  if command_exists composer; then
    alias laravel_new="composer create-project laravel/laravel"
  fi

  # Check if php is available, then create the alias
  if command_exists php; then
    alias phprun="php artisan serve --host=$(get_ip) --port=8000"
  fi

  # Check if npm is available, then create the alias
  if command_exists npm; then
    npmrun() {
      npmrun_help() {
        echo "Usage: npmrun [environment] [optional:port]"
        echo "  environment: The npm environment you want to run (e.g. dev)"
        echo "  port:        Port to use (default: 8000)"
        return
      }
      if [[ "$1" == "--help" || "$1" == "-h" ]]; then
        npmrun_help
        return
      fi

      local env="$1"
      local port="${2:-8080}"

      npm run "$env" -- --host="$(get_ip)" --port="$port"
    }
  fi
}

__sources__() {
  # if [ -e "$HOME/.bash_aliases" ]; then
  #   echo_info "Loadet bash_aliases"
  #   . "$HOME/.bash_aliases"
  # else
  #   if command_exists curl; then
  #     curl -fsSL https://git.k4li.de/dotfiles/bash/raw/branch/main/.bash_aliases -o "$HOME/.bash_aliases"
  #     echo_info "(Down)loadet bash_aliases"
  #     . "$HOME/.bash_aliases"
  #   else
  #     echo_warning "Couldn't setup aliases properly.."
  #   fi
  # fi

  local sourceDir="$HOME/.zsh"
  local sourceOptions=(
    # "defaults"
    "plugins"
    "installs"
  )

  for _s in "${sourceOptions[@]}"; do
    local _source_="${sourceDir}/.${_s}.zsh"
    if [ -e "$_source_" ]; then
      . $_source_
    fi
    local _source_""
  done
}

__defaults__() {
  # Load completions
  autoload -Uz compinit && compinit

  bindkey -e

  # # Define custom word style that treats special characters as word boundaries
  autoload -Uz select-word-style
  select-word-style bash

  setopt appendhistory
  setopt sharehistory
  setopt hist_ignore_space
  setopt hist_ignore_all_dups
  setopt hist_save_no_dups
  setopt hist_ignore_dups
  setopt hist_find_no_dups

  # Huge history. Doesn't appear to slow things down, so why not?
  HISTSIZE=500000
  HISTFILESIZE=100000

  HISTFILE=~/.zsh_history
  SAVEHIST=$HISTSIZE
  HISTDUP=erase
  # Completion styling
  zstyle :compinstall filename "$HOME/.zshrc"
  zstyle ':completion:*' matcher-list 'm:{a-z}={A-Za-z}'
  # zstyle ':completion:*' list-colors "${(s.:.)LS_COLORS}"
  zstyle ':completion:*' menu no
  zstyle ':fzf-tab:complete:cd:*' fzf-preview 'ls --color $realpath'
  zstyle ':fzf-tab:complete:__zoxide_z:*' fzf-preview 'ls --color $realpath'
  setopt autocd notify
  # End of lines configured by zsh-newuser-install
}

__end__() {
  if command_exists fastfetch; then
    clear &&
      fastfetch

  else
    echo_warning "fastfetch is not installed.."
  fi

  if command_exists cowsay; then
    alias clear='clear && cowsay -f tux "$(uptime --pretty)"'
    cowsay -f tux "$(uptime --pretty)"
  else
    echo_warning "cowasy is not installed.."
  fi

  __shell_qol__
  error_log
}

main() {
  __defaults__
  __alias__
  __sources__
  __end__
}

if check_root; then
  main
fi