frameworkResources/Scripts/common.ps1

function GetUploadedVms {
    param(
        [string]$ResourceGroup
    )
    $vms = @(Get-AzVM -ResourceGroupName $ResourceGroup | ForEach-Object {
            [PSCustomObject]@{
                Name               = $_.Name
                Location           = $_.Location
                VmSize             = $_.HardwareProfile.VmSize
                OsType             = $_.StorageProfile.OsDisk.OsType
                Zone               = ($_.Zones[0])
                Publisher          = $_.StorageProfile.ImageReference.Publisher
                Offer              = $_.StorageProfile.ImageReference.Offer
                Sku                = $_.StorageProfile.ImageReference.Sku
                Version            = $_.StorageProfile.ImageReference.Version
                NIC                = $_.NetworkProfile.NetworkInterfaces.id
                StorageAccountType = $_.StorageProfile.OsDisk.ManagedDisk.StorageAccountType
                Disk               = $_.StorageProfile.OsDisk.Name
            }
        })
    return $vms
}

function RemoveResources {
    param(
        [string]$VmName,
        [string]$DiskName,
        [string]$NetworkInterfaceName,
        [string]$PublicIpName,
        [string]$ResourceGroup,
        [bool]$UseForce
    )
    if ($UseForce) {
        Remove-AzVM -ResourceGroupName $ResourceGroup -Name $VmName -Force
        Remove-AzDisk -ResourceGroupName $ResourceGroup -DiskName $DiskName -Force
        Remove-AzNetworkInterface -Name $NetworkInterfaceName -ResourceGroupName $ResourceGroup -Force
        Remove-AzPublicIpAddress -Name $PublicIpName -ResourceGroupName $ResourceGroup -Force
    }
    else {
        Remove-AzVM -ResourceGroupName $ResourceGroup -Name $VmName
        Remove-AzDisk -ResourceGroupName $ResourceGroup -DiskName $DiskName
        Remove-AzNetworkInterface -Name $NetworkInterfaceName -ResourceGroupName $ResourceGroup
        Remove-AzPublicIpAddress -Name $PublicIpName -ResourceGroupName $ResourceGroup
    }

}


function CreateStartupCommand {
    param(
        [string]$Key,
        [string]$firstName,
        [string]$lastName,
        [string]$email,
        [string]$company,
        [string]$environment
    )
    $cloudType = "azs"
    $StartupScriptUrl = "https://ncachedeployments.s3.us-east-1.amazonaws.com/5.3.5-staging/StartupScriptLinux.sh"
    return "
        #!/bin/sh
        sleep 30;wget -O /tmp/StartupScriptLinux.sh $StartupScriptUrl;chmod +x /tmp/StartupScriptLinux.sh;/tmp/StartupScriptLinux.sh -InstallType $cloudType
        -Key $Key -FirstName $firstName -LastName $lastName -Email $email -Company $company -Environment $environment
    "
 
}
 

function EncryptStartupCommand {
    param(
        [string]$StartupCommand
    )
    $bytes = [System.Text.Encoding]::UTF8.GetBytes($StartupCommand)
    $encoded = [Convert]::ToBase64String($bytes)
    return $encoded
}

function Test-CIDR {
    param ([string]$CIDR)
    $cidrPattern = '^((25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})\.){3}(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})\/(3[0-2]|[1-2]?[0-9])$'
    return $CIDR -match $cidrPattern
}


function ValidateCIDRBlocks {
    param (
        [string]$CidrBlocks
    )

    $result = @{
        valid      = $false
        errors     = @()
        validCIDRs = @()
    }

    # Return early if empty
    if (-not $CidrBlocks.Trim()) {
        $result.errors += "CIDR block cannot be empty"
        return $result
    }

    # Regex checks (multiple spaces or missing commas)
    $multipleSpaces = "/\\s{2,}/"
    $missingComma = "/[^,\\s]+\\s+[^,\\s]+/"


    $cidrList = $CidrBlocks -split "," |
    ForEach-Object { $_.Trim() } |
    Where-Object { $_.Length -gt 0 }

    if ($cidrList.Count -eq 0) {
        $result.errors += "No valid CIDR blocks provided"
        return $result
    }

    $seen = @{}
    foreach ($cidr in $cidrList) {
        if (-not (Test-CIDR $cidr)) {
            $result.errors += "Invalid CIDR format: $cidr"
        }
        elseif ($seen.ContainsKey($cidr)) {
            $result.errors += "Duplicate CIDR blocks are not allowed"
        }
        else {
            $seen[$cidr] = $true
        }
    }

    $result.valid = ($result.errors.Count -eq 0)
    $result.validCIDRs = $seen.Keys

    return $result
}


function GetVmSize {
    param(
        [string]$VmSize
    )
    $dict = @{
        "ENT-1/1"    = "Standard_B1ms"
        "ENT-4/2"    = "Standard_D2ls_v5"
        "ENT-8/2"    = "Standard_D2as_v5"
        "ENT-8/4"    = "Standard_D4ls_v5"
        "ENT-16/2"   = "Standard_E2as_v5"
        "ENT-16/4"   = "Standard_D4as_v5"
        "ENT-16/8"   = "Standard_D8ls_v5"
        "ENT-32/4"   = "Standard_E4as_v5"
        "ENT-32/8"   = "Standard_D8as_v5"
        "ENT-32/16"  = "Standard_D16ls_v5"
        "ENT-64/8"   = "Standard_E8as_v5"
        "ENT-64/16"  = "Standard_D16as_v5"
        "ENT-64/32"  = "Standard_D32ls_v5"
        "ENT-128/16" = "Standard_E16as_v5"
        "ENT-128/32" = "Standard_D32as_v5"
        "ENT-128/64" = "Standard_D64ls_v5"
        "ENT-256/32" = "Standard_E32as_v5"
        "ENT-256/64" = "Standard_D64as_v5"
    }

    return $dict[$VmSize]
}


function ValidateFields() {
    param(
        [string]$environmentName,
        [string]$location,
        [string]$firstName,
        [string]$lastName,
        [string]$licenseKey,
        [string]$email,
        [string]$password,
        [string]$companyName,
        [string]$vmSizeName
    )

    if ([string]::IsNullOrWhiteSpace($EnvironmentName)) {
        throw "Environment Name cannot be empty"
    }

    if ([string]::IsNullOrWhiteSpace($Location)) {
        throw "Location cannot be empty"
    }

    if ($VmCount -lt 1) {
        throw "Vm Count Name cannot be less than 0"
    }

    if ([string]::IsNullOrWhiteSpace($FirstName)) {
        throw "First name is required"
    }

    if ([string]::IsNullOrWhiteSpace($LastName)) {
        throw "Last Name is required"
    }

    if ([string]::IsNullOrWhiteSpace($LicenseKey)) {
        throw "License Key is required"
    }

    if ([string]::IsNullOrWhiteSpace($Email)) {
        throw "Email is required"
    }

    if ([string]::IsNullOrWhiteSpace($Password)) {
        throw "Password is required"
    }

    if ([string]::IsNullOrWhiteSpace($CompanyName)) {
        throw "Compnay Name is required"
    }

    if ([string]::IsNullOrWhiteSpace($VmSizeName)) {
        throw "VmSize Is Required is required"
    }

    $output = GetVmSize -VmSize $VmSizeName

    if ([string]::IsNullOrEmpty($output)) {
        throw "InCorrect Vm Size Provided"
    }


}