# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
param(
    [ValidateSet('Bootstrap','Build','Failure','Success')]
    [String]$Stage = 'Build',
    [String]$NugetKey
)

Import-Module $PSScriptRoot/../build.psm1 -Force
Import-Module $PSScriptRoot/packaging -Force

function Send-DailyWebHook
{
    param (
        [Parameter(Mandatory=$true,Position=0)][ValidateSet("Pass","Fail")]$result
        )

    # Only send web hook if the environment variable is present
    # Varible should be set in Travis-CI.org settings
    if ($env:WebHookUrl)
    {
        Write-Log "Sending DailyWebHook with result '$result'."
        $webhook = $env:WebHookUrl

        $Body = @{
                'text'= @"
Build Result: $result </br>
OS Type: $($PSVersionTable.OS) </br>
<a href="https://travis-ci.org/$env:TRAVIS_REPO_SLUG/builds/$env:TRAVIS_BUILD_ID">Build $env:TRAVIS_BUILD_NUMBER</a>  </br>
<a href="https://travis-ci.org/$env:TRAVIS_REPO_SLUG/jobs/$env:TRAVIS_JOB_ID">Job $env:TRAVIS_JOB_NUMBER</a>
"@
        }

        $params = @{
            Headers = @{'accept'='application/json'}
            Body = $Body | convertto-json
            Method = 'Post'
            URI = $webhook
        }

        Invoke-RestMethod @params
    }
    else
    {
        Write-Log "Skipping DailyWebHook.  WebHookUrl environment variable not present."
    }
}

function Get-ReleaseTag
{
    $metaDataPath = Join-Path -Path $PSScriptRoot -ChildPath 'metadata.json'
    $metaData = Get-Content $metaDataPath | ConvertFrom-Json

    $releaseTag = $metadata.PreviewReleaseTag
    $previewVersion = $releaseTag.Split('-')
    $previewPrefix = $previewVersion[0]
    $previewLabel = $previewVersion[1].replace('.','')

    if($isDailyBuild)
    {
        $previewLabel= "daily{0}" -f $previewLabel
    }

    $preReleaseVersion = "$previewPrefix-$previewLabel.$env:BUILD_BUILDID"

    return $preReleaseVersion
}

# This function retrieves the appropriate svg to be used when presenting
# the daily test run badge
# the location in azure is public readonly
function Get-DailyBadge
{
    param (
        [Parameter(Mandatory=$true,Position=0)][ValidateSet("Pass","Fail")]$result
        )
    $PASS = "https://jimtru1979.blob.core.windows.net/badges/DailyBuild.Pass.svg"
    $FAIL = "https://jimtru1979.blob.core.windows.net/badges/DailyBuild.Fail.svg"

    if ( $result -eq "Pass" ) { $BadgeUrl = $PASS } else { $BadgeUrl = $FAIL }
    $response = Invoke-WebRequest -Uri $BadgeUrl
    if ( $response.StatusCode -ne 200 ) { throw "Could not read badge '$BadgeUrl'" }
    $response.Content
}

# This function uses Azure REST api to update the daily test pass results
# it relies on writing a specific SVG into a constant location so the
# README.MD can report on the status of the daily test pass
# it also relies on two environment variables which need to be set in the
# Travis-CI config which is the account name and key for the azure blob location
#
# the best way to do this would be if travis-ci supported a webcall to get
# the status of cron_job builds, but it doesn't, so we have this
# also, since we can have a build on Linux which succeeds and one on macOS which
# doesn't we'll set the appropriate badge so the the README can pick it up
function Set-DailyBuildBadge
{
    [CmdletBinding(SupportsShouldProcess=$true)]
    param ( [Parameter(Mandatory=$true,Position=0)]$content )
    $method = "PUT"
    $headerDate = '2015-12-11'

    $storageAccountName = $Env:TestResultAccountName
    $storageAccountKey = $Env:TestResultAccountKey

    # this is the url referenced in README.MD which displays the badge
    $platform = if ( $IsLinux ) { "Linux" } else { "OSX" }
    $Url = "https://jimtru1979.blob.core.windows.net/badges/DailyBuildStatus.${platform}.svg"

    $body = $content
    $bytes = ([System.Text.Encoding]::UTF8.GetBytes($body))
    $contentLength = $bytes.length

    $now = [datetime]::UtcNow.ToString("R", [System.Globalization.CultureInfo]::InvariantCulture)
    $headers = @{
        "x-ms-date"      = $now
        "cache-control"  = "no-cache"
        "x-ms-blob-type" = "BlockBlob"
        "x-ms-version"   = "$headerDate"
    }

    $contentType = "image/svg+xml"
    # more info: https://docs.microsoft.com/rest/api/storageservices/fileservices/put-blob
    $sb = [text.stringbuilder]::new()
    # can't use AppendLine because the `r`n causes the command to fail, it must be `n and only `n
    $null = $sb.Append("$method`n")
    $null = $sb.Append("`n")
    $null = $sb.Append("`n")
    $null = $sb.Append("$contentLength`n")
    $null = $sb.Append("`n")
    $null = $sb.Append("$contentType`n")
    $null = $sb.Append("`n")
    $null = $sb.Append("`n")
    $null = $sb.Append("`n")
    $null = $sb.Append("`n")
    $null = $sb.Append("`n")
    $null = $sb.Append("`n")

    $null = $sb.Append("x-ms-blob-type:" + $headers["x-ms-blob-type"] + "`n")
    $null = $sb.Append("x-ms-date:" + $headers["x-ms-date"] + "`n")
    $null = $sb.Append("x-ms-version:" + $headers["x-ms-version"] + "`n")
    $null = $sb.Append("/" + $storageAccountName + ([System.Uri]::new($url).AbsolutePath))

    $dataToMac = [System.Text.Encoding]::UTF8.GetBytes($sb.ToString())
    $accountKeyBytes = [System.Convert]::FromBase64String($storageAccountKey)
    $hmac = [System.Security.Cryptography.HMACSHA256]::new($accountKeyBytes)
    $signature = [System.Convert]::ToBase64String($hmac.ComputeHash($dataToMac))

    $headers["Authorization"]  = "SharedKey " + $storageAccountName + ":" + $signature

    if ( $PSCmdlet.ShouldProcess("$signaturestring"))
    {
        # if this fails, it will throw, you can't check the response for a success code
        $response = Invoke-RestMethod -Uri $Url -Method $method -headers $headers -Body $body -ContentType "image/svg+xml"
    }
}

# https://docs.travis-ci.com/user/environment-variables/
# TRAVIS_EVENT_TYPE: Indicates how the build was triggered.
# One of push, pull_request, api, cron.
$isPR = $env:TRAVIS_EVENT_TYPE -eq 'pull_request'

$commitMessage = [string]::Empty

# For PRs, Travis-ci strips out [ and ] so read the message directly from git
if($env:TRAVIS_EVENT_TYPE -eq 'pull_request' -or $env:BUILD_REASON)
{
    $commitId = $null
    if ($env:TRAVIS_EVENT_TYPE)
    {
        # We are in Travis-CI
        $commitId = $env:TRAVIS_PULL_REQUEST_SHA

        # If the current job is a pull request, the env variable 'TRAVIS_PULL_REQUEST_SHA' contains
        # the commit SHA of the HEAD commit of the PR.
        $commitMessage = git log --format=%B -n 1 $commitId
        Write-Log -message "commitMessage: $commitMessage"
    }
    elseif($env:TF_BUILD)
    {
        if($env:BUILD_SOURCEVERSIONMESSAGE -match 'Merge\s*([0-9A-F]*)')
        {
            # We are in VSTS and have a commit ID in the Source Version Message
            $commitId = $Matches[1]
            $commitMessage = git log --format=%B -n 1 $commitId
        }
        else
        {
            Write-Log "Unknown BUILD_SOURCEVERSIONMESSAGE format '$env:BUILD_SOURCEVERSIONMESSAGE'" -Verbose
        }
    }
}
else
{
    $commitMessage = $env:TRAVIS_COMMIT_MESSAGE
}

# Run a full build if the build was trigger via cron, api or the commit message contains `[Feature]`
# or the environment variable `FORCE_FEATURE` equals `True`
$hasFeatureTag = $commitMessage -match '\[feature\]' -or $env:FORCE_FEATURE -eq 'True'

# Run a packaging if the commit message contains `[Package]`
# or the environment variable `FORCE_PACKAGE` equals `True`
$hasPackageTag = $commitMessage -match '\[package\]' -or $env:FORCE_PACKAGE -eq 'True'
$createPackages = -not $isPr -or $hasPackageTag
$hasRunFailingTestTag = $commitMessage -match '\[includeFailingTest\]'
$isDailyBuild = $env:TRAVIS_EVENT_TYPE -eq 'cron' -or $env:TRAVIS_EVENT_TYPE -eq 'api' -or $env:BUILD_REASON -eq 'Schedule'
# only update the build badge for the cron job
$cronBuild = $env:TRAVIS_EVENT_TYPE -eq 'cron' -or $env:BUILD_REASON -eq 'Schedule'
$isFullBuild = $isDailyBuild -or $hasFeatureTag

if($Stage -eq 'Bootstrap')
{
    if($cronBuild -and $env:TF_BUILD)
    {
        Write-Host "##vso[build.updatebuildnumber]Daily-$env:BUILD_SOURCEBRANCHNAME-$env:BUILD_SOURCEVERSION-$((get-date).ToString("yyyyMMddhhmmss"))"
    }

    Write-Host -Foreground Green "Executing travis.ps1 -BootStrap `$isPR='$isPr' - $commitMessage"
    # Make sure we have all the tags
    Sync-PSTags -AddRemoteIfMissing
    Start-PSBootstrap -Package:$createPackages
}
elseif($Stage -eq 'Build')
{
    $releaseTag = Get-ReleaseTag

    Write-Host -Foreground Green "Executing travis.ps1 `$isPR='$isPr' `$isFullBuild='$isFullBuild' - $commitMessage"

    $originalProgressPreference = $ProgressPreference
    $ProgressPreference = 'SilentlyContinue'
    try {
        ## We use CrossGen build to run tests only if it's the daily build.
        Start-PSBuild -CrossGen -PSModuleRestore -CI -ReleaseTag $releaseTag -Configuration 'Release'
    }
    finally{
        $ProgressPreference = $originalProgressPreference
    }

    $output = Split-Path -Parent (Get-PSOutput -Options (Get-PSOptions))

    $testResultsNoSudo = "$pwd/TestResultsNoSudo.xml"
    $testResultsSudo = "$pwd/TestResultsSudo.xml"

    $excludeTag = @('RequireSudoOnUnix')

    $noSudoPesterParam = @{
        'BinDir'     = $output
        'PassThru'   = $true
        'Terse'      = $true
        'Tag'        = @()
        'ExcludeTag' = $excludeTag
        'OutputFile' = $testResultsNoSudo
    }

    if ($isFullBuild) {
        $noSudoPesterParam['Tag'] = @('CI','Feature','Scenario')
    } else {
        $noSudoPesterParam['Tag'] = @('CI')
        $noSudoPesterParam['ThrowOnFailure'] = $true
    }

    if ($hasRunFailingTestTag) {
        $noSudoPesterParam['IncludeFailingTest'] = $true
    }

    # Get the experimental feature names and the tests associated with them
    $ExperimentalFeatureTests = Get-ExperimentalFeatureTests

    # Running tests which do not require sudo.
    $pesterPassThruNoSudoObject = Start-PSPester @noSudoPesterParam -Title 'Pester No Sudo'

    # Running tests that do not require sudo, with specified experimental features enabled
    $noSudoResultsWithExpFeatures = @()
    foreach ($entry in $ExperimentalFeatureTests.GetEnumerator()) {
        $featureName = $entry.Key
        $testFiles = $entry.Value

        $expFeatureTestResultFile = "$pwd\TestResultsNoSudo.$featureName.xml"
        $noSudoPesterParam['OutputFile'] = $expFeatureTestResultFile
        $noSudoPesterParam['ExperimentalFeatureName'] = $featureName
        if ($testFiles.Count -eq 0) {
            # If an empty array is specified for the feature name, we run all tests with the feature enabled.
            # This allows us to prevent regressions to a critical engine experimental feature.
            $noSudoPesterParam.Remove('Path')
        } else {
            # If a non-empty string or array is specified for the feature name, we only run those test files.
            $noSudoPesterParam['Path'] = $testFiles
        }
        $passThruResult = Start-PSPester @noSudoPesterParam -Title "Pester Experimental No Sudo - $featureName"
        $noSudoResultsWithExpFeatures += $passThruResult
    }

    # Running tests, which require sudo.
    $sudoPesterParam = $noSudoPesterParam.Clone()
    $sudoPesterParam.Remove('Path')
    $sudoPesterParam['Tag'] = @('RequireSudoOnUnix')
    $sudoPesterParam['ExcludeTag'] = @()
    $sudoPesterParam['Sudo'] = $true
    $sudoPesterParam['OutputFile'] = $testResultsSudo
    $pesterPassThruSudoObject = Start-PSPester @sudoPesterParam -Title 'Pester Sudo'

    # Running tests that require sudo, with specified experimental features enabled
    $sudoResultsWithExpFeatures = @()
    foreach ($entry in $ExperimentalFeatureTests.GetEnumerator()) {
        $featureName = $entry.Key
        $testFiles = $entry.Value

        $expFeatureTestResultFile = "$pwd\TestResultsSudo.$featureName.xml"
        $sudoPesterParam['OutputFile'] = $expFeatureTestResultFile
        $sudoPesterParam['ExperimentalFeatureName'] = $featureName
        if ($testFiles.Count -eq 0) {
            # If an empty array is specified for the feature name, we run all tests with the feature enabled.
            # This allows us to prevent regressions to a critical engine experimental feature.
            $sudoPesterParam.Remove('Path')
        } else {
            # If a non-empty string or array is specified for the feature name, we only run those test files.
            $sudoPesterParam['Path'] = $testFiles
        }
        $passThruResult = Start-PSPester @sudoPesterParam -Title "Pester Experimental Sudo - $featureName"
        $sudoResultsWithExpFeatures += $passThruResult
    }

    # Determine whether the build passed
    try {
        $allTestResultsWithNoExpFeature = @($pesterPassThruNoSudoObject, $pesterPassThruSudoObject)
        $allTestResultsWithExpFeatures = $noSudoResultsWithExpFeatures + $sudoResultsWithExpFeatures
        # this throws if there was an error
        $allTestResultsWithNoExpFeature | ForEach-Object { Test-PSPesterResults -ResultObject $_ }
        $allTestResultsWithExpFeatures  | ForEach-Object { Test-PSPesterResults -ResultObject $_ -CanHaveNoResult }
        $result = "PASS"
    }
    catch {
        $resultError = $_
        $result = "FAIL"
    }

    try {
        $ParallelXUnitTestResultsFile = "$pwd/ParallelXUnitTestResults.xml"

        Start-PSxUnit -ParallelTestResultsFile $ParallelXUnitTestResultsFile
        # If there are failures, Test-XUnitTestResults throws
        Test-XUnitTestResults -TestResultsFile $ParallelXUnitTestResultsFile
    }
    catch {
        $result = "FAIL"
        if (!$resultError)
        {
            $resultError = $_
        }
    }

    if ($createPackages) {

        $packageParams = @{}
        $packageParams += @{ReleaseTag=$releaseTag}

        # Only build packages for branches, not pull requests
        $packages = @(Start-PSPackage @packageParams -SkipReleaseChecks)
        foreach($package in $packages)
        {
            # Publish the packages to the nuget feed if:
            # 1 - It's a Daily build (already checked, for not a PR)
            # 2 - We have the info to publish (NUGET_KEY and NUGET_URL)
            # 3 - it's a nupkg file
            if($isDailyBuild -and $NugetKey -and $env:NUGET_URL -and [system.io.path]::GetExtension($package) -ieq '.nupkg')
            {
                Write-Log "pushing $package to $env:NUGET_URL"
                Start-NativeExecution -sb {dotnet nuget push $package --api-key $NugetKey --source "$env:NUGET_URL/api/v2/package"} -IgnoreExitcode
            }
        }
        if ($IsLinux)
        {
            # Create and package Raspbian .tgz
            Start-PSBuild -PSModuleRestore -Clean -Runtime linux-arm -Configuration 'Release'
            Start-PSPackage @packageParams -Type tar-arm -SkipReleaseChecks
        }

        if ($isDailyBuild)
        {
            New-TestPackage -Destination $pwd
        }
    }

    # if the tests did not pass, throw the reason why
    if ( $result -eq "FAIL" ) {
        Throw $resultError
    }
}
elseif($Stage -in 'Failure', 'Success')
{
    $result = 'PASS'
    if($Stage -eq 'Failure')
    {
        $result = 'FAIL'
    }

    if ($cronBuild) {
        # update the badge if you've done a cron build, these are not fatal issues
        try {
            $svgData = Get-DailyBadge -result $result
            if ( ! $svgData ) {
                write-warning "Could not retrieve $result badge"
            }
            else {
                Write-Log "Setting status badge to '$result'"
                Set-DailyBuildBadge -content $svgData
            }
        }
        catch {
            Write-Warning "Could not update status badge: $_"
        }

        try {
            Send-DailyWebHook -result $result
        }
        catch {
            Write-Warning "Could not send webhook: $_"
        }
    }
    else {
        Write-Log 'We only send bagde or webhook update for Cron builds'
    }

}