ci_tests.yml

name: "CI tests"

on: [ push, workflow_dispatch ]

jobs:
  build-mingw:
    name: Tests and application run on Windows Latest MinGW
    runs-on: windows-latest

    steps:
      - uses: actions/checkout@v4

      - name: Install MinGW toolchain
        shell: powershell
        run: |
          choco install mingw --yes --no-progress
          echo "C:\tools\mingw64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append

      - name: Create CMake cache
        run: |
          cmake -S . -B cmake-build-release -DCMAKE_BUILD_TYPE=Release -G "MinGW Makefiles"
          cmake -S . -B cmake-build-debug -DCMAKE_BUILD_TYPE=Debug -G "MinGW Makefiles"

      - name: Build main target
        shell: bash
        run: |
          cmake --build cmake-build-release || echo Built with errors

      - name: Build tests target
        shell: bash
        run: |
          cmake --build cmake-build-debug --target cpp_tests_tests || echo Built with errors

      - name: Run program
        working-directory: .\cmake-build-release
        shell: bash
        run: |
          ./cpp_tests.exe --help

      - name: Run tests
        working-directory: .\cmake-build-debug
        shell: bash
        run: |
          # ./cpp_tests_tests.exe
          echo "Tests are not run on Windows MinGW due to issues with the test runner"

  build-matrix:
    name: Tests and application run on ${{ matrix.config.name }}
    runs-on: ${{ matrix.config.os }}
    strategy:
      fail-fast: false
      matrix:
        config:
          - {
            name: "Windows Latest MSVC", artifact: "Windows-MSVC.tar.xz",
            os: windows-latest,
            build_type: "Release", cc: "cl", cxx: "cl",
            environment_script: "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Auxiliary/Build/vcvars64.bat"
          }
          - {
            name: "Ubuntu Latest GCC", artifact: "Linux.tar.xz",
            os: ubuntu-latest,
            build_type: "Release", cc: "gcc", cxx: "g++"
          }
          - {
            name: "macOS Latest Clang", artifact: "macOS.tar.xz",
            os: macos-latest,
            build_type: "Release", cc: "clang", cxx: "clang++"
          }
    
    steps:
      - uses: actions/checkout@v4

      - name: Create CMake cache
        shell: bash
        run: |
          cmake -S . -B cmake-build-release -DCMAKE_BUILD_TYPE=Release
          cmake -S . -B cmake-build-debug -DCMAKE_BUILD_TYPE=Debug

      - name: Build main target
        shell: bash
        run: |
          cmake --build cmake-build-release --target cpp_tests || echo "Built with errors"

      - name: Build tests target
        shell: bash
        run: |
          cmake --build cmake-build-debug --target cpp_tests_tests || echo "Built with errors"

      - name: Run program
        shell: bash
        working-directory: ./cmake-build-release
        run: |
          if [ "$RUNNER_OS" == "Windows" ]; then
            ./cpp_tests.exe --help
          else 
            cd bin
            ./cpp_tests --help
          fi

      - name: Run tests
        shell: bash
        working-directory: ./cmake-build-debug
        run: |
          if [ "$RUNNER_OS" == "Windows" ]; then
            ./cpp_tests_tests.exe
          else
            cd tests
            ./cpp_tests_tests
          fi

  memory-leaks:
    name: Find memory leaks in tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install valgrind
        run: |
          sudo apt-get update && sudo apt-get -y install valgrind

      - name: Create CMake cache
        run: |
          cmake -S . -B cmake-build -DCMAKE_BUILD_TYPE=Debug

      - name: Build tests target
        run: |
          cmake --build cmake-build --target cpp_tests_tests

      - name: Run valgrind
        working-directory: ./cmake-build/tests
        run: |
          valgrind --leak-check=full --track-origins=yes --error-exitcode=1 ./cpp_tests_tests

  style-check:
    name: Code style check with clang-format
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install clang-format
        run: |
          sudo apt-get update && sudo apt-get -y install clang-format

      - name: Check code style
        shell: bash
        run: |
          mapfile -t files < <(git ls-files '*.c' '*.cpp' '*.h' '*.hpp')

          if [ "${#files[@]}" -eq 0 ]; then
            echo "No C/C++ files to check."
            exit 0
          fi

          clang-format --dry-run --Werror "${files[@]}" 2>format_output.txt || {
            cat format_output.txt
            exit 1
          }

      - name: Comment on style issues
        if: failure() && github.event_name == 'pull_request'
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const { execSync } = require('child_process');

            try {
              // Get list of files that need formatting
              const rawFiles = execSync('git ls-files "*.c" "*.cpp" "*.h" "*.hpp"', { encoding: 'utf8' }).trim();

              if (!rawFiles) {
                console.log('No files require formatting checks.');
                return;
              }

              const files = rawFiles.split('\n');

              let comment = '## 🎨 Code Style Issues Found\n\n';
              comment += 'The following files have formatting issues:\n\n';
              let hasIssues = false;

              for (const file of files) {
                try {
                  const result = execSync(`clang-format --dry-run --Werror "${file}" 2>&1`, { encoding: 'utf8' });
                } catch (error) {
                  comment += `- \`${file}\`: Formatting issues detected\n`;
                  hasIssues = true;
                }
              }

              if (!hasIssues) {
                comment += 'No files with formatting issues were detected.';
              } else {
                comment += '\nPlease run `clang-format -i <file>` to fix formatting issues.';
              }

              github.rest.issues.createComment({
                issue_number: context.issue.number,
                owner: context.repo.owner,
                repo: context.repo.repo,
                body: comment
              });
            } catch (error) {
              console.log('Could not create comment:', error.message);
            }

  code-quality-check:
    name: Code quality check with clang-tidy
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install clang-tidy
        run: |
          sudo apt-get update && sudo apt-get -y install clang-tidy

      - name: Create CMake cache
        run: |
          cmake -S . -B cmake-build-tidy -DCMAKE_BUILD_TYPE=Debug -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

      - name: Run clang-tidy
        shell: bash
        run: |
          mapfile -t files < <(git ls-files '*.c' '*.cpp')

          if [ "${#files[@]}" -eq 0 ]; then
            echo "No C/C++ files to analyze."
            echo "" > tidy_output.txt
            exit 0
          fi

          echo "Running clang-tidy on ${#files[@]} files..."
          clang-tidy "${files[@]}" -p cmake-build-tidy --format-style=file > tidy_output.txt 2>&1 || true
          
          # Ensure file exists and is readable
          if [ ! -f tidy_output.txt ]; then
            echo "" > tidy_output.txt
          fi

      - name: Count warnings and errors
        id: count_issues
        run: |
          # Count errors and warnings - handle empty file case
          if [ ! -s tidy_output.txt ]; then
            errors=0
            warnings=0
          else
            errors=$(grep -c "error:" tidy_output.txt 2>/dev/null || echo "0")
            warnings=$(grep -c "warning:" tidy_output.txt 2>/dev/null || echo "0")
          fi
          
          # Ensure we have clean integer values
          errors=$(echo "$errors" | tr -d '\n' | head -c 10)
          warnings=$(echo "$warnings" | tr -d '\n' | head -c 10)
          
          # Default to 0 if empty or non-numeric
          errors=${errors:-0}
          warnings=${warnings:-0}

          echo "errors=$errors" >> $GITHUB_OUTPUT
          echo "warnings=$warnings" >> $GITHUB_OUTPUT

          echo "Found $errors errors and $warnings warnings"

          # Fail if more than 3 warnings or any errors
          if [ "$errors" -gt 0 ] || [ "$warnings" -gt 3 ]; then
            echo "clang-tidy found $errors errors and $warnings warnings"
            cat tidy_output.txt
            exit 1
          fi

      - name: Comment on quality issues
        if: failure() && github.event_name == 'pull_request'
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            
            try {
              let comment = '## 🔍 Code Quality Issues Found\n\n';
              
              if (fs.existsSync('tidy_output.txt')) {
                const output = fs.readFileSync('tidy_output.txt', 'utf8');
                const lines = output.split('\n');
                
                let currentFile = '';
                let hasIssues = false;
                
                for (const line of lines) {
                  if (line.includes('error:') || line.includes('warning:')) {
                    const parts = line.split(':');
                    if (parts.length >= 4) {
                      const file = parts[0];
                      const lineNum = parts[1];
                      const message = parts.slice(3).join(':').trim();
                      
                      if (file !== currentFile) {
                        if (hasIssues) comment += '\n';
                        comment += `### \`${file}\`\n\n`;
                        currentFile = file;
                        hasIssues = true;
                      }
                      
                      const issueType = line.includes('error:') ? '❌ Error' : '⚠️ Warning';
                      comment += `- **Line ${lineNum}**: ${issueType} - ${message}\n`;
                    }
                  }
                }
                
                if (!hasIssues) {
                  comment += 'No specific issues found in the output.';
                }
              } else {
                comment += 'Could not read clang-tidy output.';
              }
              
              comment += '\n\nPlease review and fix the issues above.';
              
              github.rest.issues.createComment({
                issue_number: context.issue.number,
                owner: context.repo.owner,
                repo: context.repo.repo,
                body: comment
              });
            } catch (error) {
              console.log('Could not create comment:', error.message);
            }