# yaml-language-server: $schema=https://json.schemastore.org/github-action.json
# permissions:
#   - contents: read  # Required for checking out repository
---
name: Laravel Setup and Composer test
description: 'Setup PHP, install dependencies, generate key, create database and run composer test'
author: 'Ismo Vuorinen'

branding:
  icon: 'terminal'
  color: 'blue'

inputs:
  php-version:
    description: 'PHP Version to use, see https://github.com/marketplace/actions/setup-php-action#php-version-optional'
    required: false
    default: 'latest'
  php-version-file:
    description: 'PHP Version file to use, see https://github.com/marketplace/actions/setup-php-action#php-version-file-optional'
    required: false
    default: '.php-version'
  extensions:
    description: 'PHP extensions to install, see https://github.com/marketplace/actions/setup-php-action#extensions-optional'
    required: false
    default: 'mbstring, intl, json, pdo_sqlite, sqlite3'
  coverage:
    description: 'Specify code-coverage driver, see https://github.com/marketplace/actions/setup-php-action#coverage-optional'
    required: false
    default: 'none'
  token:
    description: 'GitHub token for authentication'
    required: false
    default: ''

outputs:
  php-version:
    description: 'The PHP version that was setup'
    value: ${{ steps.setup-php.outputs.php-version }}
  php-version-file:
    description: 'The PHP version file that was used'
    value: ${{ steps.setup-php.outputs.php-version-file }}
  extensions:
    description: 'The PHP extensions that were installed'
    value: ${{ steps.setup-php.outputs.extensions }}
  coverage:
    description: 'The code-coverage driver that was setup'
    value: ${{ steps.setup-php.outputs.coverage }}

runs:
  using: composite
  steps:
    - name: Mask Secrets
      shell: bash
      env:
        GITHUB_TOKEN: ${{ inputs.token }}
      run: |
        if [ -n "$GITHUB_TOKEN" ]; then
          echo "::add-mask::$GITHUB_TOKEN"
        fi

    - name: Detect PHP Version
      id: php-version
      shell: sh
      env:
        DEFAULT_VERSION: "${{ inputs.php-version || '8.4' }}"
      run: |
        set -eu

        # Function to validate version format
        validate_version() {
          version=$1
          case "$version" in
            [0-9]*.[0-9]* | [0-9]*.[0-9]*.[0-9]*)
              return 0
              ;;
            *)
              return 1
              ;;
          esac
        }

        # Function to clean version string
        clean_version() {
          printf '%s' "$1" | sed 's/^[vV]//' | tr -d ' \n\r'
        }

        detected_version=""

        # Parse .tool-versions file
        if [ -f .tool-versions ]; then
          echo "Checking .tool-versions for php..." >&2
          version=$(awk '/^php[[:space:]]/ {gsub(/#.*/, ""); print $2; exit}' .tool-versions 2>/dev/null || echo "")
          if [ -n "$version" ]; then
            version=$(clean_version "$version")
            if validate_version "$version"; then
              echo "Found PHP version in .tool-versions: $version" >&2
              detected_version="$version"
            fi
          fi
        fi

        # Parse Dockerfile
        if [ -z "$detected_version" ] && [ -f Dockerfile ]; then
          echo "Checking Dockerfile for php..." >&2
          version=$(grep -iF "FROM" Dockerfile | grep -F "php:" | head -1 | \
            sed -n -E "s/.*php:([0-9]+(\.[0-9]+)*)(-[^:]*)?.*/\1/p" || echo "")
          if [ -n "$version" ]; then
            version=$(clean_version "$version")
            if validate_version "$version"; then
              echo "Found PHP version in Dockerfile: $version" >&2
              detected_version="$version"
            fi
          fi
        fi

        # Parse devcontainer.json
        if [ -z "$detected_version" ] && [ -f .devcontainer/devcontainer.json ]; then
          echo "Checking devcontainer.json for php..." >&2
          if command -v jq >/dev/null 2>&1; then
            version=$(jq -r '.image // empty' .devcontainer/devcontainer.json 2>/dev/null | sed -n -E "s/.*php:([0-9]+(\.[0-9]+)*)(-[^:]*)?.*/\1/p" || echo "")
            if [ -n "$version" ]; then
              version=$(clean_version "$version")
              if validate_version "$version"; then
                echo "Found PHP version in devcontainer: $version" >&2
                detected_version="$version"
              fi
            fi
          else
            echo "jq not found; skipping devcontainer.json parsing" >&2
          fi
        fi

        # Parse .php-version file
        if [ -z "$detected_version" ] && [ -f .php-version ]; then
          echo "Checking .php-version..." >&2
          version=$(tr -d '\r' < .php-version | head -1)
          if [ -n "$version" ]; then
            version=$(clean_version "$version")
            if validate_version "$version"; then
              echo "Found PHP version in .php-version: $version" >&2
              detected_version="$version"
            fi
          fi
        fi

        # Parse composer.json
        if [ -z "$detected_version" ] && [ -f composer.json ]; then
          echo "Checking composer.json..." >&2
          if command -v jq >/dev/null 2>&1; then
            version=$(jq -r '.require.php // empty' composer.json 2>/dev/null | sed -n 's/[^0-9]*\\([0-9]\\+\\.[0-9]\\+\\(\\.[0-9]\\+\\)\\?\\).*/\\1/p')
            if [ -z "$version" ]; then
              version=$(jq -r '.config.platform.php // empty' composer.json 2>/dev/null | sed -n 's/[^0-9]*\\([0-9]\\+\\.[0-9]\\+\\(\\.[0-9]\\+\\)\\?\\).*/\\1/p')
            fi
            if [ -n "$version" ]; then
              version=$(clean_version "$version")
              if validate_version "$version"; then
                echo "Found PHP version in composer.json: $version" >&2
                detected_version="$version"
              fi
            fi
          else
            echo "jq not found; skipping composer.json parsing" >&2
          fi
        fi

        # Use default version if nothing detected
        if [ -z "$detected_version" ]; then
          detected_version="$DEFAULT_VERSION"
          echo "Using default PHP version: $detected_version" >&2
        fi

        # Set output
        printf 'detected-version=%s\n' "$detected_version" >> "$GITHUB_OUTPUT"
        echo "Final detected PHP version: $detected_version" >&2

    - uses: shivammathur/setup-php@bf6b4fbd49ca58e4608c9c89fba0b8d90bd2a39f # 2.35.5
      id: setup-php
      with:
        php-version: ${{ steps.php-version.outputs.detected-version }}
        extensions: ${{ inputs.extensions }}
        coverage: ${{ inputs.coverage }}

    - uses: actions/checkout@71cf2267d89c5cb81562390fa70a37fa40b1305e # v6-beta
      with:
        token: ${{ inputs.token != '' && inputs.token || github.token }}

    - name: 'Check file existence'
      id: check_files
      uses: andstor/file-existence-action@076e0072799f4942c8bc574a82233e1e4d13e9d6 # v3.0.0
      with:
        files: 'package.json, artisan'

    - name: Copy .env
      if: steps.check_files.outputs.files_exists == 'true'
      shell: bash
      run: |
        set -euo pipefail

        php -r "file_exists('.env') || copy('.env.example', '.env');"

    - name: Install Dependencies
      if: steps.check_files.outputs.files_exists == 'true'
      shell: bash
      run: |
        set -euo pipefail

        composer install -q --no-ansi --no-interaction --no-scripts --no-progress --prefer-dist

    - name: Generate key
      if: steps.check_files.outputs.files_exists == 'true'
      shell: bash
      run: |
        set -euo pipefail

        php artisan key:generate

    - name: Directory Permissions
      if: steps.check_files.outputs.files_exists == 'true'
      shell: bash
      run: |
        set -euo pipefail

        chmod -R 777 storage bootstrap/cache

    - name: Create Database
      if: steps.check_files.outputs.files_exists == 'true'
      shell: bash
      run: |
        set -euo pipefail

        mkdir -p database
        touch database/database.sqlite

    - name: Execute composer test (Unit and Feature tests)
      if: steps.check_files.outputs.files_exists == 'true'
      shell: bash
      env:
        DB_CONNECTION: sqlite
        DB_DATABASE: database/database.sqlite
      run: |-
        set -euo pipefail

        composer test