InvokeAbilityHelpers.psm1

# Implement your module commands in this script.

if (-not $DependenciesPath ) {
    $DependenciesPath = (Join-Path $PSScriptRoot Dependencies)
}

$defaultDependencyTags = @("dev")
$defaultPsDependVersion = '0.1.62'


$defaultPsDependConfiguration = @{
    PSDependOptions = @{
        AddToPath = $true
    }
    InvokeBuild     = @{
        Version        = '4.1.0'
        Tags           = 'dev', 'prod'
        DependencyType = 'PSGalleryModule'
    }
}
Write-Verbose ("DependenciesPath [{0}]" -f $DependenciesPath) -Verbose
if (-not(Get-InstalledModule PSDepend -RequiredVersion $defaultPsDependVersion -ErrorAction SilentlyContinue)) {
    Install-Module PSDepend -RequiredVersion $defaultPsDependVersion -Force -Scope CurrentUser
}
# -ProjectPath (Get-Location).Path
    
Write-Verbose ("Import or Install Dependencies") -Verbose
Import-Module PSDepend -RequiredVersion $defaultPsDependVersion
Invoke-PSDepend -InputObject $defaultPsDependConfiguration  -Install -Import -Force `
    -Target $DependenciesPath -Tags $defaultDependencyTags -ErrorAction Stop -Verbose

# Export only the functions using PowerShell standard verb-noun naming.
# Be sure to list each exported functions in the FunctionsToExport field of the module manifest file.
# This improves performance of command discovery in PowerShell.


function Invoke-BuildStep {
    param (
        [Parameter(Mandatory = $false)] 
        $Task = "default",
        [Parameter(Mandatory = $false)]
        $OutputPath,
        [Parameter(Mandatory = $false)]
        $ProjectPath
    )

    if (-not $ProjectPath ) {
        $ProjectPath = Resolve-Path  (Get-Location).Path
    }
        
    if (-not $OutputPath ) {
        $OutputPath = (Join-Path $ProjectPath)
    }


    $PSBoundParameters.Add("File", (Join-Path $PSScriptRoot Invoke-BuildStep.task.ps1))


    Write-Verbose ("ProjectPath [{0}]" -f $ProjectPath) -Verbose
    Write-Verbose ("OutputPath [{0}]" -f $OutputPath) -Verbose

    Invoke-Build @PSBoundParameters -Result result

    # Invoke-Build $Task {
    # Task default UpdateConfiguration
    # Task UpdateConfiguration{
    # echo "test"
    # }
    # } -Result result

    if ($Result.Error) {exit 1} else {exit 0}
    
    
}
Export-ModuleMember -Function Invoke-BuildStep

function Update-Project {
    param (
        [Parameter(Mandatory = $false)]
        $ProjectPath,

        [Parameter(Mandatory = $false)]
        $OutputPath
    )

    if (-not $ProjectPath ) {
        $ProjectPath = Resolve-Path  (Get-Location).Path
    }
    if (-not $OutputPath ) {
        $OutputPath = $ProjectPath
    }

    $MetadataObjectAsJson = @{}
    $CurrentTime = Get-Date -Format "MM-dd-yyyy-hh-mm-ss"

    Set-Location $ProjectPath

    $GitVersionExe = (Join-Path $PSScriptRoot "\Dependencies\GitVersion_3.6.5\GitVersion.exe")
    $ConventionalChangelogExe = (Join-Path $PSScriptRoot "\Dependencies\conventional-changelog\conventional-changelog.cmd")

    $MetadataFile = Resolve-Path $ProjectPath\*.metadata.json

    # NOTE: Generate GitVersion file
    Write-Verbose "Generate GitVersion file" -Verbose
    Set-Content $ProjectPath\GitVersion.yml @"
branches:
    master:`
      mode: ContinuousDeployment
      tag: stable
      increment: None
      prevent-increment-of-merged-branch-version: true
      track-merge-target: false
    release:
      mode: ContinuousDeployment
      tag: release
      increment: None
      prevent-increment-of-merged-branch-version: true
      track-merge-target: false
    (pull|pull\-requests|pr)[/-]:
      mode: ContinuousDeployment
      tag: pr
      increment: None
      prevent-increment-of-merged-branch-version: false
      tag-number-pattern: '[/-](?<number>\d+)[-/]'
      track-merge-target: false
    hotfix(es)?[/-]:
      mode: ContinuousDeployment
      tag: hotfix
      increment: None
      prevent-increment-of-merged-branch-version: false
      track-merge-target: false
    support[/-]:
      mode: ContinuousDeployment
      tag: support
      increment: None
      prevent-increment-of-merged-branch-version: true
      track-merge-target: false
    develop:
      mode: ContinuousDeployment
      tag: develop
      increment: None
      prevent-increment-of-merged-branch-version: false
      track-merge-target: true
"@



    # NOTE:
    Write-Verbose "Generate metadata" -Verbose
    if (-not (Test-Path $MetadataFile)) {
        throw [System.IO.FileNotFoundException] "$MetadataFile not found."
    }
    else {
        Get-Content $MetadataFile
        $MetadataFileObject = Get-Content $MetadataFile | Out-String | ConvertFrom-Json
    }

    $GitVersionObject = ConvertFrom-Json ( & $GitVersionExe | Out-String)

    $MetadataObject = [PSCustomObject]@{
        Name      = if ($MetadataFileObject.Name) {$MetadataFileObject.Name} else {"none"};  
        Version   = if ($GitVersionObject.FullSemVer) {$GitVersionObject.FullSemVer} else {"none"};
        Build     = [PSCustomObject] @{
            Time              = $CurrentTime
            BuildId           = if ($env:BUILD_BUILDID) {$env:BUILD_BUILDID} else {"none"};
            DefinitionName    = if ($env:BUILD_DEFINITIONNAME) {$env:BUILD_DEFINITIONNAME} else {"none"};
            BuildNumber       = if ($env:BUILD_BUILDNUMBER) {$env:BUILD_BUILDNUMBER} else {"none"};
            DefinitionVersion = if ($env:BUILD_DEFINITIONVERSION) {$env:BUILD_DEFINITIONVERSION} else {"none"};
            QueuedBy          = if ($env:BUILD_QUEUEDBY) {$env:BUILD_QUEUEDBY} else {"none"};
            RepositoryUri     = if ($env:BUILD_REPOSITORY_URI) {$env:BUILD_REPOSITORY_URI} else {"none"};
            TeamProject       = if ($env:SYSTEM_TEAMPROJECT) {$env:SYSTEM_TEAMPROJECT} else {"none"};
            BuildReason       = if ($env:RELEASE_ENVIRONMENTNAME) {$env:RELEASE_ENVIRONMENTNAME} else {"none"};
            AgentName         = if ($env:AGENT_NAME) {$env:AGENT_NAME} else {"none"};
        }
        SemVer    = $GitVersionObject
        Resources = if ($MetadataFileObject.Resources) {$MetadataFileObject.Resources} else {@()};    
    }
    $MetadataObjectAsJson = $MetadataObject | ConvertTo-Json -depth 100 
    $MetadataObjectAsJson | Out-File $MetadataFile -Force
    
    # NOTE: Generate changelog file
    $ChangelogFile = (Join-Path $ProjectPath CHANGELOG.md)
    & $ConventionalChangelogExe -p angular -i $ChangelogFile -s -r 0

    # NOTE: Update Version element in each csproj
    Write-Verbose "Update Version element in each csproj" -Verbose
    Get-ChildItem -Path $ProjectPath -Recurse -Filter *.csproj -File |
        ForEach-Object {
        [xml]$CsProjectName = Get-Content $_.FullName
        $Version = $CsProjectName.SelectSingleNode('//Version[last()]')
        if ($Version) {
            $Version.InnerText = $MetadataObject.Version
            $CsProjectName.Save($_.FullName)
        }
    }
    #VSTS variables
    Write-Host "##vso[build.updatebuildnumber]$($GitVersionObject.FullSemVer)"
    Write-Host "##vso[task.setvariable variable=ChangelogFile;]$ChangelogFile"
    Write-Host "##vso[task.setvariable variable=MetadataFile;]$MetadataFile"
    
    Write-Verbose ("MetadataPath: {0}" -f $MetadataFile) -Verbose
    Write-Verbose ("Metadata saved to: [{0}]" -f $MetadataFile) -Verbose
    Write-Verbose ("ChangelogFile saved to: [{0}]" -f $ChangelogFile) -Verbose
    Write-Verbose ("GitVersionExe: [{0}]" -f $GitVersionExe) -Verbose
    Write-Verbose ("ConventionalChangelogExe: [{0}]" -f $ConventionalChangelogExe) -Verbose
}

Export-ModuleMember -Function Update-Project