dot_functions

#!/usr/bin/env bash

# Create a new directory and enter it
function mkd() {
	mkdir -p "$@" && cd "$_"
}

# Create a .tar.gz archive, using `zopfli`, `pigz` or `gzip` for compression
function targz() {
	local tmpFile="${@%/}.tar"
	tar -cvf "${tmpFile}" --exclude=".DS_Store" "${@}" || return 1

	size=$(
		stat -f"%z" "${tmpFile}" 2>/dev/null # macOS `stat`
		stat -c"%s" "${tmpFile}" 2>/dev/null # GNU `stat`
	)

	local cmd=""
	if ((size < 52428800)) && hash zopfli 2>/dev/null; then
		# the .tar file is smaller than 50 MB and Zopfli is available; use it
		cmd="zopfli"
	else
		if hash pigz 2>/dev/null; then
			cmd="pigz"
		else
			cmd="gzip"
		fi
	fi

	echo "Compressing .tar ($((size / 1000)) kB) using \`${cmd}\`…"
	"${cmd}" -v "${tmpFile}" || return 1
	[ -f "${tmpFile}" ] && rm "${tmpFile}"

	zippedSize=$(
		stat -f"%z" "${tmpFile}.gz" 2>/dev/null # macOS `stat`
		stat -c"%s" "${tmpFile}.gz" 2>/dev/null # GNU `stat`
	)

	echo "${tmpFile}.gz ($((zippedSize / 1000)) kB) created successfully."
}

# Determine size of a file or total size of a directory
function fs() {
	if du -b /dev/null >/dev/null 2>&1; then
		local arg=-sbh
	else
		local arg=-sh
	fi
	if [[ -n "$@" ]]; then
		du $arg -- "$@"
	else
		du $arg .[^.]* ./*
	fi
}

# Use Git’s colored diff when available
hash git &>/dev/null
if [ $? -eq 0 ]; then
	function diff() {
		git diff --no-index --color-words "$@"
	}
fi

# Create a data URL from a file
function dataurl() {
	local mimeType=$(file -b --mime-type "$1")
	if [[ $mimeType == text/* ]]; then
		mimeType="${mimeType};charset=utf-8"
	fi
	echo "data:${mimeType};base64,$(openssl base64 -in "$1" | tr -d '\n')"
}


# Compare original and gzipped file size
function gz() {
	local origsize=$(wc -c <"$1")
	local gzipsize=$(gzip -c "$1" | wc -c)
	local ratio=$(echo "$gzipsize * 100 / $origsize" | bc -l)
	printf "orig: %d bytes\n" "$origsize"
	printf "gzip: %d bytes (%2.2f%%)\n" "$gzipsize" "$ratio"
}

# Run `dig` and display the most useful info
function digga() {
	dig +nocmd "$1" any +multiline +noall +answer
}

# Show all the names (CNs and SANs) listed in the SSL certificate
# for a given domain
function getcertnames() {
	if [ -z "${1}" ]; then
		echo "ERROR: No domain specified."
		return 1
	fi

	local domain="${1}"
	echo "Testing ${domain}…"
	echo "" # newline

	local tmp=$(echo -e "GET / HTTP/1.0\nEOT" |
		openssl s_client -connect "${domain}:443" -servername "${domain}" 2>&1)

	if [[ "${tmp}" = *"-----BEGIN CERTIFICATE-----"* ]]; then
		local certText=$(echo "${tmp}" |
			openssl x509 -text -certopt "no_aux, no_header, no_issuer, no_pubkey, \
			no_serial, no_sigdump, no_signame, no_validity, no_version")
		echo "Common Name:"
		echo "" # newline
		echo "${certText}" | grep "Subject:" | sed -e "s/^.*CN=//" | sed -e "s/\/emailAddress=.*//"
		echo "" # newline
		echo "Subject Alternative Name(s):"
		echo "" # newline
		echo "${certText}" | grep -A 1 "Subject Alternative Name:" |
			sed -e "2s/DNS://g" -e "s/ //g" | tr "," "\n" | tail -n +2
		return 0
	else
		echo "ERROR: Certificate not found."
		return 1
	fi
}

# `s` with no arguments re-sources ~/.zshrc, otherwise sources the given file
function s() {
	if [ $# -eq 0 ]; then
		source ~/.zshrc
	else
		source "$@"
	fi
}

# `o` with no arguments opens the current directory, otherwise opens the given
# location
function o() {
	# Use wslview on WSL, otherwise use open
	local opener
	if [ "$IS_WSL" = "1" ] && command -v wslview >/dev/null 2>&1; then
		opener="wslview"
	elif command -v open >/dev/null 2>&1; then
		opener="open"
	elif command -v xdg-open >/dev/null 2>&1; then
		opener="xdg-open"
	else
		echo "Error: No suitable opener found (tried wslview, open, xdg-open)" >&2
		return 1
	fi

	if [ $# -eq 0 ]; then
		$opener .
	else
		$opener "$@"
	fi
}

# `tre` is a shorthand for `tree` with hidden files and color enabled, ignoring
# the `.git` directory, listing directories first. The output gets piped into
# `less` with options to preserve color and line numbers, unless the output is
# small enough for one screen.
function tre() {
	tree -aC -I '.git|node_modules|bower_components' --dirsfirst "$@" | less -FRNX
}

# 设置全局代理
# 参数：
#   $1 - 代理端口，默认为 7890
# 示例：
#   proxyon 7890
function proxyon() {
	local port=${1:-7890}
	local host
	if [[ $(uname -r) == *microsoft* ]]; then
		host=$(ip route show | grep -i default | awk '{print $3}')
	else
		host=127.0.0.1
	fi
	export HTTPS_PROXY=http://${host}:$port
	export HTTP_PROXY=http://${host}:$port
	export ALL_PROXY=socks5://${host}:$port
}

# 取消全局代理设置
function proxyoff() {
	unset HTTPS_PROXY
	unset HTTP_PROXY
	unset ALL_PROXY
}

# claude_use 切换 Claude API 使用官方 Claude 或自定义 GLM
# 参数：
#   $1 - 模式选择：claude（官方）或 glm（自定义），必须指定
# 示例：
#   claude_use          # 显示帮助信息
#   claude_use claude   # 使用官方 Claude（用户通过 /login 自己登录）
#   claude_use glm      # 使用自定义 GLM API（从 .env 文件读取配置）
function claude_use() {
	local mode=$1
	local env_file="$HOME/.env"

	# 不加参数时显示帮助信息
	if [ -z "$mode" ]; then
		cat <<-'EOF'
		📖 Claude API 模式切换帮助

		用法：
		  claude_use <模式>

		可用模式：
		  claude  - 官方 Claude（用户通过 /login 自己登录）
		  glm     - 自定义 GLM API（从 .env 文件读取配置）

		示例：
		  claude_use claude  # 切换到官方 Claude
		  claude_use glm     # 切换到自定义 GLM API

		查看当前状态：
		  claude_status       # 显示当前 Claude API 配置

		EOF
		return 0
	fi

	case "$mode" in
		claude|official|official-api|official_api)
			# 使用官方 API（用户会自己通过 /login 登录）
			unset ANTHROPIC_AUTH_TOKEN
			unset ANTHROPIC_BASE_URL
			unset ANTHROPIC_API_KEY

			echo "✅ Claude 已切换到官方 API 模式"
			echo "   请确保你已完成登录操作"
			;;

		glm|custom|custom-glm)
			# 使用自定义 GLM API
			if [ ! -f "$env_file" ]; then
				echo "⚠️  错误：$env_file 文件不存在"
				return 1
			fi

			# 从 .env 文件读取配置
			source "$env_file"

			if [ -z "$ANTHROPIC_AUTH_TOKEN" ] || [ -z "$ANTHROPIC_BASE_URL" ]; then
				echo "⚠️  错误：.env 文件中缺少必要的配置"
				return 1
			fi

			# 清除官方配置，使用自定义配置
			unset ANTHROPIC_API_KEY
			export ANTHROPIC_AUTH_TOKEN="$ANTHROPIC_AUTH_TOKEN"
			export ANTHROPIC_BASE_URL="$ANTHROPIC_BASE_URL"

			echo "✅ Claude 已切换到自定义 GLM API 模式"
			echo "   Base URL: $ANTHROPIC_BASE_URL"
			echo "   Auth Token: ${ANTHROPIC_AUTH_TOKEN:0:20}..."
			;;

		*)
			echo "❌ 错误：未知模式 '$mode'"
			echo "使用方法："
			echo "  claude_use claude  - 使用官方 Claude"
			echo "  claude_use glm     - 使用自定义 GLM API"
			echo "  claude_use         - 显示帮助信息"
			return 1
			;;
	esac
}

# claude_status 显示当前 Claude API 配置状态
function claude_status() {
	echo "📊 当前 Claude API 配置状态："
	echo ""

	if [ -n "$ANTHROPIC_AUTH_TOKEN" ] && [ -n "$ANTHROPIC_BASE_URL" ]; then
		echo "🟢 模式：自定义 GLM API"
		echo "   Base URL: $ANTHROPIC_BASE_URL"
		echo "   Auth Token: ${ANTHROPIC_AUTH_TOKEN:0:20}..."
	else
		echo "🔵 模式：官方 Claude（默认）"
		echo "   状态：用户通过 /login 自己登录"
	fi
}

# Git worktree helper - create worktree in default directory and switch to it
# Usage:
#   gwa <branch>     - create worktree for specified branch
#   gwa              - create worktree for current branch
# Environment:
#   WORKTREE_ROOT    - override default worktree directory (default: ~/worktrees)
function gwa() {
	local root="${WORKTREE_ROOT:-$HOME/worktrees}"
	# Get main worktree path to extract repo name
	local main_worktree=$(command git worktree list --porcelain 2>/dev/null | head -1 | cut -d' ' -f2)
	if [[ -z "$main_worktree" ]]; then
		echo "Error: Not in a git repository" >&2
		return 1
	fi
	local repo=$(basename "$main_worktree")
	local branch="${1:-$(command git branch --show-current)}"
	# Replace / with - in branch name for directory name
	local branch_dir=${branch//\//-}
	local worktree_path="$root/$repo-$branch_dir"

	# Check if branch exists (local or remote)
	if git show-ref --verify --quiet "refs/heads/$branch" 2>/dev/null || \
	   git show-ref --verify --quiet "refs/remotes/origin/$branch" 2>/dev/null; then
		# Branch exists, checkout existing branch
		command git worktree add "$worktree_path" "$branch" && cd "$worktree_path"
	else
		# Branch doesn't exist, create new branch
		command git worktree add -b "$branch" "$worktree_path" && cd "$worktree_path"
	fi
}

# Git worktree "switch" - move current branch to a worktree and switch to main
# Usage:
#   gwA <branch>     - pull, switch main, then create worktree for specified branch
#   gwA              - pull, switch main, then create worktree for current branch
# Environment:
#   WORKTREE_ROOT    - override default worktree directory (default: ~/worktrees)
function gwA() {
	local root="${WORKTREE_ROOT:-$HOME/worktrees}"
	local main_worktree=$(command git worktree list --porcelain 2>/dev/null | head -1 | cut -d' ' -f2)
	if [[ -z "$main_worktree" ]]; then
		echo "Error: Not in a git repository" >&2
		return 1
	fi

	local repo=$(basename "$main_worktree")
	local current_branch=$(command git branch --show-current)
	local target_branch="${1:-$current_branch}"

	if [[ -z "$target_branch" ]]; then
		echo "Error: Could not determine target branch" >&2
		return 1
	fi

	# Detect main branch (main or master)
	local main_branch=""
	if command git show-ref --verify --quiet refs/heads/main 2>/dev/null; then
		main_branch="main"
	elif command git show-ref --verify --quiet refs/heads/master 2>/dev/null; then
		main_branch="master"
	else
		echo "Error: Could not find main or master branch" >&2
		return 1
	fi

	echo "Pulling latest changes..."
	command git pull || return 1

	# Stash any uncommitted changes if we're switching away from current branch
	local stashed=false
	if [[ "$current_branch" != "$main_branch" ]] && ! git diff --quiet HEAD 2>/dev/null; then
		echo "Stashing uncommitted changes..."
		command git stash push -m "Auto-stash before gwA on $(date '+%Y-%m-%d %H:%M:%S')"
		stashed=true
	fi

	echo "Switching to $main_branch..."
	command git checkout "$main_branch" || return 1

	# Prepare worktree path
	local branch_dir=${target_branch//\//-}
	local worktree_path="$root/$repo-$branch_dir"

	echo "Creating worktree for $target_branch at $worktree_path..."
	if command git worktree add "$worktree_path" "$target_branch"; then
		cd "$worktree_path" || return 1
		if [[ "$stashed" == "true" ]] && [[ "$target_branch" == "$current_branch" ]]; then
			echo "Note: Uncommitted changes were stashed in main worktree. Run 'git stash pop' to restore."
		fi
	else
		echo "Error: Failed to create worktree. Switching back to $current_branch..."
		command git checkout "$current_branch"
		return 1
	fi
}

# Git commit and push via Claude (non-interactive, background)
# Usage: gcP
function gcP() {
	claude -p "commit and push the code" &
}

# Git commit via Claude (non-interactive, background)
# Usage: gcC
function gcC() {
	claude -p "commit the code" &
}

# Lazygit with directory switching - changes shell dir to match lazygit's last location on exit
function lg() {
	export LAZYGIT_NEW_DIR_FILE="${TMPDIR:-/tmp/}lazygit-lastdir-$$"

	lazygit "$@"

	if [ -f "$LAZYGIT_NEW_DIR_FILE" ]; then
		cd "$(cat "$LAZYGIT_NEW_DIR_FILE")"
		rm -f "$LAZYGIT_NEW_DIR_FILE" > /dev/null
	fi
	unset LAZYGIT_NEW_DIR_FILE
}