zsh/.zsh/.aliases.zsh

# 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'

# INFO:
# ╭──────────╮
# │ defaults │
# ╰──────────╯
alias sudo="sudo -E"
alias please="sudo"

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

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

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

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

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

hm() {
  find -type f -name "${1}" | wc -l
}

if command_exists dog; then
  alias dig="dog"
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_missing "wl-clipboard | xclip"
fi

# ─< 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"
else
  echo_missing "rsync"
fi

# ─< 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() {
    appname="$1"
    shift
    if [ "$#" -eq 0 ]; then
      NVIM_APPNAME="$appname" command nvim
    else
      NVIM_APPNAME="$appname" command nvim "$@"
    fi
  }

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

# ─< cli explorer >───────────────────────────────────────────────────────────────────────
if command_exists yazi; then
  echo_info "yazi is the explorer of choice"
  # ─< 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"
  }

  alias lf="y || ya pack -i"
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"
else
  echo_missing "yazi"
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
  echo_missing "exa | eza | lsd"
  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_missing "trash-cli"
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"
else
  echo_missing "bat"
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
else
  echo_missing "fastfetch"
fi

# INFO:
# ╭──────────────────╮
# │ containerization │
# ╰──────────────────╯
__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 dc="docker compose"
  alias dcs="docker compose ps -a --format 'table {{.Name}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'"
  alias dlog="docker compose logs"

  # 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

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

# INFO:
# ╭─────╮
# │ git │
# ╰─────╯
__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"

  # ╭──────────────────────────────────────╮
  # │ git add with commit like..           │
  # │ `git add "<file>" "<commitmessage>"` │
  # │ .. or like `git add "<file>"`        │
  # ╰──────────────────────────────────────╯
  ga() {
    if [ -n "$2" ]; then
      git diff ${1:-.}
      git add ${1:-.}
      git commit -m "$2"
    else
      git diff ${1:-.}
      git add ${1:-.}
    fi
  }

  # ──────────────────────────────────────< 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 '
        echo "${RED}Submodule: $name ${NC}"
        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_files=()
      local commit_message

      # case "$1" in
      # '.')
      #   commit_files=.
      #   commit_message="wip"
      #
      #   echo "${CYAN}No changes on the remote branch. Adding changes and pushing with ${RED}${BOLD}'$commit_message'${NC}${CYAN} commit.${NC}"
      #
      #   git add "$commit_files"
      #   git commit -m "$commit_message"
      #   git push
      #   ;;
      # *)
      if [[ -n "$1" ]]; then
        for f in "$@"; do
          if [ -f "./${f}" ] || [ -d "./${f}/" ]; then
            commit_files+=("./${f}")
          else
            commit_message+="${f}"
            break
          fi
        done
      else
        echo "${BOLD}${YELLOW}You have to provide the command like..:"
        echo "${GREEN}'gwip <list of files> <commit message>' or like 'gwip .'${NC}"

        return
      fi

      case $commit_files in
      './.') commit_message="wip" ;;
      *)
        local trimmed_files

        for f in "${commit_files[@]}"; do
          trimmed_files+=("${f#./}")
        done

        echo "${GREEN}Committed files/folders: ${BOLD}${trimmed_files[*]}${NC}"
        ;;
      esac

      if [ -n "$commit_files" ] || [ -n "$commit_message" ]; then
        [[ -z "$commit_files" ]] && commit_files=.
        [[ -z "$commit_message" ]] && commit_message=wip

        echo "${CYAN}No changes on the remote branch. Adding changes and pushing with ${RED}${BOLD}'$commit_message'${NC}${CYAN} commit.${NC}"

        if (("${#commit_files}" <= 1)); then
          git add $commit_files
        else
          for f in "${commit_files[@]}"; do
            git add $f
          done
        fi
        git commit -m "${commit_message:-wip}"
        git push
      else
        echo "${RED}${BOLD}There was something wrong with:${NC}"
        echo "${YELLOW}- commit-files '$commit_files'"
        echo "or.."
        echo "${YELLOW}- commit-message '$commit_message'${NC}"
      fi
    else
      echo "${RED}${BOLD}There are changes on the remote branch. Please pull the latest changes first.${NC}"
    fi
  }

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

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

# Tmux session manager
if command_exists tmux; then
  sleep 0.01
  if [ -z "$TMUX" ]; then
    sleep 0.01
    # Attach to existing session if any, otherwise create one named 'main'
    if tmux ls &>/dev/null; then
      sleep 0.01
      tmux attach-session
    else
      sleep 0.01
      tmux new-session
    fi
  fi

  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"
else
  echo_missing "tmux"
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
}

# ─< h stands for HUGO >──────────────────────────────────────────────────────────────────
if command_exists hugo; then
  alias h='hugo'
  alias hs='hugo server -D --noHTTPCache --disableFastRender' # --bind "$(get_ip)"'
fi

missing() {
  local e=(
    bash
    zsh
    fzf
    curl
    git
    docker
    nvim
  )

  for i in "$e{[@]}"; do
    if ! command_exists $i; then
      echo_missing "$i"
    fi
  done
}

# INFO:
# ╭─────────────────╮
# │ other functions │
# ╰─────────────────╯
source-script() {
  local url="$1"
  local import="$(mktemp)"

  # ─< if $1 is a local file, source this one instead >─────────────────────────────────────
  if [ -f "$url" ]; then
    source "$url"
    sleep 0.1
    return 0
  else
    echo_info "Sourcing external script:${NC} $url"
    # ─< if $1 is a url, grab it and source it, also deletes afterwards >─────────────────────
    if command_exists curl; then
      curl -fsSL $url -o $import
    elif command_exists wget; then
      wget -o $import $url
    else
      echo "curl/wget is required, but missing.."
      exit 69
    fi

    source "$import"
    sleep 0.1
    rm -f "$import"
  fi
}

resolve() {
  local quiet=false
  if [[ "$1" == "-q" ]]; then
    quiet=true
    shift
  fi

  local ip="$1"
  local server="$2"
  local dig_out
  dig_out=$(command dig +noall +answer -x "$ip" ${server:+@$server} 2>/dev/null)

  local line ptr hostname time
  line=$(grep 'PTR' <<<"$dig_out")
  ptr=$(awk '{print $4}' <<<"$line")
  time=$(awk '{print $2}' <<<"$dig_out")
  hostname=$(awk '{print $5}' <<<"$line" | sed 's/\.$//')

  if $quiet; then
    [[ -n "$hostname" ]] && echo "$hostname"
    return
  fi

  if [[ -n "$hostname" ]]; then
    # ✅ resolved
    printf "✅  ${BOLD}${GREEN}%s${NC}  \033[1;90m%s${NC}  \033[32m%s${NC}  \033[2m%s ms${NC}\n" \
      "$ptr" "$ip" "$hostname" "$time"
  else
    # ❌ not resolved
    printf "❌  \033[1;31m%s${NC}  \033[1;90m%s${NC}  \033[1;31mNOT FOUND${NC}  \033[2m%s ms\033[0m\n" \
      "PTR" "$ip" "${time:-0}"
  fi
}

main() {
  # ─< g stands for GIT >─────────────────────────────────────────────────────────────────────
  if command_exists git; then
    __git__
  else
    echo_missing "git"
  fi

  # ─< d stands for docker >──────────────────────────────────────────────────────────────────
  if command_exists docker; then
    __docker__
  elif command_exists podman; then
    __podman__
  else
    echo_missing "docker | podman"
  fi
}

main