dot_aliases

#################################################################################################################################################
#################################################################################################################################################
#####################################
#####################################          Bash Aliases.   Feike Li     2020.5.2 ver
#####################################          write some documentation formatting here:
#####################################
#####################################	         1.temp aliases
#####################################          2.system aliases
#####################################	         3.applications
#####################################
#####################################
#################################################################################################################################################
#################################################################################################################################################


#=======================================================================
#  TEMP & MISC LAUNCHERS
#=======================================================================
# Temporary aliases and launchers for specific applications.
alias t3='npm create t3-app@latest'
alias disableKeyboard='xinput disable 13 '
alias enableKeyboard='xinput enable 13'
alias enableTapOnClick='xinput set-prop "$(xinput list --name-only | grep -i Touchpad | head -1)" "libinput Tapping Enabled" 1'
alias disableTapOnClick='xinput set-prop "$(xinput list --name-only | grep -i Touchpad | head -1)" "libinput Tapping Enabled" 0'
alias job='uv run job-toolkit '
alias l="fc -s"

#=======================================================================
#  CORE SYSTEM & NAVIGATION
#=======================================================================
# Basic aliases for shell navigation, editing config files, and system commands.
alias v='nvim'
alias vv='nvim .'
alias cc='claude --chrome'
alias r='yazi'
alias e='aerc'
alias api='resterm'
alias database='gobang'
alias f='tmux a' 
alias c='clear'
alias h='cd $HOME && clear'
alias q='exit'
alias s='cdf'
alias ss='cdf && yazi'
alias clear='clear && tmux clear-history'
alias ls='ls -lAhvFis --color=always --group-directories-first --time-style="+%Y-%m-%d %H:%M"'
alias top='btop'
alias t='btop'
p() { if [ $# -eq 0 ]; then echo "usage: p <command>"; return 1; fi; unbuffer "$@" 2>&1 | less -RiFS --use-color --color=Sky; }
alias tree='tree -a'
alias process='ps -ef | grep'
alias biggestFile='find . -type f -exec du -h {} + | sort -hr | head -20'
alias du='du -h '
cal() {
    local CYAN='\033[1;36m'
    local GREEN='\033[1;32m'
    local YELLOW='\033[1;33m'
    local BOLD='\033[1m'
    local DIM='\033[2m'
    local NC='\033[0m'

    local W=76                     # inner width; total box = W+2 chars
    local CW=$(( (W - 13) / 7 ))  # weather column width = 9

    local HBAR; HBAR=$(printf '═%.0s' $(seq 1 "$W"))

    # $1=plain text (for width measurement), $2=colored display text
    _cal_row() {
        local plain="$1" display="$2"
        local pad=$(( W - ${#plain} - 2 ))
        [[ $pad -lt 0 ]] && pad=0
        # ${NC} after display resets any ANSI left open by ncal's today-highlight
        echo -e "${DIM}║${NC} ${display}${NC}$(printf '%*s' "$pad" "") ${DIM}║${NC}"
    }

    echo -e "${DIM}╔${HBAR}╗${NC}"

    # ── Date ──────────────────────────────────────────────────────────────
    local today; today=$(date "+%A, %B %d %Y  •  %H:%M")
    _cal_row "$today" "${BOLD}${CYAN}${today}${NC}"
    echo -e "${DIM}╠${HBAR}╣${NC}"

    # ── 3-month calendar ──────────────────────────────────────────────────
    # unbuffer makes ncal think it's writing to a tty, preserving today's highlight
    while IFS= read -r line; do
        local plain; plain=$(printf '%s' "$line" | sed 's/\x1b\[[0-9;]*[mK]//g')
        if [[ "$plain" =~ (January|February|March|April|May|June|July|August|September|October|November|December) ]]; then
            _cal_row "$plain" "${BOLD}${YELLOW}${plain}${NC}"
        else
            _cal_row "$plain" "$line"
        fi
    done < <(unbuffer ncal -b -3 2>/dev/null || ncal -b -3)
    echo -e "${DIM}╠${HBAR}╣${NC}"

    # ── Weather ───────────────────────────────────────────────────────────
    local raw; raw=$(ansiweather -l Calgary,CA -u metric -f 7 2>/dev/null \
        | perl -pe 's/\x1b\[[0-9;]*[mGKH]//g' \
        | tr -d '\n' | sed 's/  */ /g; s/^ //; s/ $//')

    local -a NAMES=() DATES=() TEMPS=()
    local hdr=""

    if echo "$raw" | grep -qi 'forecast:'; then
        # Extract city/header (everything before "forecast:")
        hdr=$(echo "$raw" | sed -E 's/ *[Ff]orecast:.*//' | sed 's/[[:space:]]*$//')
        [[ -n "$hdr" ]] && hdr="${hdr}  (°C)"
        [[ ${#hdr} -gt $((W - 2)) ]] && hdr="${hdr:0:$((W - 5))}..."

        local fcast; fcast=$(echo "$raw" | sed -E 's/.*[Ff]orecast: //')

        while IFS= read -r entry; do
            entry="${entry# }"; entry="${entry% }"
            [[ -z "$entry" ]] && continue
            # New format:  "Tue Mar 03: 13/-5 °C"
            if [[ "$entry" =~ ^[A-Z][a-z]{2}[[:space:]][A-Z][a-z]{2}[[:space:]][0-9] ]]; then
                NAMES+=("$(awk '{print $1}' <<< "$entry")")
                DATES+=("$(awk '{print $2, $3}' <<< "$entry" | tr -d ':')")
                TEMPS+=("$(awk '{print $4}' <<< "$entry")")  # Hi/Lo only, strip °C (° is 2-cell wide)
            # Old format: "Mon - Clear - 5/15 °C"
            else
                NAMES+=("$(awk -F' - ' '{print $1}' <<< "$entry")")
                DATES+=("$(awk -F' - ' '{print $2}' <<< "$entry")")
                TEMPS+=("$(awk -F' - ' '{print $3}' <<< "$entry" | sed 's/ °C$//')")
            fi
        done < <(echo "$fcast" | sed -E 's/ - (Mon|Tue|Wed|Thu|Fri|Sat|Sun)/\n\1/g' | grep .)
    else
        hdr="$raw"
        [[ ${#hdr} -gt $((W - 2)) ]] && hdr="${hdr:0:$((W - 5))}..."
    fi

    if [[ -n "$hdr" ]]; then
        _cal_row "$hdr" "${GREEN}${hdr}${NC}"
        echo -e "${DIM}╠${HBAR}╣${NC}"
    fi

    # ── 7-column forecast table ───────────────────────────────────────────
    local n=${#NAMES[@]}
    if [[ $n -gt 0 ]]; then
        local r1="${DIM}║${NC}" r2="${DIM}║${NC}" r3="${DIM}║${NC}"
        local sep
        for (( i=0; i<n; i++ )); do
            [[ $i -lt $((n-1)) ]] && sep="${DIM}│${NC}" || sep="${DIM}║${NC}"
            r1+=" ${BOLD}${CYAN}$(printf "%-${CW}.${CW}s" "${NAMES[$i]:-}")${NC}${sep}"
            r2+=" ${YELLOW}$(printf "%-${CW}.${CW}s" "${DATES[$i]:-}")${NC}${sep}"
            r3+=" ${GREEN}$(printf "%-${CW}.${CW}s" "${TEMPS[$i]:-}")${NC}${sep}"
        done
        echo -e "$r1"
        echo -e "$r2"
        echo -e "$r3"
    fi

    echo -e "${DIM}╚${HBAR}╝${NC}"
    printf "\n"
}
alias neofetch='fastfetch'


#=======================================================================
#  CONFIGURATION & EDITING SHORTCUTS
#=======================================================================
# Quick access to edit configuration files and other specific text files.
alias password='nvim ~/Documents/feeco/1.lifeike/password.txt'
alias config='cd ~/.config && yazi'
alias vali='nvim ~/.aliases'
alias vbash='nvim ~/.bashrc'
alias vhistory='nvim ~/.bash_history'


#=======================================================================
#  DIRECTORY SHORTCUTS
#=======================================================================
# Quick navigation to frequently used directories.
alias d='cd /home/feeco/Downloads && yazi'
repos() {
    local dir
    dir=$(find ~/Documents -maxdepth 3 -name .git -type d 2>/dev/null | sed 's|/.git$||' | fzf --height=40% --reverse --prompt='Repo> ')
    if [[ -n "$dir" ]]; then
        cd "$dir"
    else
        cd ~/Documents && yazi
    fi
}
alias desktop='cd /home/feeco/Desktop && yazi'
alias video='cd /home/feeco/Videos && yazi'
alias picture='cd /home/feeco/Pictures && yazi'
alias music='cd /home/feeco/Music && yazi'



#=======================================================================
#  SEARCH, HISTORY & BOOKMARKS
#=======================================================================
# Fuzzy search for files, history, and marked directories.
cdf() {
   cd ~
   local file
   local dir
   file=$(fzf +m -q "$1") && dir=$(dirname "$file") 
   cd "$dir"
   pwd
}

# find available commands from .bashrc .alias and command history
alias lc='eval $(fh)'
fh() {
  set -o history
  HISTFILE=~/.bash_history
  local cmd

  # STAGE 1: Search Aliases and Functions
  cmd=$( (alias; declare -F | cut -d' ' -f3) | 
         fzf --height=40% --border --prompt='Alias/Func> ' \
             --header='Searching Aliases & Functions (ESC to search History)' \
             --bind='tab:down,shift-tab:up' --select-1 --exit-0)

  # STAGE 2: If nothing found in Stage 1, search History
  if [[ -z "$cmd" ]]; then
    cmd=$(history | tac | sed 's/^[[:space:]]*[0-9]\+[[:space:]]*//' | awk '!seen[$0]++' | 
          fzf --height=80% --border --prompt='History> ' \
              --bind='tab:down,shift-tab:up')
  fi

  # Execution logic
  if [[ -n "$cmd" ]]; then
    # If it was an alias, clean the 'alias ' prefix and '=...' suffix to get the name
    if [[ "$cmd" == alias* ]]; then
      cmd=$(echo "$cmd" | sed "s/^alias //; s/='.*$//")
    fi
    echo "$cmd"
  fi
}

# mark current directory as marked list
mm() {
    echo "$PWD" >> "$HOME/.marked_directories"
    echo "Marked: $PWD"
}

# search marked list with fzf
lm() {
    if [[ ! -f "$HOME/.marked_directories" ]]; then
        echo "No directories marked yet."
        return 1
    fi
    local dir
    dir=$(cat "$HOME/.marked_directories" | fzf)
    [[ -n "$dir" ]] && cd "$dir" && echo "Changed directory to: $dir"
}


#=======================================================================
#  NETWORKING
#=======================================================================
# Functions and aliases for managing Wi-Fi and inspecting network ports.
alias wifilist='nmcli device wifi list'
show_connected_wifi(){
    nmcli connection show
}

delete_connected_wifi(){
    read -r -p "Enter SSID: " ssid
    nmcli connection delete "$ssid"
}

connect_wifi() {
    read -r -p "Enter SSID: " ssid
    read -r -s -p "Enter Password: " password
    echo 
    sudo nmcli device wifi connect "$ssid" password "$password"
}

port() {
    local search_term="${1:-}"
    local GREEN='\033[0;32m'
    local BLUE='\033[0;34m'
    local YELLOW='\033[1;33m'
    local CYAN='\033[1;36m'
    local NC='\033[0m'
    
    echo -e "\n╔════════════════════════════════════════════════════════════════════════════╗"
    echo -e "║                        NETWORK PORTS & CONNECTIONS                         ║"
    echo -e "╚════════════════════════════════════════════════════════════════════════════╝\n"
    printf "%-10s %-25s %-10s %-15s %-12s %s\n" "PROTO" "LOCAL ADDRESS" "PORT" "STATE" "PID" "PROGRAM"
    echo "────────────────────────────────────────────────────────────────────────────────────────"
    
    sudo netstat -tulpn 2>/dev/null | grep -v "^Active\|^Proto" | while read -r line; do
        [ -z "$line" ] && continue
        proto=$(echo "$line" | awk '{print $1}')
        local_addr=$(echo "$line" | awk '{print $4}')
        
        if [[ $proto == udp* ]]; then
            state="-"
            pid_program=$(echo "$line" | awk '{print $6}')
        else
            state=$(echo "$line" | awk '{print $6}')
            pid_program=$(echo "$line" | awk '{print $7}')
        fi
        
        if [[ $local_addr == *":"* ]]; then
            ip=$(echo "$local_addr" | rev | cut -d: -f2- | rev)
            port=$(echo "$local_addr" | rev | cut -d: -f1 | rev)
        else
            ip="N/A"
            port="N/A"
        fi
        
        if [[ $pid_program == *"/"* ]]; then
            pid=$(echo "$pid_program" | cut -d/ -f1)
            program=$(echo "$pid_program" | cut -d/ -f2-)
        elif [[ $pid_program == "-" ]]; then
            pid="-"
            program="-"
        else
            pid="${pid_program:-N/A}"
            program="N/A"
        fi
        
        [ -n "$search_term" ] && ! echo "$line $program $port" | grep -qi "$search_term" && continue
        
        case $proto in
            tcp*) proto_colored="${GREEN}${proto}${NC}" ;;
            udp*) proto_colored="${BLUE}${proto}${NC}" ;;
            *) proto_colored="$proto" ;;
        esac
        
        case $state in
            LISTEN) state_colored="${YELLOW}${state}${NC}" ;;
            ESTABLISHED) state_colored="${GREEN}${state}${NC}" ;;
            *) state_colored="$state" ;;
        esac
        
        port_colored="${CYAN}${port}${NC}"
        
        printf "%-10s %-25s %-10s %-15s %-12s %s\n" "$proto" "$ip" "$port" "$state" "$pid" "$program" | \
        sed -E "s/^(tcp[^ ]*)/$(echo -e ${GREEN})\1$(echo -e ${NC})/" | \
        sed -E "s/^(udp[^ ]*)/$(echo -e ${BLUE})\1$(echo -e ${NC})/" | \
        sed -E "s/([0-9]+)( +LISTEN)/$(echo -e ${CYAN})\1$(echo -e ${NC})\2/" | \
        sed -E "s/([0-9]+)( +-)/$(echo -e ${CYAN})\1$(echo -e ${NC})\2/" | \
        sed -E "s/LISTEN/$(echo -e ${YELLOW})LISTEN$(echo -e ${NC})/" | \
        sed -E "s/ESTABLISHED/$(echo -e ${GREEN})ESTABLISHED$(echo -e ${NC})/"
    done
    
    echo "────────────────────────────────────────────────────────────────────────────────────────"
    echo -e "\n💡 Usage: port [search_term] | Examples: port nginx | ports 80\n"
}

portlistening() {
    local CYAN='\033[1;36m'
    local GREEN='\033[0;32m'
    local NC='\033[0m'
    
    echo -e "\n🔊 LISTENING PORTS\n"
    printf "%-10s %-12s %-25s\n" "PROTO" "PORT" "PROGRAM"
    echo "───────────────────────────────────────────────────────"
    sudo netstat -tulpn 2>/dev/null | grep LISTEN | awk '{print $1, $4, $7}' | \
    while read proto addr pidprog; do
        port=$(echo "$addr" | rev | cut -d: -f1 | rev)
        prog=$(echo "$pidprog" | cut -d/ -f2-)
        printf "%-10s %-12s %-25s\n" "$proto" "$port" "$prog"
    done | sort -k2 -n | while IFS= read -r line; do
        echo "$line" | sed -E "s/^(tcp[^ ]*)/\\$(echo -e '\033[0;32m')\1\\$(echo -e '\033[0m')/" | \
        sed -E "s/([0-9]+)/\\$(echo -e '\033[1;36m')\1\\$(echo -e '\033[0m')/"
    done
    echo ""
}

look() {
    if [ $# -eq 0 ]; then
        echo "Please provide a domain name."
        return 1
    fi
    local domain="$1"
    whois "$domain" | \
    awk '/Creation Date/ {print "\033[31m" $0 "\033[0m"} {print}' | \
    less -R
}


#=======================================================================
#  HARDWARE & DISPLAY
#=======================================================================
# Control screen brightness, rotation, and audio volume.
alias d1='xrandr --output DP-2 --brightness 0.5'
alias d2='xrandr --output DP-2 --brightness 0.7'
alias d3='xrandr --output DP-2 --brightness 0.9'
alias d4='xrandr --output DP-2 --brightness 1.1'

alias l1='xrandr --output eDP --brightness 0.6'
alias l2='xrandr --output eDP --brightness 0.8'
alias l3='xrandr --output eDP --brightness 1'
alias l4='xrandr --output eDP --brightness 1.2'

alias secondMonitorRotation='xrandr --output DP-1 --rotate left'
alias volume='alsamixer'


#=======================================================================
#  FILE & TEXT MANIPULATION
#=======================================================================
# Aliases and functions for file conversion, extraction, and formatting.
alias unrarall='for file in *.rar; do unrar e -p "$file"; done'
alias unzipgarbled='unzip -O cp936 '
alias convertallpdf='ls *.pdf | xargs -n1 pdftotext'
alias convertallpdftopng=allpdftopng
function allpdftopng(){
	for file in *.pdf;
		do pdftoppm "$file" "$file";
	done
}
alias convertpptxtopdf='libreoffice --headless --invisible --convert-to pdf *.pptx'
alias convertdocxtotxt='libreoffice --headless --convert-to txt'
alias convertjpgtopdf='convert *.jpg output.pdf'
md2pdf_batch() {
    local tmp_css="__temp_style.css"
    cat > "$tmp_css" <<'EOF'
body { margin: 5mm; font-family: sans-serif; }
pre { background-color: #eaeaea; color: #000000; padding: 10px; border-radius: 4px; overflow-x: auto; border: 1px solid #cccccc; }
code { font-family: monospace; }
code span.kw { font-weight: bold; }
code span.st { font-style: italic; }
code span.co { color: #555555; }
code span.fu { text-decoration: underline; }
h1, h2, h3, h4, h5, h6 { page-break-after: avoid; }
table { border-collapse: collapse; }
table, th, td { border: 1px solid #ccc; padding: 4px; }
EOF

    for f in *.md; do
        [[ -f "$f" ]] || continue
        echo "Converting $f → ${f%.md}.pdf"
        pandoc "$f" -o "${f%.md}.pdf" \
            --pdf-engine=wkhtmltopdf \
            -V margin-top=5mm \
            -V margin-bottom=5mm \
            -V margin-left=5mm \
            -V margin-right=5mm \
            --css="$tmp_css" \
            --pdf-engine-opt=--enable-local-file-access
    done
    rm -f "$tmp_css"
    echo "✅ All Markdown files converted."
}


#=======================================================================
#  PACKAGE MANAGEMENT & SYSTEM UPDATES
#=======================================================================
# Aliases for installing, removing, and updating system packages.
alias install='sudo apt install -y'
alias remove='sudo apt purge -y'
alias installed=manually_installed
function manually_installed(){
	comm -23 <(apt-mark showmanual | sort -u) <(gzip -dc /var/log/installer/initial-status.gz | sed -n 's/^Package: //p' | sort -u)
}

alias update=updateall
function updateall(){
	sudo apt upgrade;
	sudo apt-get upgrade;
	sudo apt update;
	sudo apt-get update;
    updateChrome;
    sudo snap refresh;
	sudo apt-get clean;
	sudo apt clean;
	sudo apt autoremove;
	sudo apt-get autoremove;
	sudo apt-get autoclean;
	sudo apt autoclean;
}

function clean(){
	sudo apt-get clean;
	sudo apt clean;
	sudo apt autoremove;
	sudo apt-get autoremove;
	sudo apt-get autoclean;
	sudo apt autoclean;
}

updateChrome(){
   cd $HOME
   wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
   sudo dpkg -i google-chrome-stable_current_amd64.deb
   rm google-chrome-stable_current_amd64.deb
}


#=======================================================================
#  GIT & GITHUB WORKFLOW
#=======================================================================
# A comprehensive set of aliases and functions to streamline Git and GitHub usage.

# ── Project shortcut ──────────────────────────────────────────────────
alias lifeike='cd /home/feeco/Documents/feeco && gb && gs && yazi'

# ── Status & inspection ───────────────────────────────────────────────
# gs: pretty working-tree status with staged/modified/untracked breakdown
gs() {
  local CYAN='\033[1;36m'
  local GREEN='\033[1;32m'
  local RED='\033[1;31m'
  local YELLOW='\033[1;33m'
  local MAGENTA='\033[1;35m'
  local BLUE='\033[1;34m'
  local DIM='\033[2m'
  local NC='\033[0m'

  local branch=$(git branch --show-current 2>/dev/null)
  local repo=$(basename "$(git rev-parse --show-toplevel 2>/dev/null)")
  local ahead_behind=$(git rev-list --left-right --count HEAD...@{upstream} 2>/dev/null)
  local ahead=$(echo "$ahead_behind" | cut -f1)
  local behind=$(echo "$ahead_behind" | cut -f2)

  echo -e "\n${DIM}╔════════════════════════════════════════════════════════════════════════════╗${NC}"
  echo -e "${DIM}║${NC}  ${MAGENTA}${repo}${NC} ${DIM}│${NC} ${CYAN}${branch}${NC} ${ahead:+${GREEN}↑$ahead${NC}} ${behind:+${RED}↓$behind${NC}}"
  echo -e "${DIM}╠════════════════════════════════════════════════════════════════════════════╣${NC}"

  local has_changes=false
  while IFS= read -r line; do
    [[ -z "$line" ]] && continue
    has_changes=true
    local status="${line:0:2}"
    local file="${line:3}"
    case "$status" in
      "M ") echo -e "${DIM}║${NC}  ${GREEN}  staged${NC}     $file" ;;
      " M") echo -e "${DIM}║${NC}  ${CYAN}  modified${NC}  $file" ;;
      "MM") echo -e "${DIM}║${NC}  ${YELLOW}  partial${NC}   $file" ;;
      "A ") echo -e "${DIM}║${NC}  ${GREEN}  added${NC}     $file" ;;
      "AM") echo -e "${DIM}║${NC}  ${YELLOW}  added+mod${NC} $file" ;;
      " D") echo -e "${DIM}║${NC}  ${RED}  deleted${NC}   $file" ;;
      "D ") echo -e "${DIM}║${NC}  ${RED}  staged-del${NC}$file" ;;
      "R ") echo -e "${DIM}║${NC}  ${BLUE}  renamed${NC}   $file" ;;
      "??") echo -e "${DIM}║${NC}  ${YELLOW}  untracked${NC} $file" ;;
      "UU") echo -e "${DIM}║${NC}  ${RED}  conflict${NC}  $file" ;;
      *) echo -e "${DIM}║${NC}  ${DIM}$status${NC}        $file" ;;
    esac
  done < <(git status --short 2>/dev/null)

  if [[ "$has_changes" == false ]]; then
    echo -e "${DIM}║${NC}  ${GREEN}  clean${NC}     working tree is clean"
  fi

  echo -e "${DIM}╚════════════════════════════════════════════════════════════════════════════╝${NC}\n"
}

# gb: list local and remote branches with hash, date, and subject
gb() {
  local CYAN='\033[1;36m'
  local GREEN='\033[1;32m'
  local RED='\033[1;31m'
  local YELLOW='\033[1;33m'
  local MAGENTA='\033[1;35m'
  local BLUE='\033[1;34m'
  local DIM='\033[2m'
  local NC='\033[0m'

  local current
  current=$(git branch --show-current 2>/dev/null)

  echo -e "\n${DIM}╔════════════════════════════════════════════════════════════════════════════╗${NC}"
  echo -e "${DIM}║${NC}  ${MAGENTA}branches${NC}  ${DIM}on${NC} ${CYAN}${current}${NC}"
  echo -e "${DIM}╠════════════════════════════════════════════════════════════════════════════╣${NC}"
  echo -e "${DIM}║${NC}  ${YELLOW}local${NC}"

  git branch --format='%(refname:short)|%(objectname:short)|%(committerdate:relative)|%(subject)' | \
  while IFS='|' read -r branch hash date msg; do
    if [[ "$branch" == "$current" ]]; then
      echo -e "${DIM}║${NC}  ${GREEN}★${NC} ${CYAN}${branch}${NC}  ${DIM}${hash}${NC}  ${BLUE}${date}${NC}  ${msg}"
    else
      echo -e "${DIM}║${NC}    ${branch}  ${DIM}${hash}  ${date}  ${msg}${NC}"
    fi
  done

  if git branch -r 2>/dev/null | grep -q .; then
    echo -e "${DIM}║${NC}"
    echo -e "${DIM}║${NC}  ${RED}remote${NC}"
    git branch -r --format='%(refname:short)|%(objectname:short)|%(committerdate:relative)|%(subject)' | \
    while IFS='|' read -r branch hash date msg; do
      echo -e "${DIM}║${NC}    ${RED}${branch}${NC}  ${DIM}${hash}  ${date}  ${msg}${NC}"
    done
  fi

  echo -e "${DIM}╚════════════════════════════════════════════════════════════════════════════╝${NC}\n"
}

# gl: pretty graph log (default: last 40 commits across all branches)
gl() {
  local fmt="%C(bold yellow)%<(9,trunc)%h%C(reset)  %C(bold blue)%<(14,trunc)%ar%C(reset)  %C(green)%<(17,trunc)%an%C(reset)  %C(white)%s%C(reset)%C(bold magenta)%d%C(reset)"
  git log \
    --graph \
    --abbrev-commit \
    --all \
    --topo-order \
    --format=format:"$fmt" \
    "${@:--40}"
}

# gitlastcommit: fzf-browse files changed in the last commit with diff preview
alias gitlastcommit='git diff --name-only HEAD^ | fzf --ansi \
  --preview "git diff --color=always HEAD^ -- {}" \
  --preview-window "right:70%" \
  --bind "tab:down,shift-tab:up,ctrl-k:preview-up,ctrl-j:preview-down"'

alias gitcommitscount='git shortlog -sn --all'          # commit count per author
alias gitbigfile='git rev-list --all | xargs -rL1 git ls-tree -r --long | sort -uk3 | sort -rnk4 | head -10'  # top 10 largest tracked files

# ── Conflicts & checks ────────────────────────────────────────────────
alias gitlistconflicts='git diff --check'                # show whitespace/conflict markers
alias gitconflict='git diff --name-only --diff-filter=U' # list files with merge conflicts

# ── Tags ──────────────────────────────────────────────────────────────
alias gt='echo "local tags: " && git tag -n && echo "" && echo "" && echo "remote tags: " && git ls-remote --tags'
alias gnewtag='git tag -a'

# ── Commit & push ─────────────────────────────────────────────────────
alias gr='git reset --hard && git clean -fd'  # hard reset + clean untracked files
alias gp='pushall'

# pushall: prompt for commit message, stage all, commit, and push current branch
function pushall(){
    IFS= read -r -p "commit message: " commitMessage
    git add -A;
    git commit --allow-empty -am "$commitMessage";
    branch=$(git branch | sed -n -e 's/^\* \(.*\)/\1/p')
    git push -u origin $branch
    clear
}

# ── Pull & sync ───────────────────────────────────────────────────────
# pull: fetch all remotes and pull/track every remote branch
pull() {
    local CYAN='\033[1;36m'
    local GREEN='\033[1;32m'
    local RED='\033[1;31m'
    local YELLOW='\033[1;33m'
    local MAGENTA='\033[1;35m'
    local BLUE='\033[1;34m'
    local DIM='\033[2m'
    local NC='\033[0m'

    local current
    current=$(git branch --show-current 2>/dev/null)
    if [[ -z "$current" ]]; then
        echo -e "${RED}✗ Not in a git repository.${NC}"
        return 1
    fi

    local repo
    repo=$(basename "$(git rev-parse --show-toplevel 2>/dev/null)")

    echo -e "\n${DIM}╔════════════════════════════════════════════════════════════════════════════╗${NC}"
    echo -e "${DIM}║${NC}  ${MAGENTA}pull${NC}  ${DIM}│${NC}  ${CYAN}${repo}${NC}  ${DIM}on${NC}  ${GREEN}${current}${NC}"
    echo -e "${DIM}╠════════════════════════════════════════════════════════════════════════════╣${NC}"

    { git fetch --all; } 2>&1 | while IFS= read -r line; do
        echo -e "${DIM}║${NC}  ${DIM}${line}${NC}"
    done

    git branch -r | grep -v '\->' | sed 's|origin/||' | while read -r branch; do
        echo -e "${DIM}║${NC}"
        if git show-ref --verify --quiet "refs/heads/$branch"; then
            echo -e "${DIM}║${NC}  ${CYAN}↓  pulling   ${NC}${branch}"
            { git checkout "$branch" && git pull origin "$branch"; } 2>&1 | while IFS= read -r line; do
                echo -e "${DIM}║${NC}  ${line}"
            done
        else
            echo -e "${DIM}║${NC}  ${YELLOW}⊕  tracking  ${NC}${branch}"
            { git checkout --track "origin/$branch"; } 2>&1 | while IFS= read -r line; do
                echo -e "${DIM}║${NC}  ${line}"
            done
        fi
        echo -e "${DIM}║${NC}"
    done

    git checkout "$current"
    echo -e "${DIM}╚════════════════════════════════════════════════════════════════════════════╝${NC}\n"
}

# ── Deploy ────────────────────────────────────────────────────────────
# gitdeploy: merge current branch into main, push, then return to original branch
function gitdeploy(){
   local current
   current=$(git branch --show-current)
   git checkout main
   git merge "$current"
   git push origin main
   git checkout "$current"
}

# ── Pull requests & issues ────────────────────────────────────────────
# pr: commit, push current branch, and open a PR with auto-filled title/body
pr() {
    local branch
    branch=$(git branch --show-current)
    git add -A
    git commit
    git push -u origin "$branch"
    gh pr create --fill
}

alias gittodolist='gh issue list'   # list open issues
alias gittodo='gh issue create'     # create a new issue

# ── GitHub auth & account switching ──────────────────────────────────
alias githublogin='gh auth login'
alias githubbrowser='gh browse'

declare -A GH_ALIAS_MAP=(
    [hankAndfeeco]=hankAndfeeco
    [lifeike]=lifeike
)

# github: switch gh account and list all repos + org repos for that user
github() {
    local user
    user=$(gh auth status 2>&1 | grep -oP 'account \K\S+' | fzf --height=40% --reverse --prompt='GitHub User> ')
    if [[ -n "$user" ]]; then
        gh auth switch --user "$user"
        echo "=== $user ==="
        gh repo list "$user" --limit 100
        local orgs
        orgs=$(gh api user/orgs --jq '.[].login' 2>/dev/null)
        for org in $orgs; do
            echo ""
            echo "=== $org ==="
            gh repo list "$org" --limit 100
        done
    fi
}

# ── Clone & fork & Create ──────────────────────────────────────────────────────
alias githubrepos='ghclone'
alias githuborganizationrepos='ghcloneorg'
alias githubcreaterepo='gh repo create'
alias githubdeleterepo='gh repo delete'

# ghclone: fzf-pick from all personal, collaborator, and org repos then clone
ghclone() {
  local repo
  repo=$(
    {
      gh repo list \
        --limit 100 \
        --json nameWithOwner,description \
        --jq '.[] | "\(.nameWithOwner)\t\(.description // "")"'

      gh api "user/repos?affiliation=collaborator&per_page=100" \
        --paginate \
        --jq '.[] | "\(.full_name)\t\(.description // "")"' 2>/dev/null

      gh api user/orgs --jq '.[].login' 2>/dev/null | while read -r org; do
        gh repo list "$org" \
          --limit 100 \
          --json nameWithOwner,description \
          --jq '.[] | "\(.nameWithOwner)\t\(.description // "")"' 2>/dev/null
      done
    } | sort -u |
    fzf \
      --height=80% \
      --layout=reverse \
      --prompt="Clone repo > " \
      --delimiter=$'\t' \
      --with-nth=1,2 \
      --bind='tab:down,shift-tab:up,ctrl-j:down,ctrl-k:up' \
      --preview 'echo {2}' \
      --preview-window=down:3:wrap |
    cut -f1
  )
  [[ -n "$repo" ]] && gh repo clone "$repo"
}

# ghcloneorg: fzf-pick an org then a repo within it, then clone
ghcloneorg() {
    local org
    org=$(gh api user/orgs --jq '.[].login' 2>/dev/null | fzf --height=40% --reverse --prompt='Organization> ')
    [[ -z "$org" ]] && return
    local repo
    repo=$(
        gh repo list "$org" \
            --limit 100 \
            --json nameWithOwner,description \
            --jq '.[] | "\(.nameWithOwner)\t\(.description // "")"' |
        fzf \
            --height=80% \
            --layout=reverse \
            --prompt="$org repo > " \
            --delimiter=$'\t' \
            --with-nth=1,2 \
            --bind='tab:down,shift-tab:up,ctrl-j:down,ctrl-k:up' \
            --preview 'echo {2}' \
            --preview-window=down:3:wrap |
        cut -f1
    )
    [[ -n "$repo" ]] && gh repo clone "$repo"
}

# gc: clone a repo, track all remote branches, then open in nvim
gc() {
    local repo_dir
    repo_dir=$(basename "${1%/}" .git)
    gh repo clone "$1" || return
    cd "$repo_dir" || return
    for branch in $(git branch -r | grep -v '\->'); do
        git branch --track "${branch#origin/}" "$branch" 2>/dev/null
    done
    git fetch --all
    nvim .
}

# gf: fork a repo, clone it, track all remote branches, then open in nvim
gf() {
    local repo_dir
    repo_dir=$(basename "${1%/}" .git)
    gh repo fork "$1" --clone || return
    cd "$repo_dir" || return
    for branch in $(git branch -r | grep -v '\->'); do
        git branch --track "${branch#origin/}" "$branch" 2>/dev/null
    done
    git fetch --all
    nvim .
}

# githubsearch: interactive GitHub repo search with rich metadata preview and optional clone
githubsearch() {
    local CYAN='\033[1;36m'
    local GREEN='\033[1;32m'
    local RED='\033[1;31m'
    local YELLOW='\033[1;33m'
    local MAGENTA='\033[1;35m'
    local BLUE='\033[1;34m'
    local DIM='\033[2m'
    local NC='\033[0m'
    local BOLD='\033[1m'

    local query="$*"
    if [[ -z "$query" ]]; then
        IFS= read -r -p "Search GitHub repos: " query
        [[ -z "$query" ]] && return
    fi

    echo -e "\n${DIM}Searching GitHub for: ${NC}${CYAN}${query}${NC}\n"

    local selected
    selected=$(
        gh search repos "$query" \
            --limit 50 \
            --json fullName,description,stargazersCount,language,forksCount \
            --jq '.[] | "\(.fullName)\t⭐\(.stargazersCount)  🍴\(.forksCount)  [\(.language // "?")]\t\(.description // "")"' |
        fzf \
            --height=80% \
            --layout=reverse \
            --prompt="GitHub Search> " \
            --delimiter=$'\t' \
            --with-nth=1,2,3 \
            --bind='tab:down,shift-tab:up,ctrl-j:down,ctrl-k:up' \
            --preview='gh repo view {1} 2>/dev/null' \
            --preview-window=right:55%:wrap \
            --header="Results for: $query" |
        cut -f1
    )
    [[ -z "$selected" ]] && return

    echo -e "\n${DIM}Fetching repo data...${NC}"

    local meta commits issues prs contributors
    meta=$(gh api "repos/$selected" 2>/dev/null)
    commits=$(gh api "repos/$selected/commits?per_page=10" 2>/dev/null)
    issues=$(gh api "repos/$selected/issues?state=open&per_page=10" 2>/dev/null)
    prs=$(gh api "repos/$selected/pulls?state=open&per_page=10" 2>/dev/null)
    contributors=$(gh api "repos/$selected/contributors?per_page=10" 2>/dev/null)

    local W=76
    local HBAR; HBAR=$(printf '═%.0s' $(seq 1 $W))

    _ghs_row() { echo -e "${DIM}║${NC} $1"; }

    echo -e "${DIM}╔${HBAR}╗${NC}"

    # Header: repo name + stats
    local stars forks lang license desc homepage topics created updated open_issues owner_type
    stars=$(echo "$meta"       | jq -r '.stargazers_count // 0')
    forks=$(echo "$meta"       | jq -r '.forks_count // 0')
    lang=$(echo "$meta"        | jq -r '.language // "unknown"')
    license=$(echo "$meta"     | jq -r '.license.spdx_id // "no license"')
    desc=$(echo "$meta"        | jq -r '.description // ""')
    homepage=$(echo "$meta"    | jq -r '.homepage // ""')
    topics=$(echo "$meta"      | jq -r '.topics | join(", ")' 2>/dev/null)
    created=$(echo "$meta"     | jq -r '.created_at[:10]')
    updated=$(echo "$meta"     | jq -r '.updated_at[:10]')
    open_issues=$(echo "$meta" | jq -r '.open_issues_count // 0')
    owner_type=$(echo "$meta"  | jq -r '.owner.type // ""')

    _ghs_row " ${BOLD}${MAGENTA}${selected}${NC}  ${YELLOW}⭐ $stars${NC}  ${BLUE}🍴 $forks${NC}  ${GREEN}$lang${NC}  ${DIM}$license${NC}"
    [[ -n "$desc" ]]     && _ghs_row " ${desc}"
    [[ -n "$homepage" ]] && _ghs_row " ${DIM}🌐 $homepage${NC}"
    [[ -n "$topics" ]]   && _ghs_row " ${DIM}tags:${NC} $topics"
    _ghs_row " ${DIM}owner: $owner_type  •  created: $created  •  updated: $updated  •  open issues: $open_issues${NC}"
    echo -e "${DIM}╠${HBAR}╣${NC}"

    # Last 10 commits
    _ghs_row " ${BOLD}${CYAN}Last 10 Commits${NC}"
    echo "$commits" | jq -r '.[] | "\(.commit.committer.date[:10])  \(.commit.author.name)  \(.commit.message | split("\n")[0])"' 2>/dev/null | \
    while IFS= read -r line; do
        local date author msg
        date=$(echo "$line" | awk '{print $1}')
        author=$(echo "$line" | awk '{print $2}')
        msg=$(echo "$line" | cut -d' ' -f3-)
        _ghs_row " ${BLUE}$date${NC}  ${GREEN}$author${NC}  ${msg}"
    done
    echo -e "${DIM}╠${HBAR}╣${NC}"

    # Last 10 open issues
    _ghs_row " ${BOLD}${YELLOW}Last 10 Open Issues${NC}"
    echo "$issues" | jq -r '.[] | select(.pull_request == null) | "#\(.number)  \(.user.login)  \(.title)"' 2>/dev/null | head -10 | \
    while IFS= read -r line; do
        _ghs_row " ${YELLOW}$(echo "$line" | awk '{print $1}')${NC}  ${DIM}$(echo "$line" | awk '{print $2}')${NC}  $(echo "$line" | cut -d' ' -f3-)"
    done
    echo -e "${DIM}╠${HBAR}╣${NC}"

    # Last 10 open PRs
    _ghs_row " ${BOLD}${CYAN}Last 10 Open Pull Requests${NC}"
    echo "$prs" | jq -r '.[] | "#\(.number)  \(.user.login)  \(.title)"' 2>/dev/null | head -10 | \
    while IFS= read -r line; do
        _ghs_row " ${CYAN}$(echo "$line" | awk '{print $1}')${NC}  ${DIM}$(echo "$line" | awk '{print $2}')${NC}  $(echo "$line" | cut -d' ' -f3-)"
    done
    echo -e "${DIM}╠${HBAR}╣${NC}"

    # Top 10 contributors
    _ghs_row " ${BOLD}${GREEN}Top 10 Contributors${NC}"
    echo "$contributors" | jq -r '.[] | "\(.login)  \(.contributions)"' 2>/dev/null | head -10 | \
    while IFS= read -r line; do
        local login contribs
        login=$(echo "$line" | awk '{print $1}')
        contribs=$(echo "$line" | awk '{print $2}')
        _ghs_row " ${GREEN}$login${NC}  ${DIM}$contribs commits${NC}"
    done

    echo -e "${DIM}╚${HBAR}╝${NC}\n"

    local choice
    IFS= read -r -p "Clone this repo? [y/N] " choice
    if [[ "$choice" =~ ^[Yy]$ ]]; then
        gc "$selected"
    fi
}
alias ghs='githubsearch'


#=======================================================================
#  TMUX - TERMINAL MULTIPLEXER
#=======================================================================
# Functions and aliases for managing Tmux sessions, windows, and layouts.
alias tnewsession=createNewSessionInsideTmuxSession
alias tkill=killTmuxSession 
alias layout=defaultLayout
alias project=projectLayout
alias tnewwindow='tmux new-window -n ' 
alias twindowname='tmux rename-window '
alias tsessionname='tmux rename-session '
alias lw='tmw'
alias w='tmw'

tmw() {
  local target
  target=$(tmux list-windows -a -F "#{session_name}:#{window_index} | #{session_name} > #{window_name} #{?window_active,(active),}" | \
    fzf-tmux -p 80% --reverse --header "Search Sessions & Windows" \
    --delimiter "|" --with-nth 2 | \
    cut -d " " -f 1)

  if [[ -n "$target" ]]; then
    tmux switch-client -t "${target%:}"
  fi
}

function createNewSessionInsideTmuxSession(){
    session_name=$1
    tmux has-session -t=$session_name 2> /dev/null
    if [[ $? -ne 0 ]]; then
      TMUX='' tmux new-session -d -s "$session_name"
    fi
    if [[ -z "$TMUX" ]]; then
      tmux attach -t "$session_name"
    else
      tmux switch-client -t "$session_name"
    fi
}

function killTmuxSession(){
  tls;
  IFS= read -r -p "input session name: " sessionName
  tmux switch-client -t main &&
  tmux kill-session -t "$sessionName" ;
}

function defaultLayout(){
  tmux selectp -t 0;
  tmux splitw -v -p 40;
  tmux splitw -h -p 50;
  tmux splitw -v -p 50;
  tmux selectp -t 1;
  tmux splitw -v -p 50;
  tmux send-keys -t1 music Enter ;
  tmux send-keys -t1 yazi Enter ;
  tmux send-keys -t4 "cd ~/Downloads" Enter ;
  tmux selectp -t 0;
}

function projectLayout(){
  tmux selectp -t 0;
  tmux splitw -h -p 50;
  tmux selectp -t 1;
  tmux splitw -v -p 50;
  tmux selectp -t 0;
  tmux send-keys -t0 "claude --chrome" Enter;
}


#=======================================================================
#  DEVELOPMENT
#=======================================================================
# Aliases and functions for development-related tasks (Node.js, Prisma, etc.).
alias npminstalled='npm list --global --depth=0'
function updatePrismaSchema(){
 npx prisma db pull
 npx prisma generate
}

# Interactive rustup doc browser — fuzzy searches all ~2000 topics from local docs.
# Note: shadows the rustdoc compiler binary (rarely called directly; cargo doc wraps it).
# Rename to e.g. 'rdoc' if you need the real rustdoc in your PATH.
rust() {
    local docs
    docs=$(dirname "$(rustup doc --path 2>/dev/null)" 2>/dev/null)
    if [[ -z "$docs" || ! -d "$docs/std" ]]; then
        echo "rustup docs not found. Run: rustup component add rust-docs"
        return 1
    fi

    local selection
    selection=$(
        {
            # Named book flags pinned at top (description in middle, --flag at end for $NF extraction)
            printf '%-10s %-54s %s\n' \
                "book" "The Rust Programming Language book"               "--book" \
                "book" "Standard library API documentation"               "--std" \
                "book" "The Cargo Book"                                   "--cargo" \
                "book" "The Rust Reference"                               "--reference" \
                "book" "The Rust Core Library"                            "--core" \
                "book" "The Rust core allocation and collections library" "--alloc" \
                "book" "The Clippy Documentation"                         "--clippy" \
                "book" "The Rust Edition Guide"                           "--edition-guide" \
                "book" "The Embedded Rust Book"                           "--embedded-book" \
                "book" "The Rust Error Codes Index"                       "--error-codes" \
                "book" "The Dark Arts of Advanced and Unsafe Rust"        "--nomicon" \
                "book" "A support library for macro authors"              "--proc_macro" \
                "book" "Runnable examples illustrating Rust concepts"     "--rust-by-example" \
                "book" "The Rust compiler documentation"                  "--rustc" \
                "book" "Documentation generator for Rust projects"        "--rustdoc" \
                "book" "The Rust Style Guide"                             "--style-guide" \
                "book" "Unit-test and micro-benchmarking framework"       "--test" \
                "book" "The Unstable Book"                                "--unstable-book"

            # All std items + modules, sorted alphabetically by topic
            {
                # Modules (directories containing index.html)
                find "$docs/std" -mindepth 2 -name "index.html" -printf "%P\n" \
                    | sed 's|/index\.html$||; s|/|::|g' \
                    | awk '{printf "%-10s std::%s\n", "module", $0}'

                # Items — skip non-! macro duplicates (macro.foo.html) keeping macro.foo!.html
                find "$docs/std" -name "*.html" -printf "%P\n" \
                    | grep -v '^index\.html$' \
                    | grep -v '^all\.html$' \
                    | grep -v 'sidebar-items' \
                    | grep -v 'not_found' \
                    | grep -vE 'macro\.[^!]+\.html$' \
                    | awk -F/ '{
                        file=$NF; sub(/\.html$/, "", file)
                        dot=index(file,".")
                        kind=substr(file,1,dot-1)
                        name=substr(file,dot+1)
                        n=NF-1
                        if(n==0) { topic=name }
                        else { mod=$1; for(i=2;i<=n;i++) mod=mod"::"$i; topic="std::"mod"::"name }
                        printf "%-10s %s\n", kind, topic
                    }'
            } | sort -k2

        } | fzf --height=70% --reverse \
                --prompt='rustup doc > ' \
                --header='struct · fn · type · trait · constant · macro · enum · keyword · primitive · derive · attr · union · module · book' \
                --bind='tab:down,shift-tab:up'
    )

    [[ -z "$selection" ]] && return

    local topic
    topic=$(awk '{print $NF}' <<< "$selection")
    rustup doc "$topic"
}

# Interactive Python API browser — fuzzy searches builtins, keywords, and the
# stdlib modules most useful for LeetCode (collections, itertools, functools,
# heapq, bisect, math, string, re, operator, typing) plus str/list/dict/set/
# tuple methods. Pulled live from the installed interpreter's docstrings via
# pydoc3, so no separate docs package or internet connection is needed.
# Note: shadows the real 'pydoc' command (this system only ships 'pydoc3');
# rename this to e.g. 'pyd' if you need the stock pydoc CLI under this name.
pydoc() {
    local selection
    selection=$(
        python3 - <<'PYEOF' |
import inspect

modules = [
    "collections", "itertools", "functools", "heapq", "bisect",
    "math", "string", "re", "operator", "typing",
]

seen = set()

for modname in modules:
    mod = __import__(modname)
    if modname not in seen:
        seen.add(modname)
        doc = (inspect.getdoc(mod) or "").split("\n")[0]
        print(f"{'module':<10} {modname:<30} {doc}")
    for name, obj in inspect.getmembers(mod):
        if name.startswith("_"):
            continue
        full = f"{modname}.{name}"
        if full in seen:
            continue
        seen.add(full)
        kind = "class" if inspect.isclass(obj) else "function" if inspect.isroutine(obj) else "member"
        doc = (inspect.getdoc(obj) or "").split("\n")[0]
        print(f"{kind:<10} {full:<30} {doc}")

for typename in ("str", "list", "dict", "set", "tuple", "frozenset"):
    t = eval(typename)
    for name, obj in inspect.getmembers(t):
        if name.startswith("_"):
            continue
        full = f"{typename}.{name}"
        if full in seen:
            continue
        seen.add(full)
        doc = (inspect.getdoc(obj) or "").split("\n")[0]
        print(f"{'method':<10} {full:<30} {doc}")

import builtins, keyword
for kw in keyword.kwlist:
    if kw in seen:
        continue
    seen.add(kw)
    print(f"{'keyword':<10} {kw:<30}")

for name in dir(builtins):
    if name.startswith("_") or name in seen:
        continue
    obj = getattr(builtins, name)
    seen.add(name)
    kind = "class" if inspect.isclass(obj) else "function" if inspect.isroutine(obj) else "member"
    doc = (inspect.getdoc(obj) or "").split("\n")[0]
    print(f"{kind:<10} {name:<30} {doc}")
PYEOF
        fzf --height=90% --reverse \
            --prompt='python doc > ' \
            --header='module · class · function · method · member · keyword' \
            --tiebreak=begin \
            --color='hl:yellow,hl+:yellow' \
            --bind='tab:down,shift-tab:up'
    )

    [[ -z "$selection" ]] && return

    local topic
    topic=$(awk '{print $2}' <<< "$selection")
    pydoc3 "$topic"
}

# Interactive FastAPI (+ Starlette bits it re-exports) API browser — same
# mechanism as pydoc(): live inspect.getmembers() introspection, but scoped to
# fastapi and the submodules you actually import from day to day (security,
# responses, testclient, middleware.cors, staticfiles, params, ...). Uses
# whichever 'python3' is first on PATH, so activate your venv first if
# FastAPI lives there rather than globally.
fastapidoc() {
    if ! python3 -c "import fastapi" 2>/dev/null; then
        echo "fastapi not importable by 'python3'. Activate the venv that has it installed, or: pip install fastapi"
        return 1
    fi

    local selection
    selection=$(
        python3 - <<'PYEOF' |
import inspect

modules = [
    "fastapi", "fastapi.security", "fastapi.responses", "fastapi.testclient",
    "fastapi.encoders", "fastapi.exceptions", "fastapi.middleware",
    "fastapi.middleware.cors", "fastapi.staticfiles", "fastapi.templating",
    "fastapi.background", "fastapi.requests", "fastapi.websockets", "fastapi.params",
]

seen = set()
out = []

for modname in modules:
    try:
        mod = __import__(modname, fromlist=["_"])
    except Exception:
        continue
    if modname not in seen:
        seen.add(modname)
        doc = (inspect.getdoc(mod) or "").split("\n")[0]
        out.append(("module", modname, doc))
    for name, obj in inspect.getmembers(mod):
        if name.startswith("_") or inspect.ismodule(obj):
            continue
        full = f"{modname}.{name}"
        if full in seen:
            continue
        seen.add(full)
        kind = "class" if inspect.isclass(obj) else "function" if inspect.isroutine(obj) else "member"
        doc = (inspect.getdoc(obj) or "").split("\n")[0]
        out.append((kind, full, doc))

out.sort(key=lambda e: e[1])
for kind, topic, desc in out:
    print(f"{kind:<10} {topic:<32} {desc}")
PYEOF
        fzf --height=90% --reverse \
            --prompt='fastapi doc > ' \
            --header='module · class · function · member' \
            --tiebreak=begin \
            --color='hl:yellow,hl+:yellow' \
            --bind='tab:down,shift-tab:up'
    )

    [[ -z "$selection" ]] && return

    local topic
    topic=$(awk '{print $2}' <<< "$selection")
    pydoc3 "$topic"
}

# Fuzzy-search all crates in the current Cargo project's generated docs.
# Run `cargo doc` first if target/doc doesn't exist yet.
doc() {
    local root
    root=$(cargo locate-project --message-format plain 2>/dev/null)
    if [[ -z "$root" ]]; then
        echo "This command only works inside a Cargo project."
        return 1
    fi

    cargo doc 2>&1 || return 1

    local doc_dir
    doc_dir="$(dirname "$root")/target/doc"
    if [[ ! -d "$doc_dir" ]]; then
        local workspace_root
        workspace_root=$(cargo metadata --no-deps --format-version 1 2>/dev/null \
            | grep -o '"workspace_root":"[^"]*"' | sed 's|"workspace_root":"||;s|"||g')
        doc_dir="$workspace_root/target/doc"
    fi

    local selected
    selected=$(find "$doc_dir" -mindepth 1 -maxdepth 1 -type d -printf '%f\n' | sort | \
        fzf --height=50% --reverse --prompt='crate > ')
    [[ -z "$selected" ]] && return 0

    local all_html="$doc_dir/$selected/all.html"
    if [[ ! -f "$all_html" ]]; then
        echo "all.html not found for: $selected"
        return 1
    fi

    w3m "$all_html"
}

# Interactive Docker CLI browser — fuzzy searches every docker command and
# subcommand (run, container ls, image build, volume prune, compose up, ...)
# by recursively parsing `docker ... --help` output (up to 3 levels deep) live
# from your installed Docker CLI, so it always matches your installed version.
# Named 'ddoc' rather than 'docker' so it doesn't shadow the real docker CLI.
ddoc() {
    local selection
    selection=$(
        python3 - <<'PYEOF' |
import re
import subprocess

MAX_DEPTH = 3


def get_help(path):
    proc = subprocess.run(
        ["docker", *path, "--help"], capture_output=True, text=True, timeout=5
    )
    return proc.stdout


def parse_commands(text):
    section = None
    for line in text.splitlines():
        header = re.match(r"^(Common Commands|Management Commands|Swarm Commands|Commands):$", line)
        if header:
            section = header.group(1)
            continue
        if section is None:
            continue
        if not line.startswith(" "):
            section = None
            continue
        m = re.match(r"^ {2}(\S+)\s{2,}(.*)$", line)
        if m:
            name, desc = m.group(1), m.group(2).strip()
            is_group = section in ("Management Commands", "Swarm Commands")
            yield name.rstrip("*"), desc, is_group


def walk(path, depth, seen_paths, out):
    if depth > MAX_DEPTH:
        return
    key = tuple(path)
    if key in seen_paths:
        return
    seen_paths.add(key)

    for name, desc, is_group in parse_commands(get_help(path)):
        topic = path + [name]
        kind = "group" if is_group else "command"
        out.append((kind, "/".join(topic), desc))
        if is_group:
            walk(topic, depth + 1, seen_paths, out)


out = []
walk([], 0, set(), out)
out.sort(key=lambda e: e[1])
for kind, topic, desc in out:
    print(f"{kind:<10} {topic:<28} {desc}")
PYEOF
        fzf --height=90% --reverse \
            --prompt='docker doc > ' \
            --header='group · command  (path segments joined by /)' \
            --tiebreak=begin \
            --color='hl:yellow,hl+:yellow' \
            --bind='tab:down,shift-tab:up'
    )

    [[ -z "$selection" ]] && return

    local topic parts
    topic=$(awk '{print $2}' <<< "$selection")
    IFS='/' read -ra parts <<< "$topic"
    docker "${parts[@]}" --help
}

# Interactive git command browser — fuzzy searches all ~150 git commands
# (porcelain and plumbing) by parsing the GIT COMMANDS section of `man git`,
# so it always matches your installed git version. Named 'gdoc' since 'git'
# itself obviously can't be shadowed.
gdoc() {
    local selection
    selection=$(
        python3 - <<'PYEOF' |
import re
import subprocess

proc = subprocess.run(["man", "git"], capture_output=True, text=True)
if not proc.stdout:
    raise SystemExit("man git produced no output")
raw = subprocess.run(["col", "-b"], input=proc.stdout, capture_output=True, text=True).stdout
lines = raw.splitlines()

start = next(i for i, l in enumerate(lines) if l.strip() == "GIT COMMANDS")
end = next(i for i, l in enumerate(lines) if l.strip() == "CONFIGURATION MECHANISM")

category = None
entries = []
i = start
while i < end:
    line = lines[i]
    if line.strip() == "":
        i += 1
        continue
    indent = len(line) - len(line.lstrip(" "))
    text = line.strip()
    if indent == 3:
        category = text
        i += 1
        continue
    m = re.match(r"^git-([\w.-]+)\(1\)$", text) if indent == 7 else None
    if m:
        name = m.group(1)
        desc_lines = []
        j = i + 1
        while j < end and lines[j].strip() != "":
            desc_lines.append(lines[j].strip())
            j += 1
        entries.append((name, category, " ".join(desc_lines)))
        i = j
        continue
    i += 1

entries.sort(key=lambda e: e[0])
for name, cat, desc in entries:
    print(f"{'command':<10} {name:<20} ({cat}) {desc}")
PYEOF
        fzf --height=90% --reverse \
            --prompt='git doc > ' \
            --header='command  (category in parens)' \
            --tiebreak=begin \
            --color='hl:yellow,hl+:yellow' \
            --bind='tab:down,shift-tab:up'
    )

    [[ -z "$selection" ]] && return

    local topic
    topic=$(awk '{print $2}' <<< "$selection")
    git help "$topic"
}

# Interactive uv (Python package manager) CLI browser — fuzzy searches every
# uv command and subcommand (add, sync, pip install, tool install, python
# pin, ...) by recursively parsing `uv ... --help`, live from your installed
# uv, up to 3 levels deep. Named 'uvdoc' so it doesn't shadow the real 'uv'.
uvdoc() {
    local selection
    selection=$(
        python3 - <<'PYEOF' |
import re
import subprocess

MAX_DEPTH = 3


def get_help(path):
    proc = subprocess.run(["uv", *path, "--help"], capture_output=True, text=True, timeout=5)
    return proc.stdout


def parse_commands(text):
    entries = []
    capturing = False
    for line in text.splitlines():
        if line == "Commands:":
            capturing = True
            continue
        if not capturing:
            continue
        if line.strip() == "":
            break
        m = re.match(r"^ {2}(\S+)\s{2,}(.*)$", line)
        if m:
            entries.append((m.group(1), m.group(2).strip()))
    return entries


def walk(path, depth, seen, out, desc=""):
    if depth > MAX_DEPTH:
        return
    key = tuple(path)
    if key in seen:
        return
    seen.add(key)

    entries = parse_commands(get_help(path))
    if path:
        kind = "group" if entries else "command"
        out.append((kind, "/".join(path), desc))
    for name, sdesc in entries:
        walk(path + [name], depth + 1, seen, out, sdesc)


out = []
walk([], 0, set(), out)
out.sort(key=lambda e: e[1])
for kind, topic, desc in out:
    print(f"{kind:<10} {topic:<20} {desc}")
PYEOF
        fzf --height=90% --reverse \
            --prompt='uv doc > ' \
            --header='group · command  (path segments joined by /)' \
            --tiebreak=begin \
            --color='hl:yellow,hl+:yellow' \
            --bind='tab:down,shift-tab:up'
    )

    [[ -z "$selection" ]] && return

    local topic parts
    topic=$(awk '{print $2}' <<< "$selection")
    IFS='/' read -ra parts <<< "$topic"
    uv "${parts[@]}" --help
}


#=======================================================================
#  MEDIA & YOUTUBE
#=======================================================================
# Aliases for downloading media and playing audio.
alias youtubesubtitle='yt-dlp --sub-lang en --convert-subs srt --write-sub --skip-download'
alias youtube='yt-dlp --no-playlist -o "%(title)s.%(ext)s"'
alias youtubechannelrelease='yt-dlp -x --audio-format mp3 -c --write-info-json -o "%(uploader)s/[%(upload_date>%Y)s] %(album,playlist_title)s/%(track_number,playlist_index)02d - %(title)s.%(ext)s" --add-metadata --embed-thumbnail --yes-playlist '
youtubeplayliststartfrom() {
    yt-dlp -o "%(uploader)s/[%(upload_date>%Y)s] %(playlist_title)s/%(playlist_index)02d - %(title)s.%(ext)s" \
        --add-metadata --embed-thumbnail --write-info-json --yes-playlist \
        --playlist-start "$1" "$2"
}

youtubedownloadmp3() {
    local url="$1"
    if [ -z "$url" ]; then
        read -r -p "▶ URL: " url
        [ -z "$url" ] && return 1
    fi
    local music_dir="$HOME/Music"
    mkdir -p "$music_dir"
    yt-dlp -x --audio-format mp3 --audio-quality 0 \
        --add-metadata --embed-thumbnail \
        --no-playlist \
        -o "$music_dir/%(title)s.%(ext)s" \
        "$url"
}

musicplay() {
    local url="$1"

    # & in YouTube URLs is a bash metacharacter — the shell splits the URL before
    # the function sees it. Prompt with read so the user can paste without quotes.
    if [ -z "$url" ]; then
        read -r -p "▶ URL: " url
        [ -z "$url" ] && return 1
    fi
    local music_dir="$HOME/Music"
    mkdir -p "$music_dir"
    cd "$music_dir" || return

    # Real playlists (list=PL...) → subfolder + all tracks.
    # YouTube Mix/Radio (list=RD..., start_radio=1) → single video only.
    local output_tmpl dl_flags=()
    if [[ "$url" == *"list=PL"* ]]; then
        output_tmpl="%(playlist_title)s/%(playlist_index)02d - %(title)s.%(ext)s"
    else
        output_tmpl="%(title)s.%(ext)s"
        dl_flags=(--no-playlist)
    fi

    # Download to file in the background
    yt-dlp -x --audio-format best --audio-quality 0 "${dl_flags[@]}" -o "$music_dir/$output_tmpl" "$url" >/dev/null 2>&1 &
    disown

    # Stream via a named FIFO so yt-dlp runs as a tracked background process.
    # When mpv exits (q), we kill yt-dlp immediately instead of waiting for it to drain.
    # Reading from a FIFO path (not stdin) also means mpv's stdin stays as the terminal,
    # so --no-config + no window gives clean keyboard control without --input-terminal hacks.
    local fifo
    fifo=$(mktemp -u /tmp/mp3_XXXXXX)
    mkfifo "$fifo"

    yt-dlp -f bestaudio "${dl_flags[@]}" -o - "$url" > "$fifo" 2>/dev/null &
    local ytdlp_pid=$!

    mpv --no-config \
        --input-conf="$HOME/.config/mpv/input.conf" \
        --no-video \
        --input-terminal=yes \
        "$fifo"

    kill "$ytdlp_pid" 2>/dev/null
    wait "$ytdlp_pid" 2>/dev/null
    rm -f "$fifo"
}

#=======================================================================
#  DOTFILES MANAGEMENT
#=======================================================================
# Aliases for managing dotfiles and reloading shell configuration.
load() {
  source ~/.bashrc
  source ~/.profile
  [ -n "$TMUX" ] && tmux source-file ~/.tmux.conf
  echo "dotfiles reloaded..."
  echo "to reload awesomeWM, use following command"
  echo "super+ctrl+r"
}

function updatedotfiles {
    local CYAN='\033[1;36m'
    local GREEN='\033[1;32m'
    local RED='\033[1;31m'
    local YELLOW='\033[1;33m'
    local MAGENTA='\033[1;35m'
    local BLUE='\033[1;34m'
    local DIM='\033[2m'
    local NC='\033[0m'
    local BAR="════════════════════════════════════════════════════════════════════════════"

    local out status
    out=$(chezmoi re-add 2>&1)
    status=$?

    echo -e "\n${DIM}╔${BAR}╗${NC}"

    if [[ $status -ne 0 ]]; then
        echo -e "${DIM}║${NC}  ${MAGENTA}dotfiles${NC} ${DIM}│${NC} ${RED}✗ sync failed${NC}"
        echo -e "${DIM}╠${BAR}╣${NC}"
        while IFS= read -r line; do
            echo -e "${DIM}║${NC}  ${RED}${line}${NC}"
        done <<< "$out"
        echo -e "${DIM}╚${BAR}╝${NC}\n"
        return $status
    fi

    if [[ -z "$out" ]]; then
        echo -e "${DIM}║${NC}  ${MAGENTA}dotfiles${NC} ${DIM}│${NC} ${GREEN}up to date${NC}"
        echo -e "${DIM}╚${BAR}╝${NC}\n"
        return 0
    fi

    local commit_line branch commit_hash commit_msg
    commit_line=$(grep -m1 -oP '^\[\S+ [0-9a-f]+\] .*' <<< "$out")

    if [[ -z "$commit_line" ]]; then
        echo -e "${DIM}║${NC}  ${MAGENTA}dotfiles${NC} ${DIM}│${NC} ${YELLOW}synced (unrecognized output)${NC}"
        echo -e "${DIM}╠${BAR}╣${NC}"
        while IFS= read -r line; do
            echo -e "${DIM}║${NC}  ${line}"
        done <<< "$out"
        echo -e "${DIM}╚${BAR}╝${NC}\n"
        return 0
    fi

    branch=$(sed -E 's/^\[([^ ]+) .*/\1/' <<< "$commit_line")
    commit_hash=$(sed -E 's/^\[[^ ]+ ([0-9a-f]+)\].*/\1/' <<< "$commit_line")
    commit_msg=$(sed -E 's/^\[[^]]+\] //' <<< "$commit_line")

    echo -e "${DIM}║${NC}  ${MAGENTA}dotfiles${NC} ${DIM}│${NC} ${GREEN}synced${NC} ${DIM}to${NC} ${CYAN}${branch}${NC}"
    echo -e "${DIM}╠${BAR}╣${NC}"

    while IFS=' ' read -r verb path; do
        [[ -z "$path" ]] && continue
        case "$verb" in
            Add)    echo -e "${DIM}║${NC}  ${GREEN}  added${NC}   $path" ;;
            Remove) echo -e "${DIM}║${NC}  ${RED}  removed${NC} $path" ;;
            *)      echo -e "${DIM}║${NC}  ${CYAN}  updated${NC} $path" ;;
        esac
    done < <(grep -oP '(Update|Add|Remove) \S+' <<< "$commit_msg")

    local stat_line files_changed insertions deletions plural
    stat_line=$(grep -m1 -E '^ [0-9]+ files? changed' <<< "$out")
    files_changed=$(grep -oP '^\s*\K[0-9]+' <<< "$stat_line")
    insertions=$(grep -oP '\d+(?= insertions?\(\+\))' <<< "$stat_line")
    deletions=$(grep -oP '\d+(?= deletions?\(-\))' <<< "$stat_line")
    plural="s"
    [[ "${files_changed:-0}" == "1" ]] && plural=""

    local push_dest push_line range local_b arrow remote_b old_sha new_sha
    push_dest=$(grep -m1 -oP '^To \K\S+' <<< "$out" | sed -E 's#^https?://##; s#\.git$##')
    push_line=$(grep -m1 -oP '[0-9a-f]+\.\.[0-9a-f]+\s+\S+ -> \S+' <<< "$out")
    if [[ -n "$push_line" ]]; then
        read -r range local_b arrow remote_b <<< "$push_line"
        old_sha=${range%%..*}
        new_sha=${range##*..}
    fi

    echo -e "${DIM}╠${BAR}╣${NC}"
    echo -e "${DIM}║${NC}  ${YELLOW}commit${NC}  ${commit_hash}  ${GREEN}+${insertions:-0}${NC} ${RED}-${deletions:-0}${NC}  ${DIM}(${files_changed:-0} file${plural})${NC}"
    if [[ -n "$push_dest" ]]; then
        echo -e "${DIM}║${NC}  ${BLUE}pushed${NC}  ${DIM}${old_sha}..${NC}${new_sha:-$commit_hash} ${DIM}→${NC} ${push_dest} ${DIM}(${remote_b:-$branch})${NC}"
    fi
    echo -e "${DIM}╚${BAR}╝${NC}\n"
}
function syncdotfiles {
    cd ~/Desktop && chezmoi update
}
alias cddotfiles='chezmoi cd && echo "current path" && pwd'
alias adddotfiles='chezmoi add'
alias removedotfiles='chezmoi destroy'
alias diffdotfiles='chezmoi status'


#=======================================================================
#  DISK & OS UTILITIES
#=======================================================================
# Functions for disk reporting and creating bootable USB drives.
diskreport() {
  RED="\e[31m"
  GREEN="\e[32m"
  CYAN="\e[36m"
  YELLOW="\e[33m"
  BOLD="\e[1m"
  RESET="\e[0m"

  echo -e "${BOLD}${CYAN}=== 🔎 Disk and OS Information Report ===${RESET}\n"
  echo -e "${YELLOW}👉 Physical Disks and Partitions:${RESET}"
  lsblk -o NAME,SIZE,FSTYPE,LABEL,MOUNTPOINT,TYPE | grep -E "disk|part" | grep -v "loop"
  echo
  echo -e "${YELLOW}👉 Detailed Partition Layout (fdisk):${RESET}"
  sudo fdisk -l | grep -E "Disk /dev/(sd|nvme)"
  echo
  echo -e "${YELLOW}👉 Currently Mounted Filesystems:${RESET}"
  mount | grep '^/dev/' | grep -v "loop"
  echo
  echo -e "${YELLOW}👉 UEFI Boot Entries (Bootloaders in firmware):${RESET}"
  sudo efibootmgr -v
  echo
  echo -e "${YELLOW}👉 Current Linux Distribution:${RESET}"
  grep -E 'PRETTY_NAME|VERSION=' /etc/os-release
  echo
  echo -e "${YELLOW}👉 Kernel and System Architecture:${RESET}"
  uname -a
  echo
  echo -e "${YELLOW}👉 Checking for Windows Partitions (NTFS):${RESET}"
  lsblk -o NAME,SIZE,FSTYPE,LABEL,MOUNTPOINT,TYPE | grep ntfs || echo -e "${RED}No Windows partitions found.${RESET}"
  echo
  echo -e "${GREEN}${BOLD}=== ✅ Report Complete ===${RESET}"
}

burnWindowUSB(){
  local iso="${1:-Windows_ISO_Placeholder.iso}"
  local drive="${2:-/dev/sdX}"
  local woeusb_url="https://github.com/WoeUSB/WoeUSB/releases/download/v5.2.4/woeusb-5.2.4.bash"
  local woeusb_bin="/usr/local/bin/woeusb"

  # Sanity checks
  if [[ "$drive" == "/dev/sdX" ]]; then
    echo "ERROR: Please specify your USB drive as the second argument, e.g.:"
    echo "  burnWindowUSB Windows.iso /dev/sdb"
    echo "Run 'diskreport' to identify your USB device."
    return 1
  fi
  if [[ ! -f "$iso" ]]; then
    echo "ERROR: ISO file not found: $iso"
    return 1
  fi

  # Install dependencies
  echo "==> Installing WoeUSB dependencies..."
  sudo apt-get install -y \
    wimtools \
    cabextract \
    genisoimage \
    ntfs-3g \
    parted \
    grub-pc-bin \
    grub-efi-amd64-bin \
    util-linux

  # Download woeusb if not already present
  if [[ ! -x "$woeusb_bin" ]]; then
    echo "==> Downloading WoeUSB..."
    sudo curl -fsSL "$woeusb_url" -o "$woeusb_bin"
    sudo chmod +x "$woeusb_bin"
  else
    echo "==> WoeUSB already installed at $woeusb_bin"
  fi

  # Burn
  echo "==> Burning '$iso' to '$drive' (this may take 1-2 hours)..."
  sudo "$woeusb_bin" --target-filesystem NTFS --device "$iso" "$drive"
}

burnLinuxUSB(){
  echo '1. run "diskrepot" command and find the mounted usb device, usually /dev/sda or /dev/sdb'
  echo '2. sudo dd if=linux.iso of=/dev/sdb bs=4M status=progress oflag=sync'
  echo "3. takes about 1-2 hours to burn to usb"
}


#=======================================================================
#  DOCKER
#=======================================================================
POSTGRES_CONTAINER="postgres_dev"
POSTGRES_USER="devuser"
POSTGRES_PASSWORD="devpass"
POSTGRES_DB="devdb"
POSTGRES_PORT="5432"

startPostgres() {
    if docker ps --format '{{.Names}}' | grep -q "^${POSTGRES_CONTAINER}$"; then
        echo "already running"
        return 0
    fi

    if docker ps -a --format '{{.Names}}' | grep -q "^${POSTGRES_CONTAINER}$"; then
        docker start "$POSTGRES_CONTAINER" > /dev/null
    else
        docker run -d \
            --name "$POSTGRES_CONTAINER" \
            -e POSTGRES_USER="$POSTGRES_USER" \
            -e POSTGRES_PASSWORD="$POSTGRES_PASSWORD" \
            -e POSTGRES_DB="$POSTGRES_DB" \
            -p "${POSTGRES_PORT}:5432" \
            postgres:latest > /dev/null
    fi

    echo "postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:${POSTGRES_PORT}/${POSTGRES_DB}"
}

stopPostgres() {
    if docker ps --format '{{.Names}}' | grep -q "^${POSTGRES_CONTAINER}$"; then
        docker stop "$POSTGRES_CONTAINER" > /dev/null
        echo "postgres stopped"
    else
        echo "postgres is not running"
    fi
}

openPostgres() {
    if ! docker ps --format '{{.Names}}' | grep -q "^${POSTGRES_CONTAINER}$"; then
        echo "postgres is not running — start it first with: startPostgres"
        return 1
    fi
    pkill -f "pgweb" 2>/dev/null; sleep 0.5
    ~/go/bin/pgweb --url="postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:${POSTGRES_PORT}/${POSTGRES_DB}?sslmode=disable" --listen=8081 --lock-session
}

#=======================================================================
#  YAZI FILE MANAGER
#=======================================================================
source ~/.config/yazi/yazi.sh