name: Install MinGW
description: Install MinGW-w64

inputs:
  platform:
    description: Target platform
    required: false
    default: x64
  cygwin:
    description: Install inside Cygwin
    required: false
    default: 0
  static:
    description: Enable static linking workaround
    required: false
    default: 1
  cc:
    description: Set up cc/c++ executables
    required: false
    default: 1
  hardlinks:
    description: On Cygwin, replace executable symlinks with hardlinks
    required: false
    default: 0

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
      run: |
        New-Variable os -Value '${{ runner.os }}' -Option Constant

        New-Variable linux_host -Value ($os -eq 'Linux') -Option Constant
        New-Variable cygwin_host -Value ('${{ inputs.cygwin }}' -eq '1') -Option Constant
        New-Variable windows_host -Value ($os -eq 'Windows' -and !$cygwin_host) -Option Constant

        New-Variable x64 -Value ('${{ inputs.platform }}' -eq 'x64') -Option Constant
        New-Variable static_workaround -Value ('${{ inputs.static }}' -eq '1') -Option Constant

        $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 ${env:ProgramData} 'chocolatey' 'bin' 'choco'
            }
        }

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

            if ($script:linux_host) {
                sudo apt-get update -yq
                sudo apt-get install -yq --no-install-recommends $Packages
            } elseif ($script:cygwin_host) {
                $choco = Locate-Choco
                & $choco install -y --no-progress --source=cygwin $Packages
            } elseif ($script:windows_host) {
                $choco = Locate-Choco
                & $choco install -y --no-progress $Packages
            } 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:cygwin_host) {
                $choco = Locate-Choco
                & $choco uninstall -y --no-progress --source=cygwin $Packages
            } elseif ($script:windows_host) {
                $choco = Locate-Choco
                & $choco uninstall -y --no-progress $Packages
            } else {
                throw "Sorry, removing packages is unsupported on $script:os"
            }
        }

        if ($linux_host) {
            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"

            if ($static_workaround) {
                sudo rm `
                    "/usr/$prefix32/lib/libpthread.dll.a" `
                    "/usr/$prefix32/lib/libwinpthread.dll.a" `
                    "/usr/$prefix64/lib/libpthread.dll.a" `
                    "/usr/$prefix64/lib/libwinpthread.dll.a"
            }
        } elseif ($cygwin_host) {
            $pkg = if ($x64) { 'mingw64-x86_64-gcc-g++' } else { 'mingw64-i686-gcc-g++' }
            Install-Package $pkg

            $bin_dir = cygpath.exe -wa "/usr/$prefix/sys-root/mingw/bin"
            $lib_dir = cygpath.exe -wa "/usr/$prefix/sys-root/mingw/lib"

            echo $bin_dir >> $env:GITHUB_PATH

            if ($static_workaround) {
                Remove-Item (Join-Path $lib_dir 'libpthread.dll.a')
                Remove-Item (Join-Path $lib_dir 'libwinpthread.dll.a')
            }
        } elseif ($windows_host) {
            $choco = Locate-Choco

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

            $mingw_install = Join-Path C: ProgramData chocolatey lib mingw tools install

            $mingw32_root = Join-Path $mingw_install $mingw32
            $mingw64_root = Join-Path $mingw_install $mingw64
            $mingw_root = Join-Path $mingw_install $mingw

            $mingw32_bin = Join-Path $mingw32_root bin
            $mingw64_bin = Join-Path $mingw64_root bin
            $mingw_bin = Join-Path $mingw_root bin

            $mingw_lib = Join-Path $mingw_root $prefix lib

            if ($x64) {
                # If 32-bit version is installed, we won't detect that.  But
                # it's not _that important, and we save a lot of time.
                Install-Package mingw
                echo $mingw64_bin >> $env:GITHUB_PATH
            } else {
                # Assuming the 64-bit version is installed.
                Remove-Package mingw
                Install-Package --x86 mingw
                echo $mingw32_bin >> $env:GITHUB_PATH
            }

            if ($static_workaround) {
                Remove-Item (Join-Path $mingw_lib 'libpthread.dll.a')
                Remove-Item (Join-Path $mingw_lib 'libwinpthread.dll.a')
            }
        } else {
            throw "Sorry, installing MinGW is unsupported on $os"
        }

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

        echo "::set-output name=prefix::$prefix"
        echo "::set-output name=gcc::$gcc"
        echo "::set-output name=gxx::$gxx"
        echo "::set-output name=windres::$windres"
      shell: pwsh

    - run: |
        New-Variable os -Value '${{ runner.os }}' -Option Constant

        New-Variable linux_host -Value ($os -eq 'Linux') -Option Constant
        New-Variable cygwin_host -Value ('${{ inputs.cygwin }}' -eq '1') -Option Constant
        New-Variable windows_host -Value ($os -eq 'Windows' -and !$cygwin_host) -Option Constant

        New-Variable cc -Value ('${{ inputs.cc }}' -eq '1') -Option Constant

        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 = if ($script:cygwin_host) { "$link_dir/$link_name" } else { 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:cygwin_host) {
                ln.exe -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 '${{ steps.setup.outputs.gcc }}' cc
            Link-Exe '${{ steps.setup.outputs.gxx }}' c++
        }
      shell: pwsh

    - run: |
        New-Variable cygwin_host -Value ('${{ inputs.cygwin }}' -eq '1') -Option Constant
        New-Variable hardlinks -Value ('${{ inputs.hardlinks }}' -eq '1') -Option Constant

        if ($cygwin_host -and $hardlinks) {
            echo @'
        while IFS= read -d '' -r link_path; do
            dest_path="$( readlink --canonicalize-existing -- "$link_path" )"
            dest_ext=".${dest_path##*.}"
            [ "$dest_ext" == ".$dest_path" ] && dest_ext=
            link_ext=".${link_path##*.}"
            [ "$link_ext" == ".$link_path" ] && link_ext=
            echo "Removing symlink $link_path" && rm -f -- "$link_path"
            [ "$link_ext" != "$dest_ext" ] && echo "${PATHEXT//\;/
        }" | grep -q --ignore-case --line-regexp -F -- "$dest_ext" && link_path="$link_path$dest_ext"
            echo "Creating hardlink $link_path -> $dest_path" && ln -- "$dest_path" "$link_path"
        done < <( find /usr/local/bin /usr/bin \
                       -type l '-(' \
                       -path /usr/local/bin/cc -o \
                       -path /usr/local/bin/c++ \
                       '-)' -print0 )
        '@ | & bash.exe --login -o errexit -o nounset -o pipefail -o igncr
        }
      shell: pwsh

branding:
  icon: star
  color: green