name: External Plugin Intake

on:
  issues:
    types: [opened, edited, reopened]

concurrency:
  group: external-plugin-intake-${{ github.event.issue.number }}
  cancel-in-progress: true

permissions:
  contents: read
  issues: write

jobs:
  validate-submission:
    runs-on: ubuntu-latest
    if: >-
      contains(github.event.issue.labels.*.name, 'external-plugin') ||
      contains(github.event.issue.body, '<!-- external-plugin-submission -->')
    steps:
      - name: Checkout repository
        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1

      - name: Evaluate submission
        id: evaluation
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          result=$(node ./eng/external-plugin-intake.mjs "$GITHUB_EVENT_PATH")
          {
            echo 'result<<EOF'
            echo "$result"
            echo 'EOF'
          } >> "$GITHUB_OUTPUT"

      - name: Sync labels and comment
        uses: actions/github-script@f28e40c7f34bde8b3046d885e986cb6290c5673b # v7.1.0
        env:
          RESULT_JSON: ${{ steps.evaluation.outputs.result }}
        with:
          script: |
            const path = require('path');
            const { pathToFileURL } = require('url');

            const intakeState = await import(pathToFileURL(path.join(process.env.GITHUB_WORKSPACE, 'eng', 'external-plugin-intake-state.mjs')).href);

            const result = JSON.parse(process.env.RESULT_JSON);
            const issueNumber = context.issue.number;
            const issueState = context.payload.issue.state;
            const action = context.payload.action;
            const existingLabelNames = (context.payload.issue.labels || []).map((label) => label.name);

            if (existingLabelNames.includes('approved')) {
              core.info('Issue is already approved; skipping intake synchronization.');
              return;
            }

            if (issueState === 'closed' && action !== 'reopened') {
              core.info('Issue is closed; waiting for reopen before rerunning intake synchronization.');
              return;
            }

            await intakeState.applyExternalPluginIntakeEvaluation({
              github,
              owner: context.repo.owner,
              repo: context.repo.repo,
              issueNumber,
              evaluation: result
            });

            if (!result.valid && issueState === 'open') {
              await github.rest.issues.update({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: issueNumber,
                state: 'closed'
              });
            }