# ==================================================================================================================== #
# Authors:                                                                                                             #
#   Patrick Lehmann                                                                                                    #
#   Unai Martinez-Corral                                                                                               #
#                                                                                                                      #
# ==================================================================================================================== #
# Copyright 2020-2024 The pyTooling Authors                                                                            #
#                                                                                                                      #
# Licensed under the Apache License, Version 2.0 (the "License");                                                      #
# you may not use this file except in compliance with the License.                                                     #
# You may obtain a copy of the License at                                                                              #
#                                                                                                                      #
#   http://www.apache.org/licenses/LICENSE-2.0                                                                         #
#                                                                                                                      #
# Unless required by applicable law or agreed to in writing, software                                                  #
# distributed under the License is distributed on an "AS IS" BASIS,                                                    #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.                                             #
# See the License for the specific language governing permissions and                                                  #
# limitations under the License.                                                                                       #
#                                                                                                                      #
# SPDX-License-Identifier: Apache-2.0                                                                                  #
# ==================================================================================================================== #
name: Unit Testing (Matrix)

on:
  workflow_call:
    inputs:
      jobs:
        description: 'JSON list with environment fields, telling the system and Python versions to run tests with.'
        required: true
        type: string
      apt:
        description: 'Ubuntu dependencies to be installed through apt.'
        required: false
        default: ''
        type: string
      brew:
        description: 'macOS dependencies to be installed through brew.'
        required: false
        default: ''
        type: string
      pacboy:
        description: 'MSYS2 dependencies to be installed through pacboy (pacman).'
        required: false
        default: ''
        type: string
      requirements:
        description: 'Python dependencies to be installed through pip.'
        required: false
        default: '-r tests/requirements.txt'
        type: string
      mingw_requirements:
        description: 'Override Python dependencies to be installed through pip on MSYS2 (MINGW64) only.'
        required: false
        default: ''
        type: string
      macos_before_script:
        description: 'Scripts to execute before pytest on macOS.'
        required: false
        default: ''
        type: string
      ubuntu_before_script:
        description: 'Scripts to execute before pytest on Ubuntu.'
        required: false
        default: ''
        type: string
      root_directory:
        description: 'Working directory for running tests.'
        required: false
        default: ''
        type: string
      tests_directory:
        description: 'Path to the directory containing tests (relative to root_directory).'
        required: false
        default: 'tests'
        type: string
      unittest_directory:
        description: 'Path to the directory containing unit tests (relative to tests_directory).'
        required: false
        default: 'unit'
        type: string
      coverage_config:
        description: 'Path to the .coveragerc file. Use pyproject.toml by default.'
        required: false
        default: 'pyproject.toml'
        type: string
      unittest_xml_artifact:
        description: "Generate unit test report with junitxml and upload results as an artifact."
        required: false
        default: ''
        type: string
      unittest_html_artifact:
        description: "Generate unit test report with junitxml and upload results as an artifact."
        required: false
        default: ''
        type: string
      coverage_sqlite_artifact:
        description: 'Name of the SQLite coverage artifact.'
        required: false
        default: ''
        type: string
      coverage_xml_artifact:
        description: 'Name of the XML coverage artifact.'
        required: false
        default: ''
        type: string
      coverage_json_artifact:
        description: 'Name of the JSON coverage artifact.'
        required: false
        default: ''
        type: string
      coverage_html_artifact:
        description: 'Name of the HTML coverage artifact.'
        required: false
        default: ''
        type: string

jobs:
  UnitTesting:
    name: ${{ matrix.sysicon }} ${{ matrix.pyicon }} Unit Tests - Python ${{ matrix.python }}
    runs-on: ${{ matrix.runs-on }}

    strategy:
      fail-fast: false
      matrix:
        include: ${{ fromJson(inputs.jobs) }}

    defaults:
      run:
        shell: ${{ matrix.shell }}

    steps:
      - name: ⏬ Checkout repository
        uses: actions/checkout@v4

# Package Manager steps
      - name: 🔧 Install homebrew dependencies on macOS
        if: matrix.system == 'macos' && inputs.brew != ''
        run: brew install ${{ inputs.brew }}

      - name: 🔧 Install apt dependencies on Ubuntu
        if: matrix.system == 'ubuntu' && inputs.apt != ''
        run: sudo apt-get install -y --no-install-recommends ${{ inputs.apt }}

# Compute Dependencies for MSYS2 steps

      - name: 🔧 Install dependencies (system Python for Python shell)
        if: matrix.system == 'msys2'
        shell: pwsh
        run: |
          py -3.9 -m pip install --disable-pip-version-check -U tomli

      - name: Compute pacman/pacboy packages
        id: pacboy
        if: matrix.system == 'msys2'
        shell: python
        run: |
          from os      import getenv
          from pathlib import Path
          from re      import compile
          from sys     import version

          print(f"Python: {version}")

          def loadRequirementsFile(requirementsFile: Path):
            requirements = []
            with requirementsFile.open("r") as file:
              for line in file.readlines():
                line = line.strip()
                if line.startswith("#") or line.startswith("https") or line == "":
                  continue
                elif line.startswith("-r"):
                  # Remove the first word/argument (-r)
                  requirements += loadRequirementsFile(requirementsFile.parent / line[2:].lstrip())
                else:
                  requirements.append(line)

            return requirements

          requirements = "${{ inputs.requirements }}"
          if requirements.startswith("-r"):
            requirementsFile = Path(requirements[2:].lstrip())
            dependencies = loadRequirementsFile(requirementsFile)
          else:
            dependencies = [req.strip() for req in requirements.split(" ")]

          packages = {
            "coverage":    "python-coverage:p",
            "igraph":      "igraph:p",
            "jinja2":      "python-markupsafe:p",
            "lxml":        "python-lxml:p",
            "numpy":       "python-numpy:p",
            "markupsafe":  "python-markupsafe:p",
            "pip":         "python-pip:p",
            "ruamel.yaml": "python-ruamel-yaml:p python-ruamel.yaml.clib:p",
            "sphinx":      "python-markupsafe:p",
            "tomli":       "python-tomli:p",
            "wheel":       "python-wheel:p",
            "pyEDAA.ProjectModel": "python-ruamel-yaml:p python-ruamel.yaml.clib:p python-lxml:p",
            "pyEDAA.Reports":      "python-ruamel-yaml:p python-ruamel.yaml.clib:p python-lxml:p",
          }
          subPackages = {
            "pytooling": {
              "yaml":      "python-ruamel-yaml:p python-ruamel.yaml.clib:p",
            },
          }

          regExp = compile(r"(?P<PackageName>[\w_\-\.]+)(?:\[(?P<SubPackages>(?:\w+)(?:\s*,\s*\w+)*)\])?(?:\s*(?P<Comperator>[<>~=]+)\s*)(?P<Version>\d+(?:\.\d+)*)(?:-(?P<VersionExtension>\w+))?")

          pacboyPackages = set(("python-pip:p", "python-wheel:p", "python-tomli:p"))
          print(f"Processing dependencies ({len(dependencies)}):")
          for dependency in dependencies:
            print(f"  {dependency}")

            match = regExp.match(dependency.lower())
            if not match:
              print(f"    Wrong format: {dependency}")
              print(f"::error title=Identifying Pacboy Packages::Unrecognized dependency format '{dependency}'")
              continue

            package = match["PackageName"]
            if package in packages:
              rewrite = packages[package]
              print(f"    Found rewrite rule for '{package}': {rewrite}")
              pacboyPackages.add(rewrite)

            if match["SubPackages"] and package in subPackages:
              for subPackage in match["SubPackages"].split(","):
                if subPackage in subPackages[package]:
                  rewrite = subPackages[package][subPackage]
                  print(f"    Found rewrite rule for '{package}[..., {subPackage}, ...]': {rewrite}")
                  pacboyPackages.add(rewrite)

          # Write jobs to special file
          github_output = Path(getenv("GITHUB_OUTPUT"))
          print(f"GITHUB_OUTPUT: {github_output}")
          with github_output.open("a+") as f:
            f.write(f"pacboy_packages={' '.join(pacboyPackages)}\n")

# Python setup

      - name: '🟦 Setup MSYS2 for ${{ matrix.runtime }}'
        if: matrix.system == 'msys2'
        uses: msys2/setup-msys2@v2
        with:
          msystem: ${{ matrix.runtime }}
          update: true
          pacboy: >-
            ${{ steps.pacboy.outputs.pacboy_packages }}
            ${{ inputs.pacboy }}

      - name: 🐍 Setup Python ${{ matrix.python }}
        if: matrix.system != 'msys2'
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python }}

# Python Dependency steps

      - name: 🔧 Install wheel,tomli and pip dependencies (native)
        if: matrix.system != 'msys2'
        run: |
          python -m pip install --disable-pip-version-check -U wheel tomli
          python -m pip install --disable-pip-version-check ${{ inputs.requirements }}

      - name: 🔧 Install pip dependencies (MSYS2)
        if: matrix.system == 'msys2'
        run: |
          if [ -n '${{ inputs.mingw_requirements }}' ]; then
            python -m pip install --disable-pip-version-check ${{ inputs.mingw_requirements }}
          else
            python -m pip install --disable-pip-version-check ${{ inputs.requirements }}
          fi

# Before scripts

      - name: 🍎 macOS before scripts
        if: matrix.system == 'macos' && inputs.macos_before_script != ''
        run: ${{ inputs.macos_before_script }}

      - name: 🐧 Ubuntu before scripts
        if: matrix.system == 'ubuntu' && inputs.ubuntu_before_script != ''
        run: ${{ inputs.ubuntu_before_script }}

# Read pyproject.toml

      - name: 🔁 Extract configurations from pyproject.toml
        id: getVariables
        shell: python
        run: |
          from os       import getenv
          from pathlib  import Path
          from sys      import version
          from textwrap import dedent

          print(f"Python: {version}")

          from tomli import load as tomli_load

          htmlDirectory = Path("htmlcov")
          xmlFile =  Path("./coverage.xml")
          jsonFile = Path("./coverage.json")
          coverageRC = "${{ inputs.coverage_config }}".strip()

          # Read output paths from 'pyproject.toml' file
          if coverageRC == "pyproject.toml":
            pyProjectFile =  Path("pyproject.toml")
            if pyProjectFile.exists():
              with pyProjectFile.open("rb") as file:
                pyProjectSettings = tomli_load(file)

              htmlDirectory = Path(pyProjectSettings["tool"]["coverage"]["html"]["directory"])
              xmlFile       = Path(pyProjectSettings["tool"]["coverage"]["xml"]["output"])
              jsonFile      = Path(pyProjectSettings["tool"]["coverage"]["json"]["output"])
            else:
              print(f"File '{pyProjectFile}' not found and no '.coveragerc' file specified.")

          # Read output paths from '.coveragerc' file
          elif len(coverageRC) > 0:
            coverageRCFile = Path(coverageRC)
            if coverageRCFile.exists():
              with coverageRCFile.open("rb") as file:
                coverageRCSettings = tomli_load(file)

              htmlDirectory = Path(coverageRCSettings["html"]["directory"])
              xmlFile       = Path(coverageRCSettings["xml"]["output"])
              jsonFile      = Path(coverageRCSettings["json"]["output"])
            else:
              print(f"File '{coverageRCFile}' not found.")

          # Write jobs to special file
          github_output = Path(getenv("GITHUB_OUTPUT"))
          print(f"GITHUB_OUTPUT: {github_output}")
          with github_output.open("a+", encoding="utf-8") as f:
            f.write(dedent(f"""\
              unittest_report_html_directory={htmlDirectory}
              coverage_report_html_directory={htmlDirectory.as_posix()}
              coverage_report_xml={xmlFile}
              coverage_report_json={jsonFile}
            """))

          print(f"DEBUG:\n  html={htmlDirectory}\n  xml={xmlFile}\n  json={jsonFile}")

# Run pytests

      - name: ✅ Run unit tests (Ubuntu/macOS)
        if: matrix.system != 'windows'
        run: |
          export ENVIRONMENT_NAME="${{ matrix.envname }}"
          export PYTHONPATH=$(pwd)

          cd "${{ inputs.root_directory || '.' }}"
          [ -n '${{ inputs.unittest_xml_artifact }}' ] && PYTEST_ARGS='--junitxml=report/unit/TestReportSummary.xml' || unset PYTEST_ARGS
          if [ -n '${{ inputs.coverage_config }}' ]; then
            echo "coverage run --data-file=.coverage --rcfile=pyproject.toml -m pytest -raP $PYTEST_ARGS --color=yes ${{ inputs.tests_directory || '.' }}/${{ inputs.unittest_directory }}"
            coverage run --data-file=.coverage --rcfile=pyproject.toml -m pytest -raP $PYTEST_ARGS --color=yes ${{ inputs.tests_directory || '.' }}/${{ inputs.unittest_directory }}
          else
            echo "python -m pytest -raP $PYTEST_ARGS --color=yes ${{ inputs.tests_directory || '.' }}/${{ inputs.unittest_directory }}"
            python -m pytest -raP $PYTEST_ARGS --color=yes ${{ inputs.tests_directory || '.' }}/${{ inputs.unittest_directory }}
          fi

      - name: ✅ Run unit tests (Windows)
        if: matrix.system == 'windows'
        run: |
          $env:ENVIRONMENT_NAME = "${{ matrix.envname }}"
          $env:PYTHONPATH = (Get-Location).ToString()

          cd "${{ inputs.root_directory || '.' }}"
          $PYTEST_ARGS = if ("${{ inputs.unittest_xml_artifact }}") { "--junitxml=report/unit/TestReportSummary.xml" } else { "" }
          if ("${{ inputs.coverage_config }}") {
            Write-Host "coverage run --data-file=.coverage --rcfile=pyproject.toml -m pytest -raP --color=yes ${{ inputs.tests_directory || '.' }}/${{ inputs.unittest_directory }}"
            coverage run --data-file=.coverage --rcfile=pyproject.toml -m pytest -raP $PYTEST_ARGS --color=yes ${{ inputs.tests_directory || '.' }}/${{ inputs.unittest_directory }}
          } else {
            Write-Host "python -m pytest -raP $PYTEST_ARGS --color=yes ${{ inputs.tests_directory || '.' }}/${{ inputs.unittest_directory }}"
            python -m pytest -raP $PYTEST_ARGS --color=yes ${{ inputs.tests_directory || '.' }}/${{ inputs.unittest_directory }}
          }

      - name: Convert coverage to XML format (Cobertura)
        if: inputs.coverage_xml_artifact != ''
        continue-on-error: true
        run: coverage xml --data-file=.coverage

      - name: Convert coverage to JSON format
        if: inputs.coverage_json_artifact != ''
        continue-on-error: true
        run: coverage json --data-file=.coverage

      - name: Convert coverage to HTML format
        if: inputs.coverage_html_artifact != ''
        continue-on-error: true
        run: |
          coverage html --data-file=.coverage -d ${{ steps.getVariables.outputs.coverage_report_html_directory }}
          rm ${{ steps.getVariables.outputs.coverage_report_html_directory }}/.gitignore

# Upload artifacts

      - name: 📤 Upload 'TestReportSummary.xml' artifact
        if: inputs.unittest_xml_artifact != ''
        continue-on-error: true
        uses: actions/upload-artifact@v4
        with:
          name: ${{ inputs.unittest_xml_artifact }}-${{ matrix.system }}-${{ matrix.runtime }}-${{ matrix.python }}
          path: report/unit/TestReportSummary.xml
          if-no-files-found: error
          retention-days: 1

#      - name: 📤 Upload 'Unit Tests HTML Report' artifact
#        if: inputs.unittest_html_artifact != ''
#        continue-on-error: true
#        uses: actions/upload-artifact@v4
#        with:
#          name: ${{ inputs.unittest_html_artifact }}-${{ matrix.system }}-${{ matrix.runtime }}-${{ matrix.python }}
#          path: ${{ steps.getVariables.outputs.unittest_report_html_directory }}
#          if-no-files-found: error
#          retention-days: 1

      - name: 📤 Upload 'Coverage SQLite Database' artifact
        if: inputs.coverage_sqlite_artifact != ''
        continue-on-error: true
        uses: actions/upload-artifact@v4
        with:
          name: ${{ inputs.coverage_sqlite_artifact }}-${{ matrix.system }}-${{ matrix.runtime }}-${{ matrix.python }}
          path: .coverage
          if-no-files-found: error
          retention-days: 1

      - name: 📤 Upload 'Coverage XML Report' artifact
        if: inputs.coverage_xml_artifact != ''
        continue-on-error: true
        uses: actions/upload-artifact@v4
        with:
          name: ${{ inputs.coverage_xml_artifact }}-${{ matrix.system }}-${{ matrix.runtime }}-${{ matrix.python }}
          path: ${{ steps.getVariables.outputs.coverage_report_xml }}
          if-no-files-found: error
          retention-days: 1

      - name: 📤 Upload 'Coverage JSON Report' artifact
        if: inputs.coverage_json_artifact != ''
        continue-on-error: true
        uses: actions/upload-artifact@v4
        with:
          name: ${{ inputs.coverage_json_artifact }}-${{ matrix.system }}-${{ matrix.runtime }}-${{ matrix.python }}
          path: ${{ steps.getVariables.outputs.coverage_report_json }}
          if-no-files-found: error
          retention-days: 1

      - name: 📤 Upload 'Coverage HTML Report' artifact
        if: inputs.coverage_html_artifact != ''
        continue-on-error: true
        uses: actions/upload-artifact@v4
        with:
          name: ${{ inputs.coverage_html_artifact }}-${{ matrix.system }}-${{ matrix.runtime }}-${{ matrix.python }}
          path: ${{ steps.getVariables.outputs.coverage_report_html_directory }}
          if-no-files-found: error
          retention-days: 1