parameters:
  buildConfig: ''
  osGroup: ''
  archType: ''
  osSubgroup: ''
  platform: ''
  crossBuild: false
  timeoutInMinutes: 120
  condition: true
  shouldContinueOnError: false
  container: ''
  buildSteps: []
  dependsOn: []
  dependsOnGlobalBuild: false
  dependOnEvaluatePaths: false
  globalBuildSuffix: ''
  variables: []
  name: ''
  displayName: ''
  runtimeVariant: ''
  pool: ''
  pgoType: ''
  runOnlyIfDependenciesSucceeded: false

  # The target names here should match container names in the resources section in our pipelines, like runtime.yml
  packageDistroList:
  - target: debpkg
    packageType: deb
    packagingArgs: /p:BuildDebPackage=true
  - target: rpmpkg
    packageType: rpm
    packagingArgs: /p:BuildRpmPackage=true

  isOfficialBuild: false
  buildFullPlatformManifest: false

  liveRuntimeBuildConfig: ''
  liveLibrariesBuildConfig: ''
  runtimeFlavor: 'coreclr'

### Product build
jobs:
- template: /eng/common/templates/job/job.yml
  parameters:
    buildConfig: ${{ parameters.buildConfig }}
    archType: ${{ parameters.archType }}
    osGroup: ${{ parameters.osGroup }}
    osSubgroup: ${{ parameters.osSubgroup }}
    runtimeVariant: ${{ parameters.runtimeVariant }}
    testGroup: ${{ parameters.testGroup }}
    helixType: 'build/product/'
    enableMicrobuild: true
    stagedBuild: ${{ parameters.stagedBuild }}
    pool: ${{ parameters.pool }}

    ${{ if eq(parameters.runOnlyIfDependenciesSucceeded, true) }}:
      condition: and(succeeded(), ${{ parameters.condition }})
    ${{ if ne(parameters.runOnlyIfDependenciesSucceeded, true) }}:
      condition: ${{ parameters.condition }}

    dependOnEvaluatePaths: ${{ parameters.dependOnEvaluatePaths }}
    disableClrTest: ${{ parameters.disableClrTest }}
    pgoType: ${{ parameters.pgoType }}

    # Compute job name from template parameters
    name: ${{ format('installer_{0}_{1}_{2}_{3}_{4}_', parameters.pgoType, parameters.runtimeFlavor, parameters.runtimeVariant, coalesce(parameters.name, parameters.platform), parameters.buildConfig) }}
    displayName: ${{ format('{0} Installer Build and Test {1} {2} {3} {4}', parameters.pgoType, parameters.runtimeFlavor, parameters.runtimeVariant, coalesce(parameters.name, parameters.platform), parameters.buildConfig) }}

    # Run all steps in the container.
    # Note that the containers are defined in platform-matrix.yml
    container: ${{ parameters.container }}

    timeoutInMinutes: ${{ parameters.timeoutInMinutes }}

    crossBuild: ${{ parameters.crossBuild }}

    gatherAssetManifests: true
    variables:
    - ${{ each variable in parameters.variables }}:
      - ${{ variable }}

    - name: OfficialBuildArg
      value: ''

    - name: SkipTests
      value: ${{ or(
        not(in(parameters.archType, 'x64', 'x86')),
        eq(parameters.runtimeFlavor, 'mono'),
        eq(parameters.isOfficialBuild, true),
        eq(parameters.crossBuild, true),
        eq(parameters.pgoType, 'PGO')) }}

    - name: BuildAction
      value: -test

    - ${{ if eq(or(not(in(parameters.archType, 'x64', 'x86')), eq(parameters.runtimeFlavor, 'mono'), eq(parameters.isOfficialBuild, true), eq(parameters.crossBuild, true), eq(parameters.pgoType, 'PGO')), true) }}:
      - name: BuildAction
        value: ''

    - name: SignType
      value: test

    - name: pgoInstrumentArg
      value: ''
    - ${{ if eq(parameters.pgoType, 'PGO' )}}:
      - name: pgoInstrumentArg
        value: '-pgoinstrument '

    # Set up non-PR build from internal project
    - ${{ if eq(parameters.isOfficialBuild, true) }}:
      - name: SignType
        value: $[ coalesce(variables.OfficialSignType, 'real') ]
      - name: OfficialBuildArg
        value: /p:OfficialBuildId=$(Build.BuildNumber)

    - name: buildCommandSourcesDirectory
      value: '$(Build.SourcesDirectory)/'

    ###
    ### Platform-specific variable setup
    ###

    - ${{ if eq(parameters.osGroup, 'windows') }}:

      - name: CommonMSBuildArgs
        value: >-
          /p:TargetArchitecture=${{ parameters.archType }}
          /p:PortableBuild=true
          /p:SkipTests=$(SkipTests)
          /p:RuntimeFlavor=${{ parameters.runtimeFlavor }}
          $(OfficialBuildArg)
      - name: MsbuildSigningArguments
        value: >-
          /p:CertificateId=400
          /p:DotNetSignType=$(SignType)
      - name: TargetArchitecture
        value: ${{ parameters.archType }}

      - name: BaseJobBuildCommand
        value: >-
          build.cmd -subset host+packs -ci
          $(BuildAction)
          -configuration $(_BuildConfig)
          $(pgoInstrumentArg)
          $(LiveOverridePathArgs)
          $(CommonMSBuildArgs)
          $(MsbuildSigningArguments)

    - ${{ if eq(parameters.osGroup, 'OSX') }}:

      - name: CommonMSBuildArgs
        value: >-
          /p:PortableBuild=true
          /p:SkipTests=$(SkipTests)
          /p:RuntimeFlavor=${{ parameters.runtimeFlavor }}
          /p:TargetArchitecture=${{ parameters.archType }}
          /p:CrossBuild=${{ parameters.crossBuild }}

      - name: BaseJobBuildCommand
        value: >-
          $(Build.SourcesDirectory)/build.sh -ci
          $(BuildAction)
          -configuration $(_BuildConfig)
          -arch ${{ parameters.archType }}
          $(LiveOverridePathArgs)
          $(CommonMSBuildArgs)
          $(OfficialBuildArg)

    - ${{ if in(parameters.osGroup, 'iOS', 'tvOS', 'Android', 'Browser') }}:

      - name: CommonMSBuildArgs
        value: >-
          /p:PortableBuild=true
          /p:SkipTests=$(SkipTests)

      - name: BaseJobBuildCommand
        value: >-
          $(Build.SourcesDirectory)/build.sh -subset packs -ci
          $(BuildAction)
          -configuration $(_BuildConfig)
          -os ${{ parameters.osGroup }}
          -arch ${{ parameters.archType }}
          /p:StripSymbols=true
          $(LiveOverridePathArgs)
          $(CommonMSBuildArgs)
          $(OfficialBuildArg)

    - ${{ if in(parameters.osGroup, 'Linux', 'FreeBSD') }}:
      - name: CommonMSBuildArgs
        value: >-
          /p:Configuration=$(_BuildConfig)
          /p:TargetOS=${{ parameters.osGroup }}
          /p:TargetArchitecture=${{ parameters.archType }}
          /p:RuntimeFlavor=${{ parameters.runtimeFlavor }}
          $(OfficialBuildArg)

      - name: _PortableBuild
        value: ${{ eq(parameters.osSubgroup, '') }}

      - ${{ if and(eq(parameters.osSubgroup, '_musl'), eq(parameters.osGroup, 'Linux')) }}:
        - name: _PortableBuild
          value: true

      - ${{ if eq(parameters.crossBuild, true) }}:
        - name: ArchArg
          value: -arch ${{ parameters.archType }}

      - name: BaseJobBuildCommand
        value: >-
          $(Build.SourcesDirectory)/build.sh -subset host+packs -ci
          $(BuildAction)
          $(ArchArg)
          /p:CrossBuild=${{ parameters.crossBuild }}
          /p:PortableBuild=$(_PortableBuild)
          /p:SkipTests=$(SkipTests)
          $(pgoInstrumentArg)
          $(LiveOverridePathArgs)
          $(CommonMSBuildArgs)

      - name: installersSubsetArg
        value: --subset packs.installers

    ###
    ### Common Live build override variable setup
    ###

    - name: LiveOverridePathArgs
      value: >-
        $(RuntimeArtifactsArgs)
        $(LibrariesConfigurationArg)

    - name: RuntimeArtifactsArgs
      value: ''
    - name: LibrariesConfigurationArg
      value: ''

    - name: RuntimeDownloadPath
      value: ''
    - name: LibrariesDownloadPath
      value: ''

    - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
      - name: liveRuntimeLegName
        value: ${{ format('{0}{1}_{2}_{3}',
          parameters.osGroup,
          parameters.osSubgroup,
          parameters.archType,
          parameters.liveRuntimeBuildConfig) }}
      - name: RuntimeDownloadPath
        value: 'artifacts/transport/${{ parameters.runtimeFlavor }}'
      - name: RuntimeArtifactsArgs
        value: >-
          /p:RuntimeArtifactsPath=$(buildCommandSourcesDirectory)$(RuntimeDownloadPath)
          /p:RuntimeConfiguration=${{ parameters.liveRuntimeBuildConfig }}
      - name: RuntimeArtifactName
        value: $(runtimeFlavorName)Product_${{ parameters.pgoType }}_${{ parameters.runtimeVariant }}_$(liveRuntimeLegName)

    - ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
      - name: liveLibrariesLegName
        value: ${{ format('{0}{1}_{2}_{3}',
          parameters.osGroup,
          parameters.osSubgroup,
          parameters.archType,
          parameters.liveLibrariesBuildConfig) }}
      - name: LibrariesDownloadPath
        value: 'artifacts'
      - name: LibrariesArtifactName
        value: libraries_bin_$(liveLibrariesLegName)
      - name: LibrariesConfigurationArg
        value: ' /p:LibrariesConfiguration=${{ parameters.liveLibrariesBuildConfig }}'

    dependsOn:
    - ${{ if eq(parameters.dependOnEvaluatePaths, true) }}:
      - evaluate_paths
    - ${{ parameters.dependsOn }}
    - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
      - ${{ format('{0}_{1}_product_build_{2}{3}_{4}_{5}{6}',
          parameters.runtimeFlavor,
          parameters.runtimeVariant,
          parameters.osGroup,
          parameters.osSubgroup,
          parameters.archType,
          parameters.liveRuntimeBuildConfig,
          parameters.pgoType) }}
    - ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
      - libraries_build_${{ format('{0}{1}_{2}_{3}',
          parameters.osGroup,
          parameters.osSubgroup,
          parameters.archType,
          parameters.liveLibrariesBuildConfig) }}
    steps:
      - checkout: self
        clean: true
        fetchDepth: $(checkoutFetchDepth)
      - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
        - template: /eng/pipelines/common/download-artifact-step.yml
          parameters:
            unpackFolder: $(Build.SourcesDirectory)/$(RuntimeDownloadPath)
            artifactFileName: '$(RuntimeArtifactName)$(archiveExtension)'
            artifactName: '$(RuntimeArtifactName)'
            displayName: '$(runtimeFlavorName) artifacts'

      - ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
        - template: /eng/pipelines/common/download-artifact-step.yml
          parameters:
            unpackFolder: $(Build.SourcesDirectory)/$(LibrariesDownloadPath)
            artifactFileName: '$(LibrariesArtifactName)$(archiveExtension)'
            artifactName: '$(LibrariesArtifactName)'
            displayName: 'Libraries artifacts'
            cleanUnpackFolder: false

      - ${{ if in(parameters.osGroup, 'OSX', 'iOS', 'tvOS') }}:
        - script: $(Build.SourcesDirectory)/eng/install-native-dependencies.sh ${{ parameters.osGroup }}
          displayName: Install Build Dependencies

        - script: |
            du -sh $(Build.SourcesDirectory)/*
            df -h
          displayName: Disk Usage before Build

    # Build the default subset non-MacOS platforms
      - ${{ if ne(parameters.osGroup, 'OSX') }}:
        - script: $(BaseJobBuildCommand)
          displayName: Build
          continueOnError: ${{ and(eq(variables.SkipTests, false), eq(parameters.shouldContinueOnError, true)) }}

      # Build corehost, sign and add entitlements to MacOS binaries
      - ${{ if eq(parameters.osGroup, 'OSX') }}:
        - script: $(BaseJobBuildCommand) -subset host.native
          displayName: Build CoreHost
          continueOnError: ${{ and(eq(variables.SkipTests, false), eq(parameters.shouldContinueOnError, true)) }}

        - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
          - template: /eng/pipelines/common/macos-sign-with-entitlements.yml
            parameters:
              filesToSign:
              - name: dotnet
                path: $(Build.SourcesDirectory)/artifacts/bin/osx-${{ parameters.archType }}.$(_BuildConfig)/corehost
                entitlementsFile: $(Build.SourcesDirectory)/eng/pipelines/common/entitlements.plist
              - name: apphost
                path: $(Build.SourcesDirectory)/artifacts/bin/osx-${{ parameters.archType }}.$(_BuildConfig)/corehost
                entitlementsFile: $(Build.SourcesDirectory)/eng/pipelines/common/entitlements.plist

        - script: $(BaseJobBuildCommand) -subset host.pkg+host.tools+host.tests+packs
          displayName: Build and Package
          continueOnError: ${{ and(eq(variables.SkipTests, false), eq(parameters.shouldContinueOnError, true)) }}

      - ${{ if in(parameters.osGroup, 'OSX', 'iOS', 'tvOS') }}:
        - script: |
            du -sh $(Build.SourcesDirectory)/*
            df -h
          displayName: Disk Usage after Build

      # Only in glibc leg, we produce RPMs and Debs
      - ${{ if and(eq(parameters.runtimeFlavor, 'coreclr'), or(eq(parameters.platform, 'Linux_x64'), eq(parameters.platform, 'Linux_arm64')), eq(parameters.osSubgroup, ''), eq(parameters.pgoType, ''))}}:
        - ${{ each packageBuild in parameters.packageDistroList }}:
          # This leg's RID matches the build image. Build its distro-dependent packages, as well as
          # the distro-independent installers. (There's no particular reason to build the distro-
          # independent installers on this leg, but we need to do it somewhere.)
          # Currently, Linux_arm64 supports 'rpm' type only.
          - ${{ if or(not(eq(parameters.platform, 'Linux_arm64')), eq(packageBuild.packageType, 'rpm')) }}:
            - template: /eng/pipelines/installer/jobs/steps/build-linux-package.yml
              parameters:
                packageType: ${{ packageBuild.packageType }}
                target: ${{ packageBuild.target }}
                packageStepDescription: Runtime Deps, Runtime, Framework Packs installers
                subsetArg: $(installersSubsetArg)
                packagingArgs: ${{ packageBuild.packagingArgs }}

      - ${{ if and(eq(parameters.osGroup, 'windows'), eq(parameters.isOfficialBuild, true)) }}:
        - task: NuGetCommand@2
          displayName: Push Visual Studio NuPkgs
          inputs:
            command: push
            packagesToPush: '$(Build.SourcesDirectory)/artifacts/packages/$(_BuildConfig)/*/VS.Redist.Common.*.nupkg'
            nuGetFeedType: external
            publishFeedCredentials: 'DevDiv - VS package feed'
          condition: and(
            succeeded(),
            eq(variables['_BuildConfig'], 'Release'),
            ne(variables['DisableVSPublish'], 'true'),
            ne(variables['PostBuildSign'], 'true'))

      - template: /eng/pipelines/installer/jobs/steps/upload-job-artifacts.yml
        parameters:
          name: ${{ coalesce(parameters.name, parameters.platform) }}
          runtimeFlavor: ${{ parameters.runtimeFlavor }}
          runtimeVariant: ${{ parameters.runtimeVariant }}
          isOfficialBuild: ${{ eq(parameters.isOfficialBuild, true) }}
          pgoType: ${{ parameters.pgoType }}

      - ${{ if ne(parameters.osGroup, 'windows') }}:
        - script: set -x && df -h
          displayName: Check remaining storage space
          condition: always()
          continueOnError: true