name: Install MinGW
description: Install MinGW-w64

inputs:
  platform:
    description: Target platform
    required: false
    default: x64
  cc:
    description: Set up cc/c++ executables
    required: false
    default: 1
  version:
    description: Specify mingw version; will fall back to package manager default if not supplied
    required: false
    default: ''

outputs:
  prefix:
    description: Cross-compilation toolchain prefix
    value: ${{ steps.setup.outputs.prefix }}
  gcc:
    description: gcc binary name
    value: ${{ steps.setup.outputs.gcc }}
  gxx:
    description: g++ binary name
    value: ${{ steps.setup.outputs.gxx }}
  windres:
    description: windres binary name
    value: ${{ steps.setup.outputs.windres }}

runs:
  using: composite
  steps:
    - id: setup
      env:
        ARG_VERSION: ${{ inputs.version }}
        ARG_PLATFORM: ${{ inputs.platform }}
      run: |
        $linux_host = '${{ runner.os }}' -eq 'Linux'
        $windows_host = '${{ runner.os }}' -eq 'Windows'

        $mingw_version = (Get-ChildItem env:ARG_VERSION).Value
        $mingw_version_supplied = $mingw_version -ne ''

        $x64 = (Get-ChildItem env:ARG_PLATFORM).Value -eq 'x64'

        $prefix32 = 'i686-w64-mingw32'
        $prefix64 = 'x86_64-w64-mingw32'
        $prefix = if ($x64) { $prefix64 } else { $prefix32 }

        function Locate-Choco {
            $path = Get-Command 'choco' -ErrorAction SilentlyContinue
            if ($path) {
                $path.Path
            } else {
                Join-Path (Get-ChildItem env:ProgramData).Value 'chocolatey' 'bin' 'choco'
            }
        }

        function Install-Package {
            param(
                [Parameter(Mandatory=$true, ValueFromRemainingArguments=$true)]
                [string[]] $Packages
            )

            if ($script:linux_host) {
                sudo apt-get update
                sudo DEBIAN_FRONTEND=noninteractive apt-get install -yq --no-install-recommends $Packages
            } elseif ($script:windows_host) {
                $choco = Locate-Choco
                & $choco upgrade $Packages -y --no-progress --allow-downgrade
            } else {
                throw "Sorry, installing packages is unsupported on $script:os"
            }
        }

        function Remove-Package {
            param(
                [Parameter(Mandatory=$true, ValueFromRemainingArguments=$true)]
                [string[]] $Packages
            )

            if ($script:linux_host) {
                sudo apt-get autoremove --purge -yq $Packages
            } elseif ($script:windows_host) {
                $choco = Locate-Choco
                & $choco uninstall $Packages -y --no-progress
            } else {
                throw "Sorry, removing packages is unsupported on $script:os"
            }
        }

        if ($linux_host) {
            if ($mingw_version_supplied) {
                Install-Package mingw-w64=$mingw_version
            } else {
                Install-Package mingw-w64
            }

            # Make the compilers use the POSIX threading model, whatever that
            # is.  Without it, the stuff from <mutex>/<thread>/etc. doesn't
            # compile.  Of course, it makes the binaries depend on
            # libwinpthread-1.dll, but what you gonna do?

            sudo update-alternatives --set "$prefix32-gcc" "/usr/bin/$prefix32-gcc-posix"
            sudo update-alternatives --set "$prefix32-g++" "/usr/bin/$prefix32-g++-posix"
            sudo update-alternatives --set "$prefix64-gcc" "/usr/bin/$prefix64-gcc-posix"
            sudo update-alternatives --set "$prefix64-g++" "/usr/bin/$prefix64-g++-posix"
        } elseif ($windows_host) {
            $choco = Locate-Choco

            $mingw32 = 'mingw32'
            $mingw64 = 'mingw64'
            $mingw = if ($x64) { $mingw64 } else { $mingw32 }

            $pkg = 'mingw'

            if ($x64) {
                # If the 32-bit version is installed, we won't detect that.
                # But it's not that important, and we save a lot of time.
                if ($mingw_version_supplied) {
                    Install-Package $pkg --version $mingw_version
                } else {
                    Install-Package $pkg
                }
            } else {
                # Assuming the 64-bit version is installed.
                Remove-Package $pkg
                if ($mingw_version_supplied) {
                    Install-Package $pkg --version $mingw_version --x86
                } else {
                    Install-Package $pkg --x86
                }
            }

            $mingw_install_new = Join-Path C: ProgramData mingw64 $mingw
            $mingw_install_old = Join-Path C: ProgramData chocolatey lib mingw tools install

            if (Test-Path $mingw_install_new) {
                $mingw_install = $mingw_install_new
            } elseif (Test-Path $mingw_install_old) {
                $mingw_install = Join-Path $mingw_install_old $mingw
            } else {
                throw "Where was MinGW installed? Not sure"
            }

            $mingw_bin = Join-Path $mingw_install bin
            echo $mingw_bin >> $env:GITHUB_PATH
        } else {
            throw "Sorry, installing MinGW is unsupported on $os"
        }

        $gcc = $prefix + '-gcc'
        $gxx = $prefix + '-g++'
        $windres = $prefix = '-windres'

        echo "prefix=$prefix"   >> $env:GITHUB_OUTPUT
        echo "gcc=$gcc"         >> $env:GITHUB_OUTPUT
        echo "gxx=$gxx"         >> $env:GITHUB_OUTPUT
        echo "windres=$windres" >> $env:GITHUB_OUTPUT
      shell: pwsh

    - env:
        ARG_CC: ${{ inputs.cc }}
        GCC: ${{ steps.setup.outputs.gcc }}
        GXX: ${{ steps.setup.outputs.gxx }}
      run: |
        $linux_host = '${{ runner.os }}' -eq 'Linux'
        $windows_host = '${{ runner.os }}' -eq 'Windows'

        $cc = (Get-ChildItem env:ARG_CC).Value -eq '1'

        function Link-Exe {
            param(
                [Parameter(Mandatory=$true)]
                [string] $Exe,
                [Parameter(Mandatory=$true)]
                [string] $LinkName
            )

            $exe_path = (Get-Command $Exe).Path
            $link_dir = if ($script:windows_host) { Split-Path $exe_path } else { '/usr/local/bin' }
            $link_name = if ($script:windows_host) { "$LinkName.exe" } else { $LinkName }
            $link_path = Join-Path $link_dir $link_name

            echo "Creating link $link_path -> $exe_path"
            if ($script:linux_host) {
                sudo ln -f -s $exe_path $link_path
            } elseif ($script:windows_host) {
                New-Item -ItemType HardLink -Path $link_path -Value $exe_path -Force | Out-Null
            }
        }

        if ($cc) {
            Link-Exe (Get-ChildItem env:GCC).Value cc
            Link-Exe (Get-ChildItem env:GXX).Value c++
        }
      shell: pwsh

branding:
  icon: star
  color: green