package-validation.yml

parameters:
- name: arguments
  type: string
  default: ''
- name: unocheckArguments
  type: string
  default: ''
- name: xCodeRoot
  type: string
  default: ''

steps:
- checkout: self
  clean: 'true'

- bash: |
    # This list is based on what the base image contains and
    # may need to be adjusted as new software gets installed.
    # Use the `du` command below to determine what can be
    # uninstalled.
    
    rm -fR ~/.cargo
    rm -fR ~/.rustup
    rm -fR ~/.dotnet
    sudo rm -fR /usr/share/swift
    sudo rm -fR /opt/microsoft/msedge
    sudo rm -fR /usr/local/.ghcup
    sudo rm -fR /usr/lib/mono
    sudo snap remove lxd
    sudo snap remove core20
    sudo apt remove snapd

    df -h
    # du -h -d 3 /

  displayName: 'Cleanup unused image dependencies (Linux)'
  condition: eq(variables['Agent.OS'], 'Linux')

- powershell: |
    $templateArgs = '${{ parameters.arguments }}'
    echo "TemplateArgs = '$templateArgs'"
    $dotnetVersion = $env:TargetDotNetVersion
    $ValidationUnoCheckVersion = $env:ValidationUnoCheckVersionNet8
    if ($templateArgs -match 'net9.0')
    {
        $dotnetVersion = '9.0.100'
        $ValidationUnoCheckVersion = $env:ValidationUnoCheckVersionNet9
    }

    echo "##vso[task.setvariable variable=DotNetVersion]$dotnetVersion"
    echo "##vso[task.setvariable variable=ValidationUnoCheckVersion]$ValidationUnoCheckVersion"
  displayName: Evaluate Template Args
  env:
    TargetDotNetVersion: $(ValidationDotNetVersion)

# Install android 34 as we're running on macos-15, early so that
# the JDK override does not break the installer
- bash: |
    echo "y" | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --sdk_root=$ANDROID_HOME --install 'tools'| tr '\r' '\n' | uniq
    echo "y" | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --sdk_root=$ANDROID_HOME --install 'platform-tools'  | tr '\r' '\n' | uniq
    echo "y" | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --sdk_root=$ANDROID_HOME --install 'platforms;android-34' | tr '\r' '\n' | uniq
    echo "y" | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --sdk_root=$ANDROID_HOME --install 'build-tools;35.0.0' | tr '\r' '\n' | uniq
    echo "y" | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --sdk_root=$ANDROID_HOME --install 'build-tools;34.0.0' | tr '\r' '\n' | uniq
  displayName: Install Android 34
  condition: eq(variables['Agent.OS'], 'Darwin')

- template: dotnet-install-windows.yml
  parameters:
    DotNetVersion: $(DotNetVersion)

- task: DownloadBuildArtifacts@0
  inputs:
    artifactName: $(Build.DefinitionName)

- pwsh: |
      md $(Build.SourcesDirectory)/src/PackageCache
      copy "$(System.ArtifactsDirectory)/$(Build.DefinitionName)/*.nupkg" $(Build.SourcesDirectory)/src/PackageCache
  displayName: Copy Artifacts to PackageCache

- template: canary-updater.yml
  parameters:
    MergeBranch: false

- bash: |
    sudo rm -fR /usr/lib/jvm
    ubuntu_release=`lsb_release -rs` 
    wget  https://packages.microsoft.com/config/ubuntu/${ubuntu_release}/packages-microsoft-prod.deb -O packages-microsoft-prod.deb 
    sudo dpkg -i packages-microsoft-prod.deb 
    sudo apt-get install apt-transport-https 
    sudo apt-get update 
    sudo apt-get install -y msopenjdk-11
  displayName: OpenJDK (Linux)
  condition: eq(variables['Agent.OS'], 'Linux')

- powershell: |
    & dotnet tool install --global Uno.Check --version $env:ValidationUnoCheckVersion
    uno-check -v --ci --non-interactive --fix --skip androidemulator --skip dotnetnewunotemplates  ${{ parameters.unocheckArguments }}
  displayName: Uno Check (Linux)
  condition: eq(variables['Agent.OS'], 'Linux')
  env:
    ValidationUnoCheckVersion: $(ValidationUnoCheckVersion)
    JAVA_HOME: $(JAVA_HOME)

- powershell: |
    & dotnet tool install --global Uno.Check --version $env:ValidationUnoCheckVersion
    uno-check -v --ci --non-interactive --fix --skip androidemulator --skip androidsdk --skip gtk3 --skip xcode --skip vswin --skip vsmac --skip dotnetnewunotemplates  ${{ parameters.unocheckArguments }}
  displayName: Uno Check (macOS)
  condition: eq(variables['Agent.OS'], 'Darwin')
  env:
    ValidationUnoCheckVersion: $(ValidationUnoCheckVersion)
    JAVA_HOME: $(JAVA_HOME)

- bash: |
    echo 'xCode Root to ${{parameters.xCodeRoot}}'
    echo '##vso[task.setvariable variable=MD_APPLE_SDK_ROOT;]'${{parameters.xCodeRoot}}
    sudo xcode-select --switch ${{parameters.xCodeRoot}}/Contents/Developer

  condition: eq(variables['Agent.OS'], 'Darwin')
  displayName: Select Xcode

- bash: |
    brew install ninja

  condition: eq(variables['Agent.OS'], 'Darwin')
  displayName: Install ninja

- powershell: |
    & dotnet tool install --global Uno.Check --version $env:ValidationUnoCheckVersion
    uno-check -v --ci --non-interactive --fix --skip xcode --skip gtk3 --skip vswin --skip openjdk --skip androidemulator --skip androidsdk --skip vsmac --skip dotnetnewunotemplates  ${{ parameters.unocheckArguments }}
  displayName: Uno Check (Windows)
  condition: eq(variables['Agent.OS'], 'Windows_NT')
  env:
    ValidationUnoCheckVersion: $(ValidationUnoCheckVersion)

- script: dotnet new install "$(System.ArtifactsDirectory)/$(Build.DefinitionName)/Uno.Templates*.nupkg"
  displayName: Install Project Templates

- bash: |
    find ~/.nuget -type f -name "*.nupkg" -exec rm {} \;
    df -h
  displayName: Cleanup nupkg from package cache
  condition: eq(variables['Agent.OS'], 'Linux')

- pwsh: |
      dotnet nuget add source -n nuget_local $(Build.SourcesDirectory)/src/PackageCache
      dotnet nuget add source -n uno_dev "https://pkgs.dev.azure.com/uno-platform/1dd81cbd-cb35-41de-a570-b0df3571a196/_packaging/unoplatformdev/nuget/v3/index.json"
      dotnet nuget add source -n net8 "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet8/nuget/v3/index.json"
  displayName: Setup nuget sources

- pwsh: |
    #Set-PSDebug -Trace 1
    $ErrorActionPreference = 'Stop'

    # Escape quotes properly
    $validationsArray = ('${{ replace(parameters.arguments, '""', '`""') }}' -split '\r?\n').Trim()

    # write currently running dotnet version in a variable
    $dotnetVersion = dotnet --version

    echo "Running validations for:"

    $validations=@{}
    $buildFailures=@()

    foreach($validation in $validationsArray)
    {
      # Skip commented out tests
      if($validation.StartsWith('#'))
      {
        continue
      }

      $fields = ($validation -split ';').Trim()

      if($fields[0])
      {      
        $validations.Add($fields[0], @($fields[2],$fields[1]))
        echo "- $($fields[0]), $($fields[2]) (Filter: $($fields[1]))"
      }
    }

    $currentTest=0;

    foreach($validation in $validations.Keys)
    {
      $testName = $validation;
      $testParams = $validations[$validation][0];
      $environmentFilter = $validations[$validation][1];

      # Skip testing for the wrong environment
      if($environmentFilter -eq "Windows" -and !$IsWindows)
      {
        echo "Skipping $testName ($testParams) because it's only for Windows"
        continue
      }

      if($environmentFilter -eq "Linux" -and !$IsLinux)
      {
        echo "Skipping $testName ($testParams) because it's only for Linux"
        continue
      }

      if ($testParams.Contains('net9.0') -and $IsWindows)
      {
        if($testName -eq "MauiBlank" -or $testName -eq "MauiRecommended" -or $testName -eq "Issue396")
        {
          echo "Skipping $testName ($testParams) on net9.0 Windows because of https://github.com/unoplatform/uno.csharpmarkup/issues/787"
          continue
        }
      }

      echo "Testing $testName ($testParams)"

      # Set the progress to report on azdo UI
      $progress = ($currentTest / $validations.Keys.Count) * 100;
      echo "Progress: {$progress}"
      echo "##vso[task.setprogress value=$progress;]$testName"

      # Split the string containing parameters with respect for quotes, so parameters can be 
      # passed properly to the dotnet new command. (the string would be interpreted as a single parameter otherwise)
      if($testParams)
      {
        $dotnetNewParams = ($testParams -replace "`n"," " -replace "`r"," ") -split ' (?=(?:[^"]|"[^"]*")*$)' | ForEach-Object { $_ -replace '"', '' } | Where-Object { -not [string]::IsNullOrWhiteSpace($_) }
      }
      else
      {
        # avoid passing an empty array
        Remove-Variable -name dotnetNewParams -ErrorAction SilentlyContinue
      }

      # Create the app solution
      & dotnet new unoapp -skip -o $testName $dotnetNewParams

      if ($LASTEXITCODE -ne 0)
      {
        echo "Template creation failed for $testName"
        $buildFailures += , "$testName";
      }
      else
      {
        # Build the app
        pushd $testName 
        & dotnet build $testName.sln "/bl:$(System.ArtifactsDirectory)/$testName.$(Agent.OS).$dotnetVersion.binlog"
        if ($LASTEXITCODE -ne 0)
        {
          echo "Build failed for $testName"
          $buildFailures += , "$testName";
        }
        popd

        # Clean the folder to continue testing with limited disk space
        Remove-Item -Recurse -Force $testName -ErrorAction Continue

        if ($IsLinux)
        {
          echo "Show disk usage"
          & df -h
        }
      }

      $currentTest = $currentTest + 1;
    }

    if($buildFailures.Length -gt 0)
    {
      echo "Validation failed for :"

      foreach($buildFailure in $buildFailures)
      {
        echo "- $buildFailure"
      }

      throw "Exit code must be zero."
    }

  displayName: Test all scenarios

- task: PublishBuildArtifacts@1
  condition: always()
  retryCountOnTaskFailure: 3
  inputs:
    PathtoPublish: $(build.artifactstagingdirectory)
    ArtifactName: logs
    ArtifactType: Container