name: 测试 Setup Environment Action

on:
  workflow_dispatch:
    inputs:
      test_scope:
        description: '选择测试范围'
        required: true
        default: 'basic'
        type: choice
        options:
          - basic
          - docker-only
          - kubectl-only
          - full
          - debug
      use_aliyun_mirror:
        description: '使用阿里云镜像源'
        required: false
        default: true
        type: boolean
      test_kubectl:
        description: '测试 kubectl 功能'
        required: false
        default: false
        type: boolean

env:
  TEST_REGISTRY: docker-registry.bjxgj.com
  TEST_IMAGE: test-setup-env

jobs:
  # 基础测试 - 最小配置
  test-basic:
    if: ${{ inputs.test_scope == 'basic' || inputs.test_scope == 'full' }}
    runs-on: ubuntu-node-20
    steps:
      - name: 检出代码
        uses: actions/checkout@v4

      - name: 基础环境配置测试
        id: setup-basic
        uses: actions/xgj/setup-env@v1
        with:
          docker-password: ${{ secrets.DOCKER_PASSWORD }}
          use-aliyun-mirror: ${{ inputs.use_aliyun_mirror }}
          cache-key: 'test-basic-${{ github.run_id }}'

      - name: 验证基础配置
        run: |
          echo "🔍 验证基础配置结果..."
          echo "缓存命中: ${{ steps.setup-basic.outputs.cache-hit }}"
          echo "Docker 版本: ${{ steps.setup-basic.outputs.docker-version }}"
          echo "kubectl 版本: ${{ steps.setup-basic.outputs.kubectl-version }}"
          
          # 验证 Docker 是否可用
          if command -v docker &> /dev/null; then
            echo "✅ Docker 已安装: $(docker --version)"
            docker info | head -10
          else
            echo "❌ Docker 未安装"
            exit 1
          fi
          
          # 验证 Git 配置
          echo "Git 用户: $(git config --global user.name)"
          echo "Git 邮箱: $(git config --global user.email)"

      - name: 测试 Docker 功能
        run: |
          echo "🐳 测试 Docker 功能..."
          
          # 创建测试 Dockerfile
          cat > Dockerfile.test << 'EOF'
          FROM alpine:latest
          RUN echo "Setup Environment Action Test" > /test.txt
          CMD cat /test.txt
          EOF
          
          # 构建测试镜像
          docker build -f Dockerfile.test -t ${{ env.TEST_IMAGE }}:test .
          
          # 运行测试容器
          docker run --rm ${{ env.TEST_IMAGE }}:test
          
          echo "✅ Docker 功能测试通过"

  # Docker 专项测试
  test-docker-only:
    if: ${{ inputs.test_scope == 'docker-only' || inputs.test_scope == 'full' }}
    runs-on: ubuntu-node-20
    steps:
      - name: 检出代码
        uses: actions/checkout@v4

      - name: Docker 专项配置
        id: setup-docker
        uses: actions/xgj/setup-env@v1
        with:
          docker-password: ${{ secrets.DOCKER_PASSWORD }}
          skip-kubectl: 'true'
          use-aliyun-mirror: ${{ inputs.use_aliyun_mirror }}
          cache-key: 'test-docker-${{ github.run_id }}'

      - name: 验证 Docker 专项配置
        run: |
          echo "🐳 验证 Docker 专项配置..."
          
          # 检查 kubectl 是否被跳过
          if command -v kubectl &> /dev/null; then
            echo "⚠️ kubectl 应该被跳过但仍然存在"
          else
            echo "✅ kubectl 正确跳过"
          fi
          
          # 验证 Docker 功能
          docker version
          docker info | grep -E "(Server Version|Storage Driver|Logging Driver)"

      - name: 测试 Docker Buildx 功能
        run: |
          echo "🔧 测试 Docker Buildx 功能..."
          docker buildx version
          docker buildx ls
          
          # 创建多平台构建测试
          cat > Dockerfile.multiarch << 'EOF'
          FROM --platform=$TARGETPLATFORM alpine:latest
          RUN echo "Platform: $TARGETPLATFORM" > /platform.txt
          CMD cat /platform.txt
          EOF
          
          docker buildx build \
            --platform linux/amd64 \
            -f Dockerfile.multiarch \
            -t ${{ env.TEST_IMAGE }}:multiarch \
            --load \
            .
          
          docker run --rm ${{ env.TEST_IMAGE }}:multiarch
          echo "✅ Docker Buildx 测试通过"

  # kubectl 专项测试
  test-kubectl-only:
    if: ${{ (inputs.test_scope == 'kubectl-only' || inputs.test_scope == 'full') && inputs.test_kubectl }}
    runs-on: ubuntu-node-20
    steps:
      - name: 检出代码
        uses: actions/checkout@v4

      - name: kubectl 专项配置
        id: setup-kubectl
        uses: actions/xgj/setup-env@v1
        with:
          kube-config: ${{ secrets.KUBE_CONFIG }}
          skip-docker-login: 'true'
          use-aliyun-mirror: ${{ inputs.use_aliyun_mirror }}
          cache-key: 'test-kubectl-${{ github.run_id }}'

      - name: 验证 kubectl 配置
        run: |
          echo "☸️ 验证 kubectl 配置..."
          
          if command -v kubectl &> /dev/null; then
            echo "✅ kubectl 已安装: $(kubectl version --client --short 2>/dev/null || kubectl version --client)"
            
            # 验证配置文件
            if [[ -f ~/.kube/config ]]; then
              echo "✅ kubectl 配置文件存在"
              kubectl config view --minify
            else
              echo "❌ kubectl 配置文件不存在"
              exit 1
            fi
            
            # 测试集群连接（如果配置了）
            if [[ -n "${{ secrets.KUBE_CONFIG }}" ]]; then
              echo "测试集群连接..."
              kubectl cluster-info --request-timeout=10s || echo "⚠️ 集群连接失败或无权限"
            fi
          else
            echo "❌ kubectl 未安装"
            exit 1
          fi

  # 调试模式测试
  test-debug:
    if: ${{ inputs.test_scope == 'debug' || inputs.test_scope == 'full' }}
    runs-on: ubuntu-node-20
    steps:
      - name: 检出代码
        uses: actions/checkout@v4

      - name: 调试模式配置
        id: setup-debug
        uses: actions/xgj/setup-env@v1
        with:
          docker-password: ${{ secrets.DOCKER_PASSWORD }}
          kube-config: ${{ secrets.KUBE_CONFIG }}
          use-aliyun-mirror: ${{ inputs.use_aliyun_mirror }}
          cache-key: 'test-debug-${{ github.run_id }}'
        env:
          ACTIONS_STEP_DEBUG: true
          ACTIONS_RUNNER_DEBUG: true

      - name: 系统信息收集
        run: |
          echo "🔍 收集系统信息..."
          
          echo "=== 系统基本信息 ==="
          uname -a
          cat /etc/os-release
          
          echo -e "\n=== 已安装工具版本 ==="
          echo "Docker: ${{ steps.setup-debug.outputs.docker-version }}"
          echo "kubectl: ${{ steps.setup-debug.outputs.kubectl-version }}"
          echo "Git: $(git --version)"
          echo "Curl: $(curl --version | head -1)"
          echo "GPG: $(gpg --version | head -1)"
          
          echo -e "\n=== 缓存信息 ==="
          echo "Cache Hit: ${{ steps.setup-debug.outputs.cache-hit }}"
          
          echo -e "\n=== 网络测试 ==="
          echo "测试外部连接..."
          curl -I https://github.com --connect-timeout 5 || echo "GitHub 连接失败"
          curl -I https://mirrors.aliyun.com --connect-timeout 5 || echo "阿里云连接失败"
          curl -I ${{ env.TEST_REGISTRY }}/v2/ --connect-timeout 5 || echo "私有仓库连接失败"

      - name: 环境压力测试
        run: |
          echo "🏋️ 环境压力测试..."
          
          # 并发 Docker 操作测试
          for i in {1..3}; do
            (
              echo "启动并发任务 $i..."
              docker run --rm alpine:latest echo "任务 $i 完成"
            ) &
          done
          wait
          echo "✅ 并发测试完成"
          
          # 磁盘空间检查
          echo -e "\n💾 磁盘空间:"
          df -h /
          
          # 内存使用检查
          echo -e "\n🧠 内存使用:"
          free -h

  # 缓存测试
  test-cache:
    if: ${{ inputs.test_scope == 'full' }}
    runs-on: ubuntu-node-20
    strategy:
      matrix:
        cache_test: [first-run, second-run]
    steps:
      - name: 检出代码
        uses: actions/checkout@v4

      - name: 缓存测试 - ${{ matrix.cache_test }}
        id: setup-cache
        uses: actions/xgj/setup-env@v1
        with:
          docker-password: ${{ secrets.DOCKER_PASSWORD }}
          cache-key: 'test-cache-shared'
          use-aliyun-mirror: ${{ inputs.use_aliyun_mirror }}

      - name: 验证缓存行为
        run: |
          echo "🗄️ 验证缓存行为 - ${{ matrix.cache_test }}..."
          echo "Cache Hit: ${{ steps.setup-cache.outputs.cache-hit }}"
          
          if [[ "${{ matrix.cache_test }}" == "first-run" ]]; then
            if [[ "${{ steps.setup-cache.outputs.cache-hit }}" == "true" ]]; then
              echo "⚠️ 首次运行不应该命中缓存"
            else
              echo "✅ 首次运行正确未命中缓存"
            fi
          else
            if [[ "${{ steps.setup-cache.outputs.cache-hit }}" == "true" ]]; then
              echo "✅ 第二次运行正确命中缓存"
            else
              echo "⚠️ 第二次运行应该命中缓存"
            fi
          fi

  # 测试总结
  test-summary:
    needs: [test-basic, test-docker-only, test-kubectl-only, test-debug, test-cache]
    if: always()
    runs-on: ubuntu-node-20
    steps:
      - name: 生成测试报告
        run: |
          echo "## 🧪 Setup Environment Action 测试报告" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "### 测试配置" >> $GITHUB_STEP_SUMMARY
          echo "- **测试范围**: ${{ inputs.test_scope }}" >> $GITHUB_STEP_SUMMARY
          echo "- **阿里云镜像**: ${{ inputs.use_aliyun_mirror }}" >> $GITHUB_STEP_SUMMARY
          echo "- **kubectl 测试**: ${{ inputs.test_kubectl }}" >> $GITHUB_STEP_SUMMARY
          echo "- **运行 ID**: ${{ github.run_id }}" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          
          echo "### 测试结果" >> $GITHUB_STEP_SUMMARY
          
          # 检查各个任务的结果
          if [[ "${{ needs.test-basic.result }}" == "success" ]]; then
            echo "- ✅ 基础测试: 通过" >> $GITHUB_STEP_SUMMARY
          elif [[ "${{ needs.test-basic.result }}" == "skipped" ]]; then
            echo "- ⏭️ 基础测试: 跳过" >> $GITHUB_STEP_SUMMARY
          else
            echo "- ❌ 基础测试: 失败" >> $GITHUB_STEP_SUMMARY
          fi
          
          if [[ "${{ needs.test-docker-only.result }}" == "success" ]]; then
            echo "- ✅ Docker 专项测试: 通过" >> $GITHUB_STEP_SUMMARY
          elif [[ "${{ needs.test-docker-only.result }}" == "skipped" ]]; then
            echo "- ⏭️ Docker 专项测试: 跳过" >> $GITHUB_STEP_SUMMARY
          else
            echo "- ❌ Docker 专项测试: 失败" >> $GITHUB_STEP_SUMMARY
          fi
          
          if [[ "${{ needs.test-kubectl-only.result }}" == "success" ]]; then
            echo "- ✅ kubectl 专项测试: 通过" >> $GITHUB_STEP_SUMMARY
          elif [[ "${{ needs.test-kubectl-only.result }}" == "skipped" ]]; then
            echo "- ⏭️ kubectl 专项测试: 跳过" >> $GITHUB_STEP_SUMMARY
          else
            echo "- ❌ kubectl 专项测试: 失败" >> $GITHUB_STEP_SUMMARY
          fi
          
          if [[ "${{ needs.test-debug.result }}" == "success" ]]; then
            echo "- ✅ 调试模式测试: 通过" >> $GITHUB_STEP_SUMMARY
          elif [[ "${{ needs.test-debug.result }}" == "skipped" ]]; then
            echo "- ⏭️ 调试模式测试: 跳过" >> $GITHUB_STEP_SUMMARY
          else
            echo "- ❌ 调试模式测试: 失败" >> $GITHUB_STEP_SUMMARY
          fi
          
          if [[ "${{ needs.test-cache.result }}" == "success" ]]; then
            echo "- ✅ 缓存测试: 通过" >> $GITHUB_STEP_SUMMARY
          elif [[ "${{ needs.test-cache.result }}" == "skipped" ]]; then
            echo "- ⏭️ 缓存测试: 跳过" >> $GITHUB_STEP_SUMMARY
          else
            echo "- ❌ 缓存测试: 失败" >> $GITHUB_STEP_SUMMARY
          fi
          
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "### 建议" >> $GITHUB_STEP_SUMMARY
          echo "- 如果测试失败，请检查 secrets 配置" >> $GITHUB_STEP_SUMMARY
          echo "- 可以通过调试模式获取更多信息" >> $GITHUB_STEP_SUMMARY
          echo "- 确保运行器有足够的权限安装软件包" >> $GITHUB_STEP_SUMMARY