ccdocker

#!/bin/bash

# ccdocker - AICoding开发管理工具
# 用于启动Docker/Podman容器并挂载代码目录，以便在容器环境中使用Claude Code等AI编程工具
# 自动检测并使用 Docker 或 Podman（优先使用 Docker）

# 注意：不使用 set -e，因为某些命令（如grep）的正常失败不应该导致脚本退出

# 配置变量
IMAGE_NAME="aicoding-dev:latest"
WORKSPACE_DIR="/workspace"

# 动态获取项目根目录
# 优先使用脚本所在目录，如果脚本目录没有Dockerfile，则使用当前工作目录
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CURRENT_DIR="$(pwd)"

# 查找包含Dockerfile的目录
if [ -f "${SCRIPT_DIR}/Dockerfile" ]; then
    PROJECT_ROOT="${SCRIPT_DIR}"
elif [ -f "${CURRENT_DIR}/Dockerfile" ]; then
    PROJECT_ROOT="${CURRENT_DIR}"
elif [ -f "${CURRENT_DIR}/claude/Dockerfile" ]; then
    PROJECT_ROOT="${CURRENT_DIR}/claude"
else
    # 如果都找不到，使用当前目录
    PROJECT_ROOT="${CURRENT_DIR}"
fi

# 容器配置目录（统一管理容器相关配置，避免与项目文件混淆）
DOCKER_CONFIG_DIR="${PROJECT_ROOT}/.docker"
CONTAINER_NAME_FILE="${DOCKER_CONFIG_DIR}/container-name"
DOCKER_ENV_FILE="${DOCKER_CONFIG_DIR}/env"

# 确保容器配置目录存在
mkdir -p "${DOCKER_CONFIG_DIR}"

# 检测并设置容器运行时（Docker 或 Podman）
detect_container_runtime() {
    # 优先检测 Docker
    if command -v docker > /dev/null 2>&1; then
        if docker info > /dev/null 2>&1; then
            echo "docker"
            return 0
        fi
    fi
    
    # 如果 Docker 不可用，检测 Podman
    if command -v podman > /dev/null 2>&1; then
        if podman info > /dev/null 2>&1; then
            echo "podman"
            return 0
        fi
    fi
    
    # 如果都不可用，返回错误
    return 1
}

# 初始化容器运行时
CONTAINER_RUNTIME=$(detect_container_runtime)
if [ -z "${CONTAINER_RUNTIME}" ]; then
    echo "错误: 未找到可用的容器运行时（Docker 或 Podman）"
    echo "请确保已安装并运行 Docker 或 Podman"
    exit 1
fi

# 验证容器名称是否符合规范 [a-zA-Z0-9][a-zA-Z0-9_.-]*
validate_container_name() {
    local name="$1"
    # 检查是否符合容器命名规范：第一个字符必须是字母或数字，后续可以是字母、数字、下划线、点或连字符
    if echo "${name}" | grep -qE '^[a-zA-Z0-9][a-zA-Z0-9_.-]*$'; then
        return 0
    else
        return 1
    fi
}

# 生成容器名称：目录名-随机字符串
generate_container_name() {
    # 获取项目根目录的最后一个目录名
    local dir_name=$(basename "${PROJECT_ROOT}")
    local original_dir_name="${dir_name}"
    
    # 检查目录名是否只包含字母和数字
    if ! echo "${dir_name}" | grep -qE '^[a-zA-Z0-9]+$'; then
        # 如果目录名不是只包含字母或数字，则随机生成一个
        # 警告信息直接输出到 stderr，避免被命令替换捕获（此时 print_warn 可能还未定义）
        echo "⚠ 目录名称 '${original_dir_name}' 包含非字母数字字符，将使用随机生成的名称" >&2
        # 生成随机字符串（8位十六进制字符，确保只包含0-9a-f）
        local random_prefix=$(date +%s | sha256sum | head -c 8)
        dir_name="project${random_prefix}"
    else
        # 清理目录名（转换为小写）
        dir_name=$(echo "${dir_name}" | tr '[:upper:]' '[:lower:]')
    fi
    
    # 如果目录名为空，使用默认值
    if [ -z "${dir_name}" ]; then
        dir_name="project"
    fi
    
    # 确保目录名以字母或数字开头（符合容器命名规范）
    if ! echo "${dir_name}" | grep -qE '^[a-zA-Z0-9]'; then
        dir_name="p${dir_name}"
    fi
    
    # 生成随机字符串（8位十六进制字符）
    local random_str=$(date +%s | sha256sum | head -c 8)
    
    # 组合容器名称：目录名-ccdocker-随机字符串
    local container_name="${dir_name}-ccdocker-${random_str}"
    
    # 最终验证生成的容器名称是否符合规范
    if ! validate_container_name "${container_name}"; then
        # 如果不符合规范，使用完全随机的名称
        # 警告信息直接输出到 stderr，避免被命令替换捕获
        echo "⚠ 生成的容器名称不符合规范，使用完全随机生成的名称" >&2
        container_name="ccdocker-$(date +%s | sha256sum | head -c 12)"
    fi
    
    # 只输出容器名称到标准输出
    echo "${container_name}"
}

# 获取或生成容器名称
get_container_name() {
    # 如果配置文件存在，读取已保存的容器名称
    if [ -f "${CONTAINER_NAME_FILE}" ]; then
        local saved_name=$(cat "${CONTAINER_NAME_FILE}" 2>/dev/null | tr -d '[:space:]' | head -n 1)
        # 验证保存的名称是否符合容器命名规范
        if [ -n "${saved_name}" ] && validate_container_name "${saved_name}"; then
            # 检查容器是否存在（运行中或已停止）
            if ${CONTAINER_RUNTIME} ps -a --format '{{.Names}}' 2>/dev/null | grep -q "^${saved_name}$"; then
                echo "${saved_name}"
                return 0
            else
                # 容器不存在，删除旧配置文件，生成新的
                rm -f "${CONTAINER_NAME_FILE}"
            fi
        else
            # 保存的名称不符合规范，删除旧配置文件，生成新的
            # 注意：此时 print_warn 可能还未定义，直接输出到 stderr
            if [ -n "${saved_name}" ]; then
                echo "⚠ 保存的容器名称不符合规范，将重新生成" >&2
            fi
            rm -f "${CONTAINER_NAME_FILE}"
        fi
    fi
    
    # 生成新的容器名称并保存
    # 警告信息会输出到 stderr（不会被命令替换捕获），只有容器名称输出到 stdout
    local new_name=$(generate_container_name)
    
    # 清理可能的空白字符，并验证生成的名称
    new_name=$(echo "${new_name}" | tr -d '[:space:]')
    
    # 再次验证生成的名称是否符合规范
    if [ -z "${new_name}" ] || ! validate_container_name "${new_name}"; then
        # 如果仍然不符合规范，使用完全随机的名称
        echo "⚠ 生成的容器名称验证失败，使用完全随机生成的名称" >&2
        new_name="ccdocker-$(date +%s | sha256sum | head -c 12)"
    fi
    
    # 保存容器名称（只保存名称，不包含任何其他内容）
    echo "${new_name}" > "${CONTAINER_NAME_FILE}"
    echo "${new_name}"
}

# 初始化容器名称
CONTAINER_NAME=$(get_container_name)

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
MAGENTA='\033[0;35m'
BOLD='\033[1m'
NC='\033[0m' # No Color

# 打印带颜色的消息
print_info() {
    echo -e "${GREEN}✓${NC} ${GREEN}$1${NC}"
}

print_warn() {
    echo -e "${YELLOW}⚠${NC} ${YELLOW}$1${NC}"
}

print_error() {
    echo -e "${RED}✗${NC} ${RED}$1${NC}"
}

print_success() {
    echo -e "${GREEN}✓${NC} ${BOLD}${GREEN}$1${NC}"
}

print_title() {
    echo -e "${BOLD}${CYAN}$1${NC}"
}

print_header() {
    echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${BOLD}${BLUE}  $1${NC}"
    echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
}

print_separator() {
    echo -e "${CYAN}────────────────────────────────────────────${NC}"
}

# 打印对齐的配置行（处理颜色码对齐）
print_aligned_row() {
    local label="$1"
    local value="$2"
    local label_width=16  # 减少标签宽度，使布局更紧凑
    local value_start_col=18  # 值从第18列开始：16字符标签区域 + 1空格 + 1
    
    # 计算标签的纯文本长度（去除颜色码）
    local label_plain=$(echo -e "$label" | sed 's/\x1b\[[0-9;]*m//g')
    local label_len=${#label_plain}
    
    # 如果标签长度超过限制，截断
    if [ $label_len -gt $label_width ]; then
        label_len=$label_width
        label_plain=$(echo "$label_plain" | cut -c1-$label_width)
        # 重新构建标签（保留颜色，截断文本）
        label="${CYAN}${label_plain}${NC}"
    fi
    
    local label_padding=$((label_width - label_len))
    
    # 使用 printf 分别输出标签和值，确保值从固定列开始
    # 从最左边开始，无前导空格（与横线对齐）
    # 先输出标签部分（标签 + 填充）
    printf "%b%*s" "${label}" "${label_padding}" ""
    
    # 输出值（从固定列开始，带颜色，前面加1个空格分隔，更紧凑）
    printf " %b\n" "${value}"
}

# 显示配置信息表格（分隔线样式）
show_config_table() {
    print_title "当前配置"
    echo ""
    echo -e "${CYAN}────────────────────────────────────────────────────────────────${NC}"
    print_aligned_row "${CYAN}项目目录:${NC}" "${PROJECT_ROOT}"
    print_aligned_row "${CYAN}项目名称:${NC}" "$(basename ${PROJECT_ROOT})"
    print_aligned_row "${CYAN}容器名称:${NC}" "${CONTAINER_NAME}"
    print_aligned_row "${CYAN}镜像名称:${NC}" "${IMAGE_NAME}"
    
    # 显示容器运行时，带状态指示
    local runtime_display="${CONTAINER_RUNTIME}"
    if [ "${CONTAINER_RUNTIME}" = "docker" ]; then
        runtime_display="${GREEN}docker${NC}"
    elif [ "${CONTAINER_RUNTIME}" = "podman" ]; then
        runtime_display="${BLUE}podman${NC}"
    fi
    print_aligned_row "${CYAN}容器运行时:${NC}" "${runtime_display}"
    
    print_aligned_row "${CYAN}配置目录:${NC}" "${DOCKER_CONFIG_DIR}"
    
    # 显示环境变量文件状态
    local env_status=""
    if [ -f "${DOCKER_ENV_FILE}" ]; then
        env_status="${GREEN}✓ .docker/env${NC}"
    else
        env_status="${YELLOW}无${NC}"
    fi
    print_aligned_row "${CYAN}环境变量:${NC}" "${env_status}"
    echo -e "${CYAN}────────────────────────────────────────────────────────────────${NC}"
    echo ""
}

# 显示系统状态表格（分隔线样式）
show_status_table() {
    print_title "系统状态"
    echo ""
    echo -e "${CYAN}────────────────────────────────────────────────────────────────${NC}"
    
    # 获取容器状态
    local container_name=$(get_container_name)
    local status_text=""
    local status_color=""
    
    if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${container_name}"; then
        status_text="运行中"
        status_color="${GREEN}"
    elif ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${container_name}"; then
        status_text="已停止"
        status_color="${YELLOW}"
    else
        status_text="不存在"
        status_color="${RED}"
    fi
    
    print_aligned_row "${CYAN}容器状态:${NC}" "${status_color}${status_text}${NC}"
    
    # 显示容器运行时状态
    local runtime_status=""
    if ${CONTAINER_RUNTIME} info > /dev/null 2>&1; then
        runtime_status="${GREEN}运行中${NC}"
    else
        runtime_status="${RED}未运行${NC}"
    fi
    print_aligned_row "${CYAN}${CONTAINER_RUNTIME}服务:${NC}"  "${runtime_status}"
    
    # 显示容器详细信息（如果容器存在）
    if ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${container_name}"; then
        local container_id=$(${CONTAINER_RUNTIME} inspect -f '{{.Id}}' ${container_name} 2>/dev/null | cut -c1-12)
        if [ -n "${container_id}" ]; then
            print_aligned_row "${CYAN}容器ID:${NC}" "${container_id}"
        fi
        
        local created_time=$(${CONTAINER_RUNTIME} inspect -f '{{.Created}}' ${container_name} 2>/dev/null | cut -d'T' -f1)
        if [ -n "${created_time}" ]; then
            print_aligned_row "${CYAN}创建时间:${NC}" "${created_time}"
        fi
    fi
    
    echo -e "${CYAN}────────────────────────────────────────────────────────────────${NC}"
    echo ""
}

# 获取容器状态（用于显示）
get_container_status() {
    # 重新获取容器名称
    local container_name=$(get_container_name)
    
    if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${container_name}"; then
        echo -e "${GREEN}运行中${NC}"
        return 0
    elif ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${container_name}"; then
        echo -e "${YELLOW}已停止${NC}"
        return 1
    else
        echo -e "${RED}不存在${NC}"
        return 2
    fi
}

# 检查容器运行时是否运行
check_container_runtime() {
    if ! ${CONTAINER_RUNTIME} info > /dev/null 2>&1; then
        print_error "${CONTAINER_RUNTIME} 未运行，请先启动 ${CONTAINER_RUNTIME} 服务"
        exit 1
    fi
}

# 检查镜像是否存在
check_image() {
    if ! ${CONTAINER_RUNTIME} images "${IMAGE_NAME}" 2>/dev/null | grep -q "${IMAGE_NAME%:*}"; then
        print_warn "镜像 ${IMAGE_NAME} 不存在，开始构建..."
        if [ ! -f "${PROJECT_ROOT}/Dockerfile" ]; then
            print_error "未找到 Dockerfile: ${PROJECT_ROOT}/Dockerfile"
            print_error "请确保在包含 Dockerfile 的目录中运行此脚本"
            exit 1
        fi
        ${CONTAINER_RUNTIME} build -t "${IMAGE_NAME}" -f "${PROJECT_ROOT}/Dockerfile" "${PROJECT_ROOT}"
        print_info "镜像构建完成"
    fi
}

# 检查是否需要初始化
check_init_needed() {
    if [ ! -f "${DOCKER_ENV_FILE}" ]; then
        return 0  # 需要初始化
    fi
    return 1  # 不需要初始化
}

# 初始化环境变量文件
init_env_files() {
    echo ""
    print_separator
    print_title "初始化环境变量配置"
    echo ""
    
    # 检查是否已存在文件
    if [ -f "${DOCKER_ENV_FILE}" ]; then
        print_warn "容器环境变量文件已存在: ${DOCKER_ENV_FILE}"
        print_info "环境变量文件已存在，无需初始化"
        return 0
    fi
    
    echo ""
    print_info "将创建以下环境变量文件："
    echo "  - ${DOCKER_ENV_FILE} (容器专用环境变量)"
    echo ""
    
    # 创建容器专用 .docker/env 文件
    cat > "${DOCKER_ENV_FILE}" << 'EOF'
# 容器专用环境变量配置

# 示例配置（请根据实际需求修改）
# DATABASE_URL=postgresql://host.docker.internal:5432/mydb
# CONTAINER_SPECIFIC_VAR=value

# Claude Code 相关配置（示例）
# ANTHROPIC_BASE_URL=http://localhost:4000/anthropic
# ANTHROPIC_AUTH_TOKEN=your-anthropic-api-key
# ANTHROPIC_MODEL=glm-4.7
# ANTHROPIC_DEFAULT_OPUS_MODEL=glm-4.7
# ANTHROPIC_DEFAULT_SONNET_MODEL=glm-4.7
EOF
    print_success "已创建容器环境变量文件: ${DOCKER_ENV_FILE}"
    
    echo ""
    print_separator
    print_success "初始化完成！"
    echo ""
    print_info "提示:"
    echo "  - 编辑 ${DOCKER_ENV_FILE} 配置容器专用环境变量"
    echo ""
    print_separator
}

# 加载环境变量
# 从 .docker/env 文件加载容器专用环境变量
load_env_variables() {
    local env_args=""
    local env_files=()
    
    # 加载容器专用的 .docker/env（如果存在）
    if [ -f "${DOCKER_ENV_FILE}" ]; then
        env_files+=("${DOCKER_ENV_FILE}")
    fi
    
    # 读取所有环境变量文件
    for env_file in "${env_files[@]}"; do
        if [ -f "${env_file}" ]; then
            while IFS='=' read -r key value || [ -n "$key" ]; do
                # 跳过注释和空行
                [[ "$key" =~ ^#.*$ ]] && continue
                [[ -z "$key" ]] && continue
                # 移除首尾空格
                key=$(echo "$key" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
                value=$(echo "$value" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
                # 移除引号
                value=$(echo "$value" | sed -e 's/^"//' -e 's/"$//' -e "s/^'//" -e "s/'$//")
                # 添加到环境变量参数（后面的会覆盖前面的同名变量）
                env_args="${env_args} -e ${key}=${value}"
            done < "${env_file}"
        fi
    done
    
    echo "${env_args}"
}

# 创建并启动容器
create_container() {
    # 确保使用最新的容器名称
    CONTAINER_NAME=$(get_container_name)
    
    # 验证项目根目录是否存在
    if [ ! -d "${PROJECT_ROOT}" ]; then
        print_error "项目目录不存在: ${PROJECT_ROOT}"
        print_error "请确保目录存在后再创建容器"
        exit 1
    fi
    
    # 验证项目根目录是否可读
    if [ ! -r "${PROJECT_ROOT}" ]; then
        print_error "项目目录不可读: ${PROJECT_ROOT}"
        print_error "请检查目录权限"
        exit 1
    fi
    
    print_info "创建容器 ${CONTAINER_NAME}..."
    print_info "容器名称基于目录: $(basename ${PROJECT_ROOT})"
    print_info "挂载目录: ${PROJECT_ROOT} -> ${WORKSPACE_DIR}"
    
    # 加载环境变量
    ENV_ARGS=$(load_env_variables)
    
    if [ -n "${ENV_ARGS}" ]; then
        local env_count=$(echo "${ENV_ARGS}" | grep -o '\-e' | wc -l)
        print_info "已加载 ${env_count} 个环境变量"
        if [ -f "${DOCKER_ENV_FILE}" ]; then
            print_info "  - 从 ${DOCKER_ENV_FILE} 加载"
        fi
    else
        print_warn "未检测到环境变量文件"
        if check_init_needed; then
            echo ""
            echo -ne "${YELLOW}是否要初始化环境变量配置文件? ${CYAN}(y/N)${NC}: "
            read -r init_choice
            if [[ "$init_choice" =~ ^[Yy]$ ]]; then
                init_env_files
                # 重新加载环境变量
                ENV_ARGS=$(load_env_variables)
                if [ -n "${ENV_ARGS}" ]; then
                    local env_count=$(echo "${ENV_ARGS}" | grep -o '\-e' | wc -l)
                    print_info "已加载 ${env_count} 个环境变量"
                fi
            else
                print_info "提示: 可以运行 '$0 init' 或创建 ${DOCKER_ENV_FILE} 来配置环境变量"
            fi
        else
            print_info "提示: 可以创建 ${DOCKER_ENV_FILE} 来配置环境变量"
        fi
    fi
    
    # 创建容器
    if ! ${CONTAINER_RUNTIME} run -d \
        --name "${CONTAINER_NAME}" \
        --hostname "${CONTAINER_NAME}" \
        -v "${PROJECT_ROOT}:${WORKSPACE_DIR}" \
        -w "${WORKSPACE_DIR}" \
        --network host \
        ${ENV_ARGS} \
        -it \
        "${IMAGE_NAME}" \
        /bin/bash 2>&1; then
        print_error "容器创建失败"
        print_error "请检查："
        print_error "  1. 挂载目录是否存在: ${PROJECT_ROOT}"
        print_error "  2. 目录权限是否正确"
        print_error "  3. 镜像是否存在: ${IMAGE_NAME}"
        print_error "  4. ${CONTAINER_RUNTIME} 服务是否正常运行"
        exit 1
    fi
    
    # 等待容器完全启动
    sleep 1
    
    # 配置 Git safe.directory
    configure_git_safe_directory
    
    print_success "容器 ${CONTAINER_NAME} 创建并启动成功"
    print_info "容器名称已保存到: ${CONTAINER_NAME_FILE}"
    print_info "容器配置目录: ${DOCKER_CONFIG_DIR}"
}

# 启动已存在的容器
start_container() {
    # 重新获取容器名称
    CONTAINER_NAME=$(get_container_name)
    
    print_info "启动容器 ${CONTAINER_NAME}..."
    ${CONTAINER_RUNTIME} start "${CONTAINER_NAME}" > /dev/null
    print_success "容器 ${CONTAINER_NAME} 已启动"
}

# 停止容器
stop_container() {
    # 重新获取容器名称
    CONTAINER_NAME=$(get_container_name)
    
    print_info "停止容器 ${CONTAINER_NAME}..."
    ${CONTAINER_RUNTIME} stop "${CONTAINER_NAME}" > /dev/null
    print_success "容器 ${CONTAINER_NAME} 已停止"
}

# 删除容器
remove_container() {
    # 重新获取容器名称
    CONTAINER_NAME=$(get_container_name)
    
    print_info "删除容器 ${CONTAINER_NAME}..."
    ${CONTAINER_RUNTIME} rm -f "${CONTAINER_NAME}" > /dev/null 2>&1
    # 删除容器名称配置文件（但保留 .docker 目录和其他配置）
    rm -f "${CONTAINER_NAME_FILE}"
    print_success "容器 ${CONTAINER_NAME} 已删除"
    print_info "容器名称配置文件已清除"
    print_info "提示: 容器配置目录 ${DOCKER_CONFIG_DIR} 已保留，可手动删除"
}

# 配置 Git safe.directory（如果尚未配置）
# 解决 Git 2.35.2+ 的安全特性：当目录所有者与当前用户不匹配时拒绝操作
configure_git_safe_directory() {
    # 检查容器是否运行
    if ! ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
        return 0
    fi
    
    # 检查是否已配置（检查当前用户，通常是 developer）
    if ! ${CONTAINER_RUNTIME} exec "${CONTAINER_NAME}" git config --global --get-all safe.directory 2>/dev/null | grep -q "^${WORKSPACE_DIR}$"; then
        print_info "配置 Git safe.directory for ${WORKSPACE_DIR}..."
        # 尝试配置（可能以 root 或 developer 用户运行）
        ${CONTAINER_RUNTIME} exec "${CONTAINER_NAME}" git config --global --add safe.directory "${WORKSPACE_DIR}" 2>/dev/null || \
        ${CONTAINER_RUNTIME} exec -u developer "${CONTAINER_NAME}" git config --global --add safe.directory "${WORKSPACE_DIR}" 2>/dev/null || true
    fi
}

# 进入容器
enter_container() {
    if ! ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
        if ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
            print_info "容器已停止，正在启动..."
            start_container
        else
            print_info "容器不存在，正在创建..."
            check_image
            create_container
        fi
    fi
    
    # 配置 Git safe.directory
    configure_git_safe_directory
    
    echo ""
    print_separator
    print_success "正在进入容器: ${CONTAINER_NAME}"
    echo -e "  ${CYAN}工作目录:${NC} ${WORKSPACE_DIR}"
    echo -e "  ${CYAN}提示:${NC} 使用 'exit' 退出容器"
    print_separator
    echo ""
    
    ${CONTAINER_RUNTIME} exec -it "${CONTAINER_NAME}" /bin/bash
}

# 在容器中执行命令
exec_in_container() {
    # 重新获取容器名称
    CONTAINER_NAME=$(get_container_name)
    
    if ! ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
        if ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
            start_container
        else
            print_error "容器 ${CONTAINER_NAME} 不存在，请先运行 '$0' 创建容器"
            exit 1
        fi
    fi
    
    # 配置 Git safe.directory（如果需要）
    configure_git_safe_directory
    
    print_info "在容器中执行命令: $1"
    ${CONTAINER_RUNTIME} exec -it "${CONTAINER_NAME}" /bin/bash -c "cd ${WORKSPACE_DIR} && $1"
}

# 显示容器状态
show_status() {
    # 重新获取容器名称
    CONTAINER_NAME=$(get_container_name)
    
    echo ""
    print_title "容器状态详情"
    echo ""
    echo -e "${CYAN}────────────────────────────────────────────────────────────────${NC}"
    
    if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
        print_aligned_row "${CYAN}容器名称:${NC}" "${CONTAINER_NAME}"
        print_aligned_row "${CYAN}状态:${NC}" "${GREEN}运行中${NC}"
        
        local container_id=$(${CONTAINER_RUNTIME} inspect -f '{{.Id}}' ${CONTAINER_NAME} 2>/dev/null | cut -c1-12)
        if [ -n "${container_id}" ]; then
            print_aligned_row "${CYAN}容器ID:${NC}" "${container_id}"
        fi
        
        local image=$(${CONTAINER_RUNTIME} inspect -f '{{.Config.Image}}' ${CONTAINER_NAME} 2>/dev/null)
        if [ -n "${image}" ]; then
            print_aligned_row "${CYAN}镜像:${NC}" "${image}"
        fi
        
        local created=$(${CONTAINER_RUNTIME} inspect -f '{{.Created}}' ${CONTAINER_NAME} 2>/dev/null)
        if [ -n "${created}" ]; then
            print_aligned_row "${CYAN}创建时间:${NC}" "${created}"
        fi
        
        local mounts=$(${CONTAINER_RUNTIME} inspect -f '{{range .Mounts}}{{.Source}} -> {{.Destination}} {{end}}' ${CONTAINER_NAME} 2>/dev/null)
        if [ -n "${mounts}" ]; then
            print_aligned_row "${CYAN}挂载点:${NC}" "${mounts}"
        fi
        
        local status=$(${CONTAINER_RUNTIME} ps --format "{{.Status}}" -f name=${CONTAINER_NAME} 2>/dev/null | head -1)
        if [ -n "${status}" ]; then
            print_aligned_row "${CYAN}运行状态:${NC}" "${status}"
        fi
        
        echo -e "${CYAN}────────────────────────────────────────────────────────────────${NC}"
        echo ""
        
        # 显示容器列表
        echo ""
        print_title "容器列表"
        ${CONTAINER_RUNTIME} ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" 2>/dev/null | grep -E "NAMES|${CONTAINER_NAME}"
        
    elif ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
        print_aligned_row "${CYAN}容器名称:${NC}" "${CONTAINER_NAME}"
        print_aligned_row "${CYAN}状态:${NC}" "${YELLOW}已停止${NC}"
        
        local created_at=$(${CONTAINER_RUNTIME} ps -a --format "{{.CreatedAt}}" -f name=${CONTAINER_NAME} 2>/dev/null | head -1)
        if [ -n "${created_at}" ]; then
            print_aligned_row "${CYAN}创建时间:${NC}" "${created_at}"
        fi
        
        echo -e "${CYAN}────────────────────────────────────────────────────────────────${NC}"
        echo ""
        
        # 显示容器列表
        echo ""
        print_title "容器列表"
        ${CONTAINER_RUNTIME} ps -a --format "table {{.Names}}\t{{.Status}}\t{{.CreatedAt}}" 2>/dev/null | grep -E "NAMES|${CONTAINER_NAME}"
    else
        print_aligned_row "${CYAN}容器名称:${NC}" "${CONTAINER_NAME}"
        print_aligned_row "${CYAN}状态:${NC}" "${RED}不存在${NC}"
        echo -e "${CYAN}────────────────────────────────────────────────────────────────${NC}"
        echo ""
        print_info "使用选项 3 或执行 '$0 start' 创建容器"
    fi
    echo ""
}

# 显示帮助信息
show_help() {
    cat << EOF
ccdocker - AICoding开发管理工具

用法:
    $0 [命令]

命令:
    (无参数)      打开交互式菜单（默认）
    exec <命令>   在容器中执行命令
    start         启动已存在的容器
    stop          停止容器
    restart       重启容器
    status        显示容器状态
    clean         删除容器
    build         重新构建镜像
    interactive   交互式菜单
    enter         直接进入容器（如果已运行）
    init          初始化环境变量配置文件
    help          显示此帮助信息

示例:
    $0                    # 打开交互式菜单
    $0 interactive        # 打开交互式菜单
    $0 exec "claude --version"  # 在容器中执行命令
    $0 start              # 启动容器
    $0 stop               # 停止容器
    $0 clean              # 删除容器

当前配置:
    项目目录: ${PROJECT_ROOT}
    容器名称: ${CONTAINER_NAME}
    镜像名称: ${IMAGE_NAME}
    容器运行时: ${CONTAINER_RUNTIME}
    配置目录: ${DOCKER_CONFIG_DIR}

环境变量配置:
    ${DOCKER_ENV_FILE} (容器专用环境变量)

EOF
}

# 交互式菜单
show_interactive_menu() {
    while true; do
        # 每次循环都重新获取容器名称（确保是最新的）
        CONTAINER_NAME=$(get_container_name)
        
        clear
        print_header "AICoding 开发环境管理"
        echo ""
        
        # 显示配置信息表格
        show_config_table
        
        # 显示系统状态表格
        show_status_table
        
        print_separator
        echo ""
        print_title "操作菜单"
        echo ""
        echo -e "  ${GREEN}1)${NC} 启动并进入容器"
        echo -e "  ${BLUE}2)${NC} 查看容器状态详情"
        echo -e "  ${GREEN}3)${NC} 启动容器"
        echo -e "  ${YELLOW}4)${NC} 停止容器"
        echo -e "  ${CYAN}5)${NC} 重启容器"
        echo -e "  ${MAGENTA}6)${NC} 在容器中执行命令"
        echo -e "  ${BLUE}7)${NC} 构建/重建镜像"
        echo -e "  ${RED}8)${NC} 删除容器"
        echo -e "  ${CYAN}9)${NC} 查看容器日志"
        echo -e "  ${GREEN}i)${NC} 初始化环境变量配置"
        echo -e "  ${YELLOW}h)${NC} 显示帮助信息"
        echo -e "  ${RED}0)${NC} 退出"
        echo ""
        print_separator
        echo ""
        echo -ne "${BOLD}请选择操作 ${CYAN}[0-9/i/h]${NC}: "
        read -r choice
        
        case "$choice" in
            1)
                echo ""
                print_separator
                enter_container
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            2)
                echo ""
                print_separator
                show_status
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            3)
                echo ""
                print_separator
                CONTAINER_NAME=$(get_container_name)
                if ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                    start_container
                else
                    print_warn "容器不存在，将创建新容器..."
                    check_image
                    create_container
                fi
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            4)
                echo ""
                print_separator
                CONTAINER_NAME=$(get_container_name)
                if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                    stop_container
                else
                    print_warn "容器未运行"
                fi
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            5)
                echo ""
                print_separator
                CONTAINER_NAME=$(get_container_name)
                if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                    stop_container
                fi
                if ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                    start_container
                else
                    check_image
                    create_container
                fi
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            6)
                echo ""
                print_separator
                echo -ne "${CYAN}请输入要执行的命令: ${NC}"
                read -r cmd
                if [ -n "$cmd" ]; then
                    echo ""
                    exec_in_container "$cmd"
                else
                    print_warn "命令为空"
                fi
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            7)
                echo ""
                print_separator
                print_info "开始构建镜像..."
                echo ""
                ${CONTAINER_RUNTIME} build -t "${IMAGE_NAME}" -f "${PROJECT_ROOT}/Dockerfile" "${PROJECT_ROOT}"
                echo ""
                print_success "镜像构建完成"
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            8)
                echo ""
                print_separator
                CONTAINER_NAME=$(get_container_name)
                echo -ne "${RED}⚠ 确定要删除容器 ${CONTAINER_NAME} 吗? ${YELLOW}(y/N)${NC}: "
                read -r confirm
                if [[ "$confirm" =~ ^[Yy]$ ]]; then
                    if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                        stop_container
                    fi
                    remove_container
                    print_success "容器已删除"
                else
                    print_info "操作已取消"
                fi
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            9)
                echo ""
                print_separator
                CONTAINER_NAME=$(get_container_name)
                if ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                    echo ""
                    ${CONTAINER_RUNTIME} logs --tail 50 "${CONTAINER_NAME}"
                else
                    print_warn "容器不存在"
                fi
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            i|I|init|Init)
                echo ""
                print_separator
                init_env_files
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            h|H|help|Help)
                echo ""
                print_separator
                show_help
                echo ""
                print_separator
                echo ""
                echo -ne "${CYAN}按 Enter 键返回菜单...${NC}"
                read -r
                ;;
            0|q|Q|quit|Quit)
                echo ""
                print_separator
                print_info "感谢使用，再见！"
                echo ""
                print_separator
                sleep 1
                exit 0
                ;;
            *)
                print_error "无效选项: $choice，请重新选择"
                sleep 1.5
                ;;
        esac
    done
}

# 主逻辑
main() {
    check_container_runtime
    
    # 检查Dockerfile是否存在（仅在需要构建时显示警告）
    if [ "$1" = "build" ] || [ "$1" = "" ]; then
        if [ ! -f "${PROJECT_ROOT}/Dockerfile" ]; then
            print_warn "在 ${PROJECT_ROOT} 中未找到 Dockerfile"
            print_info "构建镜像时可能会失败"
        fi
    fi
    
    case "${1:-}" in
        "exec")
            if [ -z "${2:-}" ]; then
                print_error "请提供要执行的命令"
                exit 1
            fi
            exec_in_container "${2}"
            ;;
        "start")
            CONTAINER_NAME=$(get_container_name)
            if ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                start_container
            else
                print_error "容器 ${CONTAINER_NAME} 不存在"
                exit 1
            fi
            ;;
        "stop")
            CONTAINER_NAME=$(get_container_name)
            if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                stop_container
            else
                print_warn "容器 ${CONTAINER_NAME} 未运行"
            fi
            ;;
        "restart")
            CONTAINER_NAME=$(get_container_name)
            if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                stop_container
            fi
            if ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                start_container
            else
                check_image
                create_container
            fi
            ;;
        "status")
            show_status
            ;;
        "clean")
            CONTAINER_NAME=$(get_container_name)
            if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                stop_container
            fi
            remove_container
            ;;
        "build")
            print_info "重新构建镜像 ${IMAGE_NAME}..."
            ${CONTAINER_RUNTIME} build -t "${IMAGE_NAME}" -f "${PROJECT_ROOT}/Dockerfile" "${PROJECT_ROOT}"
            print_success "镜像构建完成"
            ;;
        "interactive"|"menu")
            show_interactive_menu
            ;;
        "init")
            init_env_files
            ;;
        "enter")
            # 直接进入容器（如果已运行）
            CONTAINER_NAME=$(get_container_name)
            if ${CONTAINER_RUNTIME} ps 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                enter_container
            elif ${CONTAINER_RUNTIME} ps -a 2>/dev/null | grep -q "${CONTAINER_NAME}"; then
                print_warn "容器已停止，正在启动..."
                start_container
                enter_container
            else
                print_error "容器不存在，请先创建容器"
                print_info "使用 '$0 start' 或交互式菜单创建容器"
                exit 1
            fi
            ;;
        "help"|"-h"|"--help")
            show_help
            ;;
        "")
            # 无参数时，默认显示交互式菜单（用户必须选择才能启动容器）
            if [ -t 0 ] && [ -t 1 ]; then
                # 检查是否需要初始化
                if check_init_needed; then
                    echo ""
                    print_separator
                    print_warn "检测到新项目，未找到环境变量配置文件"
                    echo ""
                    print_info "建议先初始化环境变量配置"
                    echo ""
                    echo -ne "${YELLOW}是否要初始化环境变量配置文件? ${CYAN}(Y/n)${NC}: "
                    read -r init_choice
                    if [[ ! "$init_choice" =~ ^[Nn]$ ]]; then
                        init_env_files
                        echo ""
                        echo -ne "${CYAN}按 Enter 键继续进入菜单...${NC}"
                        read -r
                    fi
                fi
                # 在交互式终端中，直接显示菜单
                show_interactive_menu
            else
                # 非交互式终端，显示帮助信息
                print_warn "检测到非交互式终端"
                print_info "请使用以下命令之一："
                echo "  $0 interactive  - 打开交互式菜单"
                echo "  $0 start        - 启动容器"
                echo "  $0 enter         - 进入容器"
                echo "  $0 help         - 显示帮助"
                exit 1
            fi
            ;;
        *)
            print_error "未知命令: $1"
            show_help
            exit 1
            ;;
    esac
}

# 运行主函数
main "$@"