param(

[String]$ProgramURL, # bbc.co.uk/programmes URL of the show to download the latest ep or bbc.co.uk/sounds/play

[String]$SaveDir, # Directory to publish the finished audio file

[String]$ShortTitle, # Short reference for the filename

[String]$TrackNoFormat, # Set track no as DateTime format string: c(r) = count up (recurs), o = one digit year, jjj = Julian date

[String]$TitleFormat, # Format the title: {0} = primary, {1} = secondary, {2} = tertiary, {3} = UTC release date, {4} = UK rel

[Switch]$UseOrigRelease, # Sets the release date of the episode to the original date the episode aired

[Int32]$Bitrate, # Download a specific available bitrate: 48, 96, 128, or 320, 0 = Download highest available

[Switch]$mp3, # Transcode the audio file to mp3 after downloading

[Int32]$Archive, # The number of episodes to keep - omit or set to 0 to keep everything

[Switch]$Days, # Measure -Archive by the number of days instead of the number of episodes to keep

[Switch]$RecheckMetadata, # Scan ALL media files and update with the latest metadata from the BBC

[String]$VPNConfig, # Path to the ovpn file(s) separated by comma - also create and set auth-user-pass file if applicable

[String]$rcloneConfig, # Path to the rclone config file - rclone.exe config create

[String]$rcloneSyncDir, # Remote and directory rclone should upload to separated by comma if multiple - for AWS S3 use config:bucket\directory

[String]$DotSrcConfig, # Path to external .ps1 script file containing script configuration options

[Switch]$Logging, # Output the console to a text file in the LogDirectory

[String]$LogDirectory, # Directory path to save the log files if enabled

[String]$LogFileNameFormat, # Format log file names: {0} = shorttitle, {1} = task guid hash, {2} = PID, {3} = log type, {4} = date/time

[Switch]$NoDL, # Grab the metadata only - Don't download the episode

[Switch]$Force # Download the episode even if it's already downloaded - Will not overwrite existing

)

$DefaultTrackNoFormat = 'c' # DateTime format string to set the track number if -TrackNoFormat is not set

$DefaultTitleFormat = '{1}' # Format string to set episode title to if -TitleFormat is not set

$DefaultBitrate = 96 # Bitrate to download if -Bitrate is not set: 48, 96, 128, 320, 0 = Download highest available

$GenreTag = $true # Pull the genre(s) from the program page and set into the metadata

$DumpDirectory = $env:TEMP # Directory to save the stream to while working on it - to use the win temp dir: $env:TEMP

$VPNAdapter = 'OpenVPN TAP-Windows6' # Name of the adapter used by OpenVPN

$VPNTimeout = 60 # Number of seconds to wait before giving up on VPN if it doesn't connect

$ScriptInstanceControl = $true # Allow only one instance of script to download at a time: Set to $true if using VPN

$LockFileDirectory = $env:TEMP # If using ScriptInstanceControl: Specify non-env dir if running script under different users

$LockFileMaxDuration = 10800 # Max age in seconds before lock files are considered orphaned and deleted - 0 = Disabled

$ytdlpUpdate = $false # Download yt-dlp updates before running script

$rcloneUpdate = $false # Update rclone to the latest stable version

$Logging = $true # Force logging: $true = logging on, $false = no logging, $Logging > $null = read cmd line & don't force

$Printjson = $false # Print the episode metadata in json format to the console for troubleshooting

$LogDirectory = 'E:\FilesTemp\Debug' # Directory to save/move logs to when -Logging switch is present

$LogFileNameFormat = "{0}-{1}-{2}-{3}.log" # Format the log file name: {0} = ShortTitle, {1} = log id, {2} = PID, {3} = log type, {4} = date/time

$ffmpegExe = (Get-ChildItem -Path $PSScriptRoot -Filter "ffmpeg.exe" -Recurse | Sort-Object -Descending -Property LastWriteTime | Select-Object -First 1 | % { $_.FullName })

$ffprobeExe = (Get-ChildItem -Path $PSScriptRoot -Filter "ffprobe.exe" -Recurse | Sort-Object -Descending -Property LastWriteTime | Select-Object -First 1 | % { $_.FullName })

$kid3Exe = (Get-ChildItem -Path $PSScriptRoot -Filter "kid3-cli.exe" -Recurse | Sort-Object -Descending -Property LastWriteTime | Select-Object -First 1 | % { $_.FullName })

$rcloneExe = (Get-ChildItem -Path $PSScriptRoot -Filter "rclone.exe" -Recurse | Sort-Object -Descending -Property LastWriteTime | Select-Object -First 1 | % { $_.FullName })

$vpnExe = (Get-ChildItem -Path $env:Programfiles -Filter 'openvpn.exe' -Recurse -ErrorAction SilentlyContinue | Sort-Object -Descending -Property LastWriteTime | Select-Object -First 1 | % { $_.FullName })

$ytdlpExe = (Get-ChildItem -Path $PSScriptRoot -Filter "yt-dlp.exe" -Recurse | Sort-Object -Descending -Property LastWriteTime | Select-Object -First 1 | % { $_.FullName })

$SortArticles = # String of definite articles to trim from fields for sorting tags - separate with a pipe, ^ is beginning of string

$remote_internetarchive_config = {

Confirm-DownloadedMediaFile

# Build the headers to set the metadata - See https://archive.org/developers/metadata-schema/index.html and https://github.com/vmbrasseur/IAS3API/blob/master/metadata.md#setting-metadata-values-via-headers

$iaHeaders = @( )

$iaHeaders += "--header", "X-Archive-Meta-Collection: opensource_audio"

$iaHeaders += "--header", "X-Archive-Meta-Creator: $(Format-rcloneCommandString($Station))"

$iaHeaders += "--header", "X-Archive-Meta-Date: $($ReleaseDate.ToString("yyyy-MM-dd"))"

$iaHeaders += "--header", "X-Archive-Meta-Description: $(Format-rcloneCommandString($Comment.Replace("`n","<br>")))"

$iaHeaders += "--header", "X-Archive-Meta-Episode-Title: $(Format-rcloneCommandString($EpisodeTitle))"

$iaHeaders += "--header", "X-Archive-Meta-External-Identifier: $EpisodePage"

$iaHeaders += "--header", "X-Archive-Meta-MediaType: audio"

$iaHeaders += "--header", "X-Archive-Meta-Notes: $SoundsPlayLink"

$iaHeaders += "--header", "X-Archive-Meta-Program-Title: $(Format-rcloneCommandString($ShowTitle))"

$iaHeaders += "--header", "X-Archive-Meta-Publisher: $(Format-rcloneCommandString($Station))"

$iaHeaders += "--header", "X-Archive-Meta-Reviews-Allowed: none"

$iaHeaders += "--header", "X-Archive-Meta-Source: $EpisodePage"

$iaHeaders += "--header", "X-Archive-Meta-Title: $(Format-rcloneCommandString($ShowTitle)) | $(Format-rcloneCommandString($EpisodeTitle))"

$iaHeaders += "--header", "X-Archive-Meta-Year: $($ReleaseDate.ToString("yyyy"))"

# Create a page with the metadata and upload the cover art

& $rcloneExe copyto "$DumpDirectory\$ImageName" "$rcloneSyncDir\$(([system.io.fileinfo]$MediaFile).BaseName)\$(([system.io.fileinfo]$MediaFile).BaseName)_itemimage.jpg" $iaHeaders --metadata --config $rcloneConfig --progress -v --dump headers $rcloneLoggingArgs

# Upload the audio file to the page

& $rcloneExe copyto $MediaFile "$rcloneSyncDir$(([system.io.fileinfo]$MediaFile).BaseName)\$(Split-Path $MediaFile -leaf)" --check-first --metadata --config $rcloneConfig --progress -v --dump headers $rcloneLoggingArgs

}

$remote_bbcsoundsrss_r2 = {

# Sync the SaveDir with the remote dir

& $rcloneExe sync $SaveDir $rcloneSyncDir --create-empty-src-dirs --progress --config $rcloneConfig -v $rcloneLoggingArgs

}

Function Confirm-DownloadedMediaFile {

If (-not [System.IO.File]::Exists($MediaFile)) {

Write-Output "**Exiting script block: No media file to transfer"

Break

}

}

Function Exit-Script {

# Clean up the cover art from the DumpDirectory

If ($ImageName) {Get-Childitem -Path $DumpDirectory -Filter $ImageName -Recurse | Remove-Item -Force}

If ($Logging) {

# Stop recording the console

Stop-Transcript

# Spit list of variables and values to file

Get-Variable | Out-File "$LogDirectory\$(Set-LogFileName -LogType 'Console+Vars')" -Append -Encoding utf8 -Width 500

}

Exit

}

Function Format-kid3CommandString ($StringToFormat) {

Return $StringToFormat.replace("'","\'").replace("\`"","`"").replace("`"","\`"").replace("|","\|")

}

Function Get-IniContent ($FilePath) {

$ini = @{}

Switch -regex -File $FilePath {

# Parse section headers

“^\[(.+)\]” {

$Section = $matches[1]

$ini[$section] = @{}

$CommentCount = 0

}

# Parse comments

“^(;.*)$” {

$Value = $matches[1]

$CommentCount = $CommentCount + 1

$Name = “Comment” + $CommentCount

$ini[$section][$name] = $Value.Trim()

}

# Parse keys

“(.+?)\s*=(.*)” {

$Name,$Value = $matches[1..2]

$ini[$section][$name] = $value.Trim()

}

}

Return $ini

}

Function Get-LogID {

If ($LogID -eq $null) {

# Initiate a COM object and connect

$TaskService = New-Object -ComObject('Schedule.Service')

$TaskService.Connect()

$runningTasks = $TaskService.GetRunningTasks(0)

# Get the task associated with the PID of the script

$Script:TaskGUID = $runningTasks | Where-Object{$_.EnginePID -eq $PID} | Select-Object -ExpandProperty InstanceGuid

If ($TaskGUID -ne $null) {

# Compute the SHA-256 hash of the input string

$sha256 = [System.Security.Cryptography.SHA256]::Create()

$hashBytes = $sha256.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($TaskGUID))

# Convert the hash to a Base64 string

$base64Hash = [Convert]::ToBase64String($hashBytes)

# Convert to lowercase and remove non-alphanumeric characters

$alphanumericHash = ($base64Hash.ToLower() -replace '[^a-z]', '')

$Script:LogID = $alphanumericHash.Substring(0, [Math]::Min(4, $alphanumericHash.Length))

} Else {

# If $TaskGUID is empty then it's not running in a task - make something up

$Script:LogID = -join ((97..122) | Get-Random -Count 4 | ForEach-Object {[char]$_})

}

}

Return $LogID

}

Function Initialize-TitleFormatArray {

# Put the titles into a table

$TitleTable = $($jsonData.modules.data[0].data.titles)

# Grab the release date

If (!$UseOrigRelease) {$ReleaseDate = [datetime]$($jsonData.modules.data[0].data.availability.from)}

If ($UseOrigRelease) {$ReleaseDate = [datetime]$($jsonData.modules.data[0].data.release.date)}

# Format the episode title (after pulling all other metadata)

$TitleFormatArray = $TitleTable.'primary', $TitleTable.'secondary', $TitleTable.'tertiary', $ReleaseDate.ToUniversalTime(), [System.TimeZoneInfo]::ConvertTimeBySystemTimeZoneId($ReleaseDate, 'GMT Standard Time')

Return $TitleFormatArray

}

Function Invoke-LoggingRoutine {

# Create the directory to save/move logs to

New-Item -ItemType Directory -Force -Path "$LogDirectory" > $null

$Script:LogFileDate = Get-Date

# Build a command line arguments for openvpn and rclone to output logs

$Script:vpnLoggingArgs = "--log-append `"$LogDirectory\$(Set-LogFileName -LogType 'vpn')`""

$Script:rcloneLoggingArgs = "--log-file", "$LogDirectory\$(Set-LogFileName -LogType 'rclone')"

# Start recording the console

Start-Transcript -Path "$LogDirectory\$(Set-LogFileName -LogType 'Console+Vars')" -Append -IncludeInvocationHeader -Verbose

$Script:TranscriptStarted = $true

Write-Output "**Logging: Saving log files to $LogDirectory\$(Set-LogFileName -LogType '*')"

}

Function Set-LogFileName {

Param ([String]$LogType)

$LogFileNameFormatArray = $ShortTitle, $(Get-LogID), $PID, $LogType, $LogFileDate

$LogFileName = $LogFileNameFormat -f $LogFileNameFormatArray

Return $LogFileName

}

Function Start-ytdlp {

# Use the default bitrate if not speficied in CL

If (!$Bitrate) {

$Bitrate = $DefaultBitrate

}

If ($Bitrate -ge 1) {

# Build the yt-dlp argument to specify the bitrate

$ytdlpBitrate = "[abr=$Bitrate]"

}

# Start yt-dlp

& $ytdlpExe --ffmpeg-location $ffmpegExe --audio-quality 0 -f ba[ext=m4a]$ytdlpBitrate -o "$DumpFile.%(ext)s" $SoundsPlayLink

}

If ($PSBoundParameters.ContainsKey('LogDirectory')) {

$LogDirectory = $PSBoundParameters['LogDirectory']

}

If ($PSBoundParameters.ContainsKey('LogFileNameFormat')) {

$LogFileNameFormat = $PSBoundParameters['LogFileNameFormat']

}

$ProgressPreference = 'SilentlyContinue'

If ($DotSrcConfig) {

If (Test-Path $DotSrcConfig) {

$DotSrcConfig = Get-Item -Path $DotSrcConfig -ErrorAction SilentlyContinue

If ([System.IO.Path]::GetExtension($DotSrcConfig) -eq '.ps1') {

# Check for necessary variables before importing the script

If ((Select-String -Path $DotSrcConfig -Pattern '^[\s]*(\$DumpDirectory)[\s]*=') -AND

(Select-String -Path $DotSrcConfig -Pattern '^[\s]*(\$ffmpegExe)[\s]*=') -AND

(Select-String -Path $DotSrcConfig -Pattern '^[\s]*(\$ffprobeExe)[\s]*=') -AND

(Select-String -Path $DotSrcConfig -Pattern '^[\s]*(\$kid3Exe)[\s]*=') -AND

(Select-String -Path $DotSrcConfig -Pattern '^[\s]*(\$ytdlpExe)[\s]*=')) {

Write-Output "**Importing external script configuration options: $DotSrcConfig"

# Import the script

. $DotSrcConfig

} Else {

Write-Output "**Var(s) missing from external script configuration options: $DotSrcConfig"

Exit-Script

}

} Else {

Write-Output "**External script configuration options file must be .ps1: $DotSrcConfig"

Exit-Script

}

} Else {

Write-Output "**Couldn't access external script configuration options: $DotSrcConfig"

Exit-Script

}

}

If (($Logging) -AND ($TranscriptStarted -ne $true)) {

Invoke-LoggingRoutine

}

If (($rcloneConfig) -AND ($rcloneSyncDir)) {

$HashEnvVarName = $SaveDir.TrimEnd('/', '\')

# Grab the saved hash from the last time the script ran to compare changes later

If ([System.Environment]::GetEnvironmentVariable($HashEnvVarName)) {

$SaveDirHashBefore = [System.Environment]::GetEnvironmentVariable($HashEnvVarName)

# For troubleshooting only

$SaveDirHashIsFromEnvVar = $true

} Else {

# If the hash isn't already saved get it now

$md5hash = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider

$utf = New-Object -TypeName System.Text.UTF8Encoding

$SaveDirHashBefore = [System.BitConverter]::ToString($md5hash.ComputeHash($utf.GetBytes((Get-ChildItem -Path $SaveDir -Recurse | Sort-Object Name | Select -ExpandProperty FullName) -join "`n"))).Replace("-", "")

# For troubleshooting only

$SaveDirHashIsFromEnvVar = $false

}

}

If ($ProgramURL -like "https://www.bbc.co.uk/sounds/play/*") {

$SoundsPlayLink = $ProgramURL

}

If (!$SoundsPlayLink) {

# Get the content of the program page

$ProgramPageHTML = (Invoke-WebRequest –Uri $ProgramURL -UseBasicParsing)

# Search the program page for the Sounds link to the latest episode

$SoundsPlayLink = ($ProgramPageHTML.Links | Where-Object {$_.href -like "https://www.bbc.co.uk/sounds/play/*"} | Select-Object -First 1).href

}

Write-Output "**Sounds URL: $SoundsPlayLink"

$ProgramID = $($SoundsPlayLink -split "/")[-1]

If (($ScriptInstanceControl) -AND (!$NoDL)) {

# Function to delete the lock file to release control

Function Unlock-Control {

Remove-Item -Path $Script:LockFile -Force

If (!(Test-Path $Script:TestLockFile)) {Write-Output "**Released control at $(Get-Date)"}

}

# Non-VPN DLs can run simultaneously with other non-VPN DLs - VPN DLs can only run one at a time

If ($VPNConfig) {

# Set lock file parameters - If VPN is used heed any lock files

$Script:LockFile = $(Join-Path -Path $LockFileDirectory -ChildPath $([String]$PID+'.vpn.lock'))

$Script:TestLockFile = $(Join-Path -Path $LockFileDirectory -ChildPath $('*.lock'))

} Else {

# If VPN is not used only care about vpn lock files

$Script:LockFile = $(Join-Path -Path $LockFileDirectory -ChildPath $([String]$PID+'.lock'))

$Script:TestLockFile = $(Join-Path -Path $LockFileDirectory -ChildPath $('*.vpn.lock'))

}

# See if control is locked by looking for any lock files

If (Test-Path $Script:TestLockFile) {

Write-Output "**Waiting for control at $(Get-Date)"

# Generate random milliseconds up to 2 secs as the sleep interval - reduces chance of control collisions

$RandomInterval = Get-Random -Minimum 2000 -Maximum 5000

Do {

# Routine to clean up orphaned lock files

If (($LockFileMaxDuration -gt 0) -AND ($DoCount -eq $NextCheck)) {

# Check the lock file directory for old lock files

$GetLockFiles = Get-ChildItem -Path $LockFileDirectory -Filter "*.lock" -Force | Where-Object {$_.CreationTime -lt (Get-Date).AddSeconds($LockFileMaxDuration*-1)}

# Delete each one

ForEach ($OrphanedLockFile in $GetLockFiles) {

Remove-Item $OrphanedLockFile.FullName -ErrorAction SilentlyContinue

If ($?) {

Write-Output "**Released $OrphanedLockFile (possibly orphaned)"

}

}

# Only check every 4 instances to save resources

$NextCheck = $NextCheck+4

}

# Recheck for test file at random interval

Start-Sleep -Milliseconds $RandomInterval

$DoCount++

# Wait your turn until lock files are gone

} Until (!(Test-Path $Script:TestLockFile))

}

# Take control by creating a lock file

$null = New-Item $Script:LockFile

If (Test-Path $Script:LockFile) {

Write-Output "**Control received at $(Get-Date)"

Write-Output "**Lock file is $Script:LockFile"

}

}

$Download = 1

$Files = Get-ChildItem $SaveDir -ErrorAction SilentlyContinue

ForEach ($File in $Files) {

# If a file with the same ProgramID exists don't redownload it

If ($File.Name -match $ProgramID) {$Download = 0}

}

If (($Download -eq 1) -OR ($NoDL) -OR ($Force)) {

# Check for yt-dlp updates and download

If ((!$NoDL) -AND ($ytdlpUpdate -eq $true)) {& $ytdlpExe -U}

# Load the Sounds page to grab the tag information

$SoundsShowPage = (Invoke-WebRequest –Uri $SoundsPlayLink -Method Get -UseBasicParsing -ContentType "text/plain; charset=utf-8").Content

# Parse the metadata section from the Sounds page and read it as JSON

$Getjson = "(?<=<script> window.__PRELOADED_STATE__ = )(.*?)(?=; </script>)"

$jsonResult = [regex]::match($SoundsShowPage, $Getjson)

# Clean up stupid smart quotes

$jsonResult = "$jsonResult" -replace '[\u201C\u201D\u201E\u201F\u2033\u2036]', "$([char]92)$([char]34)" -replace "[\u2018\u2019\u201A\u201B\u2032\u2035]", "$([char]39)"

$jsonData = $jsonResult | ConvertFrom-Json

# Set the name of the program

$ShowTitle = $jsonData.modules.data[0].data.titles.primary

# Parse the synopses to set the comment

$SynopsesTable = $($jsonData.modules.data[0].data.synopses)

# Default the comment to the short description

$Comment = $SynopsesTable.'short'

# Use the medium description if it's available

If ($SynopsesTable.'medium') {

$Comment = $SynopsesTable.'medium'

}

# Use the long description if it's available

If ($SynopsesTable.'long') {

$Comment = $SynopsesTable.'long'

}

# Set the station

$Station = $($jsonData.modules.data[0].data.network.short_title)

# Grab the release date

If (!$UseOrigRelease) {$ReleaseDate = [datetime]$($jsonData.modules.data[0].data.availability.from)}

If ($UseOrigRelease) {$ReleaseDate = [datetime]$($jsonData.modules.data[0].data.release.date)}

# Grab the original release date

$OriginalReleaseDate = [datetime]$($jsonData.modules.data[0].data.release.date)

# Put all of the tracks in an array

$TrackTable = $($jsonData.tracklist.tracks)

If ($TrackTable) {

$trackno = 0

# Run through each track to build the track list

ForEach ($item in $TrackTable) {

# Build the track list line by line

$TrackList = $TrackList + "$([string]$($trackno+1)). $($item.titles.primary)-$($item.titles.secondary)`n"

$trackno++

}

# Add the track list to the comments

$Comment = $Comment + "`n`nTracklist:`n" + $TrackList

}

# Get the cover art

$CoverResult = $($jsonData.modules.data[0].data.image_url).replace("{recipe}","1024x1024")

# Format the episode title (after pulling all other metadata)

If (!$TitleFormat) {$TitleFormat = $DefaultTitleFormat}

# Put the titles into a table

$TitleTable = $($jsonData.modules.data[0].data.titles)

$EpisodeTitle = $TitleFormat -f $(Initialize-TitleFormatArray)

# Put each variable in the title format into an array

$TitleCheckVarArray=[Regex]::Matches($TitleFormat, '(?={)(.*?})') | ForEach-Object {$_.Groups[1].value}

# Run through the array and look for blank variables

:TitleCheck ForEach ($var in $TitleCheckVarArray) {

$TitleCheck = $var -f $(Initialize-TitleFormatArray)

If ($TitleCheck -eq '') {

Write-Output "**Correcting null title: $EpisodeTitle"

# Set the title to the primary (usually the show name)

$EpisodeTitle = $TitleTable.'primary'

# Use the secondary title if it's available

If ($TitleTable.'secondary') {

$EpisodeTitle = $TitleTable.'secondary'

}

# Use the tertiary title if it's available

If ($TitleTable.'tertiary') {

$EpisodeTitle = $TitleTable.'tertiary'

}

Break TitleCheck

}

}

Write-Output "**Episode Title: $EpisodeTitle"

Write-Output " {0} $($TitleTable.'primary')"

Write-Output " {1} $($TitleTable.'secondary')"

Write-Output " {2} $($TitleTable.'tertiary')"

Write-Output "**Show: $ShowTitle"

Write-Output "**Description: $Comment"

Write-Output "**Station: $Station"

Write-Output "**Released On: $ReleaseDate"

Write-Output "**Released On: $($ReleaseDate.ToUniversalTime())"

If ($Printjson) {

Write-Output "**Beginning of json output (line below):"

Write-Output $jsonResult

Write-Output "**End of json output (line above)"

}

If ($NoDL) {Exit-Script}

# Build the DumpFile path

$NakedName = "$ProgramID-media"

$DumpFile = "$DumpDirectory\$NakedName"

If ($VPNConfig) {

# Put the VPN config paths into an array for looping

$VPNArray = $VPNConfig.Split(",")

# Build an array to keep track of PIDs for VPN processes you start for closing later

$VPNPIDArray = @()

# Loop through each VPN config so if yt-dlp doesn't download move on to the next one

:VPNLoop ForEach ($VPNServer in $VPNArray) {

# Check to see whether the VPN adapter is free

If ($(Get-NetAdapter -Name $VPNAdapter).Status -ne "Disconnected") {

Write-Output "**Waiting because $VPNAdapter is in use"

# If VPN adapter is already connected wait until it's disconnected

Do { #Wait

} While ($(Get-NetAdapter -Name $VPNAdapter).Status -ne "Disconnected")

}

# Call OpenVPN in a new process and connect using the config file

$VPNApp = Start-Process $vpnExe -ArgumentList "$vpnLoggingArgs --config `"$VPNServer`"" -passthru

# Add the VPN PID to the array for closing later

$VPNPIDArray += $VPNApp.Id

# Start a timer

$VPNConnectionTimer = [System.Diagnostics.Stopwatch]::StartNew()

Write-Output "**Connecting to the VPN using $VPNServer"

# Wait until the VPN connects - Check link is up has IP and DNS

Do { #Wait

} Until ((($(Get-NetAdapter -Name $VPNAdapter).Status -eq "Up") -AND ($(Get-NetIPConfiguration -InterfaceAlias $VPNAdapter).IPv4Address) -AND ($(Get-NetIPConfiguration -InterfaceAlias $VPNAdapter).DNSServer)) -OR ($VPNConnectionTimer.Elapsed.TotalSeconds -gt $VPNTimeout))

If ($VPNConnectionTimer.Elapsed.TotalSeconds -gt $VPNTimeout) {

Write-Output "**Could not connect to the VPN"

Stop-Process -Id $VPNApp.Id

Continue

}

If ($(Get-NetAdapter -Name $VPNAdapter).Status -eq "Up") {

Write-Output "**Connected to the VPN"

# Call yt-dlp to download the file

Start-ytdlp

}

ForEach ($VPNPID in $VPNPIDArray) {

Stop-Process -Id $VPNPID -ErrorAction SilentlyContinue

}

# Search for the DumpFile to see if yt-dlp finished downloading

$FinishedFile = Get-ChildItem -Path $DumpDirectory\$NakedName.* -Exclude *.part, *.ytdl | Select-Object -Last 1

If ($FinishedFile) {Break VPNLoop}

}

Write-Output "**Disconnecting from the VPN"

# Close OpenVPN to disconnect once the download is done

ForEach ($VPNPID in $VPNPIDArray) {

Stop-Process -Id $VPNPID -ErrorAction SilentlyContinue

}

If ($(Get-NetAdapter -Name $VPNAdapter).Status -ne "Up") {

Write-Output "**Disconnected from the VPN"

}

}

# Call yt-dlp to download the file if the VPN isn't used

If (!$VPNConfig) {

Start-ytdlp

}

# No more downloading after this - release the control for other scripts

If ($ScriptInstanceControl) {Unlock-Control}

# Determine the extention of the DumpFile - Used later for kid3

$ext = [System.IO.Path]::GetExtension((Get-ChildItem -Path $DumpDirectory -Recurse -Filter "*$NakedName.*"))

# If it didn't download the file - you're done

If (!(Test-Path $DumpFile$ext)) {

Write-Output "**DumpFile was not downloaded or no longer exists"

Exit-Script

}

# Test that the metadata is valid by making sure EpisodeTitle and Station have characters

If (($EpisodeTitle -notmatch '\S+') -AND ($Station -notmatch '\S+')) {

Write-Output "**Could not validate metadata"

# Exit script if metadata is not valid

Exit-Script

}

# Check if the audio file needs to transcoded to mp3

If (($mp3) -AND ($ext -ne ".mp3")) {

# Run ffprobe to get the bitrate of the m4a file

$ffprobeData = & $ffprobeExe -v quiet -hide_banner -of default=noprint_wrappers=0 -print_format xml -select_streams v:0 -show_format $DumpFile$ext | Out-String

[xml]$ffprobeXMLData = $ffprobeData

# Transcode the audio file to mp3 format

& $ffmpegExe -i "$DumpFile$ext" -c:v copy -c:a libmp3lame -b:a $($ffprobeXMLData.ffprobe.format.bit_rate) "$DumpFile.mp3"

# Delete the original audio file with the old extention

Remove-Item $DumpFile$ext

# Change the extension to .mp3 so the rest of the script finds the correct file

$ext = ".mp3"

}

# Parse the image name and file extension from the url

$ImageName = "$CoverResult".Substring("$CoverResult".lastIndexOf('/')+1)

# Download the image to the dump directory

$WClient = New-Object System.Net.WebClient

$WClient.DownloadFile("$CoverResult", "$DumpDirectory\$ImageName")

# If TrackNoFormat is not set in the command line, then use the DefaultTrackNoFormat

If (!$TrackNoFormat) {$TrackNoFormat = $DefaultTrackNoFormat}

Function Get-TrackNumberCount([Switch]$Recurse) {

# Build the array to store the track numbers from kid3

$TrackNumbers = @(0)

# Search the save dir for files matching the short title - sort by creation time

Get-ChildItem $SaveDir -Recurse:$Recurse -Force | Where-Object { $_.Name -match $("$ShortTitle-([0-9]*)-([A-Za-z0-9]*|[A-Za-z0-9]*_[0-9]*)\.") } | Sort-Object CreationTime -Descending | Foreach-Object {

# Run kid3 on all files to pull the track number

$GetTrackNo = & $kid3Exe -c 'get track' $_.FullName

# Put the track number in the array

$TrackNumbers += $GetTrackNo

}

# Find the highest number in the array

$TrackNoCount = (($TrackNumbers | Measure -Max).Maximum)

Return $TrackNoCount

}

# Store the track number format in a temporary variable to work with

$TrackNoFormatWk = $TrackNoFormat

# If format contains cr - then run the function to recursively figure out the track number and add 1

$TrackNoFormatWk = $TrackNoFormatWk -creplace "cr", ((Get-TrackNumberCount -Recurse)+1)

# If format contains c - then run the function to nonrecursively figure out the track number and add 1

$TrackNoFormatWk = $TrackNoFormatWk -creplace "c", ((Get-TrackNumberCount)+1)

# Determine the day of the year (Julian date)

$TrackNoFormatWk = $TrackNoFormatWk -creplace "jjj", ("{0:D3}" -f $ReleaseDate.DayofYear)

# Break down the two digit year to a single digit

$TrackNoFormatWk = $TrackNoFormatWk -creplace "o", $ReleaseDate.ToString("yy").substring(1,1)

# Format the AvailabilityDate to the TrackNoFormat - add a leading 0 to make it at least two digits or it fails

$TrackNumber = $ReleaseDate.ToString(($TrackNoFormatWk).PadLeft(2, '0'))

# Set the episode program page - more permanent than the Sounds page (also used by genRSS to set the guid)

$EpisodePage = "https://www.bbc.co.uk/programmes/$ProgramID"

If ($GenreTag -eq $true) {

# Still need to get the program page if a Sounds link was given as $ProgramURL

If (!$ProgramPageHTML) {$ProgramPageHTML = (Invoke-WebRequest –Uri $EpisodePage -UseBasicParsing)}

# Pull the genre links from the program page and put into array

$GetGenres = @(($ProgramPageHTML.Links | Where-Object {$_.href -like "/programmes/genres/*"}).outerHTML | % {[regex]::matches( $_ , '(?<=>)(.*)*(?=<\/a>)')} | Select -ExpandProperty value)

$GetGenres = $GetGenres | Select -Unique

}

# Get the yt-dlp version info

$ytdlpName = (Get-Item -Path $ytdlpExe).VersionInfo.ProductName

$ytdlpVer = (Get-Item -Path $ytdlpExe).VersionInfo.ProductVersion

$kid3Commands = @( )

# Build MP4 or ID3v2.4 metadata commands to pass to kid3 - See kid3 handbook

If ($Ext -eq ".m4a") {

# Note: ©nam is required for genRSS.ps1 - sets <title> and <itunes:title>

$kid3Commands += "-c", "set ©nam '$(Format-kid3CommandString($EpisodeTitle))'"

$kid3Commands += "-c", "set sonm '$(Format-kid3CommandString($EpisodeTitle -replace $SortArticles))'"

$kid3Commands += "-c", "set ©ART '$(Format-kid3CommandString($Station))'"

$kid3Commands += "-c", "set soaa '$(Format-kid3CommandString($Station -replace $SortArticles))'"

$kid3Commands += "-c", "set soar '$(Format-kid3CommandString($Station -replace $SortArticles))'"

$kid3Commands += "-c", "set aART '$(Format-kid3CommandString($Station))'"

$kid3Commands += "-c", "set ©alb '$(Format-kid3CommandString($ShowTitle))'"

$kid3Commands += "-c", "set soal '$(Format-kid3CommandString($ShowTitle -replace $SortArticles))'"

$kid3Commands += "-c", "set ©day '$($OriginalReleaseDate.ToString(`"yyyy`"))'"

# Note: RELEASEDATE is required for genRSS.ps1 - sets <pubDate>

$kid3Commands += "-c", "set RELEASEDATE '$($ReleaseDate.ToUniversalTime())'"

$kid3Commands += "-c", "set ORIGINALDATE '$($OriginalReleaseDate.ToString(`"yyyy-MM-dd`"))'"

$kid3Commands += "-c", "set trkn '$TrackNumber'"

$kid3Commands += "-c", "set PUBLISHER '$(Format-kid3CommandString($Station))'"

# Note: WEBSITE is required for genRSS.ps1 - sets <guid> and <link>

$kid3Commands += "-c", "set WEBSITE '$EpisodePage'"

$kid3Commands += "-c", "set AudioSourceURL '$SoundsPlayLink'"

# Note: ©cmt is required for genRSS.ps1 - sets <description> and <itunes:summary>

$kid3Commands += "-c", "set ©cmt '$(Format-kid3CommandString($Comment))'"

$kid3Commands += "-c", "set ©too '$ytdlpName $ytdlpVer'"

} Else {

# Note: TIT2 is required for genRSS.ps1 - sets <title> and <itunes:title>

$kid3Commands += "-c", "set TIT2 '$(Format-kid3CommandString($EpisodeTitle))'"

$kid3Commands += "-c", "set TSOT '$(Format-kid3CommandString($EpisodeTitle -replace $SortArticles))'"

$kid3Commands += "-c", "set TPE1 '$(Format-kid3CommandString($Station))'"

$kid3Commands += "-c", "set TSO2 '$(Format-kid3CommandString($Station -replace $SortArticles))'"

$kid3Commands += "-c", "set TSOP '$(Format-kid3CommandString($Station -replace $SortArticles))'"

$kid3Commands += "-c", "set TPE2 '$(Format-kid3CommandString($Station))'"

$kid3Commands += "-c", "set TALB '$(Format-kid3CommandString($ShowTitle))'"

$kid3Commands += "-c", "set TSOA '$(Format-kid3CommandString($ShowTitle -replace $SortArticles))'"

$kid3Commands += "-c", "set TDRC '$($OriginalReleaseDate.ToString(`"yyyy`"))'"

# Note: TDRL is required for genRSS.ps1 - sets <pubDate>

$kid3Commands += "-c", "set TDRL '$($ReleaseDate.ToUniversalTime())'"

$kid3Commands += "-c", "set TDOR '$($OriginalReleaseDate.ToString(`"yyyy-MM-dd`"))'"

$kid3Commands += "-c", "set TRCK '$TrackNumber'"

$kid3Commands += "-c", "set TPUB '$(Format-kid3CommandString($Station))'"

# Note: WOAR is required for genRSS.ps1 - sets <guid> and <link>

$kid3Commands += "-c", "set WOAR '$EpisodePage'"

$kid3Commands += "-c", "set WOAS '$SoundsPlayLink'"

# Note: COMM is required for genRSS.ps1 - sets <description> and <itunes:summary>

$kid3Commands += "-c", "set COMM '$(Format-kid3CommandString($Comment))'"

$kid3Commands += "-c", "set TSSE '$ytdlpName $ytdlpVer'"

}

If ($GetGenres -ne $null) {

Add-Type -AssemblyName System.Web

$kid3Commands += "-c", "set genre '$([System.Web.HttpUtility]::HTMLDecode($GetGenres -Join '''|'''))'"

}

$kid3Commands += "-c", "set Picture:'$DumpDirectory\$ImageName' ''"

# Note: AlbumArt is required for genRSS.ps1 - sets cover image as <media:content> and <itunes:image>

$kid3Commands += "-c", "set AlbumArt '$CoverResult'"

# Run kid3-cli to set the tags

& $kid3Exe $kid3Commands $DumpFile$Ext

# Create the save directory if it doesn't exist

New-Item -ItemType Directory -Force -Path $SaveDir

# Build the new filename

[System.IO.Path]::GetExtension($DumpFile)

$MediaFile = $SaveDir + "\" + $ShortTitle + "-" + $ReleaseDate.ToString("yyyyMMdd") + "-" + $ProgramID + $Ext

# Make sure the filename doesn't already exist

If (Test-Path $MediaFile) {

$i = 0

# Keep trying with a different instance until the filename doesn't exist

While (Test-Path $MediaFile) {

# Increase the instance on each loop

$i += 1

# Rebuild the filename and append the loop instance

$MediaFile = $SaveDir + "\" + $ShortTitle + "-" + $ReleaseDate.ToString("yyyyMMdd") + "-" + $ProgramID + "_" + $i + $ext

}

}

# Run ffprobe to check that kid3 set the tags before moving the file

$ffprobeData = & $ffprobeExe -v quiet -hide_banner -of default=noprint_wrappers=0 -print_format xml -select_streams v:0 -show_format $DumpFile$ext | Out-String

[xml]$ffprobeXMLData = $ffprobeData

$CheckTitle = $($ffprobeXMLData.ffprobe.format.tag | Where {$_.key -eq 'title'}).value

$CheckArtist = $($ffprobeXMLData.ffprobe.format.tag | Where {$_.key -eq 'artist'}).value

$CheckAlbum = $($ffprobeXMLData.ffprobe.format.tag | Where {$_.key -eq 'album'}).value

If (($CheckTitle) -AND ($CheckArtist) -AND ($CheckAlbum)) {

# Move the file

Move-Item $DumpFile$ext -Destination $MediaFile

} Else {

Write-Output "**Metadata not set correctly"

Exit-Script

}

} Else {

Write-Output "**Program ID $ProgramID already downloaded $($File.CreationTime)"

If ($ScriptInstanceControl) {Unlock-Control}

}

$TitleMatchPattern = "$ShortTitle-([0-9]*)-([A-Za-z0-9]*|[A-Za-z0-9]*_[0-9]*)\."

If ($Archive -ge 1) {

If (!$Days) {

# Remove all audio files except the most recent ones

Get-ChildItem $SaveDir -Recurse -Force | Where-Object { $_.Name -match $($TitleMatchPattern) } | Sort-Object LastWriteTime -Descending | Select-Object -Skip $Archive | Remove-Item -Force -Verbose

}

If ($Days) {

# Run through all items in the SaveDir

Get-ChildItem $SaveDir -Recurse -Force | Where-Object {$_.Name -match $($TitleMatchPattern)} | ForEach {

# Parse the release date from the title of each episode

$ParseReleaseDate = [regex]::match($_.Name, "(\d\d\d\d\d\d\d\d+)")

# Convert the release date to a DateTime object

$TitleReleaseDate = [Datetime]::ParseExact($ParseReleaseDate, 'yyyyMMdd', (New-Object System.Globalization.CultureInfo "en-US"))

# Check if the release date of the ep is older than the specified archive date

If ($TitleReleaseDate -lt (Get-Date).Date.AddDays(-$Archive)) {

# Remove it if it is

Remove-Item $_.FullName -Force -Verbose

}

}

}

}

If ($RecheckMetadata) {

Get-ChildItem $SaveDir -Recurse -Force | Where-Object {$_.Name -match $($TitleMatchPattern)} | ForEach-Object {

$kid3data = & $kid3Exe -c '{\"method\":\"get\"}' $_.FullName

$kid3json = $kid3data | ConvertFrom-Json

$SoundsShowPage = (Invoke-WebRequest –Uri $($kid3json.result.taggedFile.tag2.frames | Where {$_.Name -eq 'audiosourceURL'}).value -Method Get -UseBasicParsing -ContentType "text/plain; charset=utf-8").Content

$Getjson = "(?<=<script> window.__PRELOADED_STATE__ = )(.*?)(?=; </script>)"

$jsonResult = [regex]::match($SoundsShowPage, $Getjson)

# Clean up stupid smart quotes

$jsonResult = $jsonResult -replace '[\u201C\u201D\u201E\u201F\u2033\u2036]', "$([char]92)$([char]34)" -replace "[\u2018\u2019\u201A\u201B\u2032\u2035]", "$([char]39)"

$jsonData = $jsonResult | ConvertFrom-Json -ErrorAction Stop

If ($jsonData -ne $null -and $jsonData.PSObject.Properties.Count -gt 0) {

If (!$TitleFormat) {$TitleFormat = $DefaultTitleFormat}

#Initialize-TitleFormatArray

$RecheckEpisodeTitle = $TitleFormat -f $(Initialize-TitleFormatArray)

# Parse the synopses to set the comment

$SynopsesTable = $($jsonData.modules.data[0].data.synopses)

# Default the comment to the short description

$RecheckComment = $SynopsesTable.'short'

# Use the medium description if it's available

If ($SynopsesTable.'medium') {

$RecheckComment = $SynopsesTable.'medium'

}

# Use the long description if it's available

If ($SynopsesTable.'long') {

$RecheckComment = $SynopsesTable.'long'

}

# Put all of the tracks in an array

$TrackTable = $($jsonData.tracklist.tracks)

If ($TrackTable) {

$trackno = 0

# Run through each track to build the track list

ForEach ($item in $TrackTable) {

# Build the track list line by line

$TrackList = $TrackList + "$([string]$($trackno+1)). $($item.titles.primary)-$($item.titles.secondary)`n"

$trackno++

}

# Add the track list to the comments

$RecheckComment = $RecheckComment + "`n`nTracklist:`n" + $TrackList

}

If ((($($kid3json.result.taggedFile.tag2.frames | Where {$_.Name -eq 'Title'}).value -ne $RecheckEpisodeTitle) -OR ($(($kid3json.result.taggedFile.tag2.frames | Where {$_.Name -eq 'Comment'}).value) -ne $RecheckComment)) -AND ((-not [string]::IsNullOrEmpty($RecheckEpisodeTitle)) -AND (-not [string]::IsNullOrEmpty($RecheckComment)))) {

$kid3Commands = @( )

# Build MP4 or ID3v2.4 metadata kid3 commands to set title and comment- See kid3 handbook

If ($_.Extension -eq ".m4a") {

# Note: ©nam is required for genRSS.ps1 - sets <title> and <itunes:title>

$kid3Commands += "-c", "set ©nam '$(Format-kid3CommandString($RecheckEpisodeTitle))'"

# Note: ©cmt is required for genRSS.ps1 - sets <description> and <itunes:summary>

$kid3Commands += "-c", "set ©cmt '$(Format-kid3CommandString($RecheckComment))'"

} Else {

# Note: TIT2 is required for genRSS.ps1 - sets <title> and <itunes:title>

$kid3Commands += "-c", "set TIT2 '$(Format-kid3CommandString($RecheckEpisodeTitle))'"

# Note: ©cmt is required for genRSS.ps1 - sets <description> and <itunes:summary>

$kid3Commands += "-c", "set COMM '$(Format-kid3CommandString($RecheckComment))'"

}

# Don't want to change the last modified date

$OriginalTimestamps = Get-Item $_ | Select-Object LastWriteTime

# Call kid3 on the current file to set the new title and comment

& $kid3Exe $kid3Commands $_

Set-ItemProperty -Path $_ -Name LastWriteTime -Value $OriginalTimestamps.LastWriteTime

Write-Output "**Updated metadata on $_"

}

}

}

}

If (($rcloneConfig) -AND ($rcloneSyncDir)) {

# Calculate the hash again to see if changes were made

$md5hash = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider

$utf = New-Object -TypeName System.Text.UTF8Encoding

$SaveDirHashAfter = [System.BitConverter]::ToString($md5hash.ComputeHash($utf.GetBytes((Get-ChildItem -Path $SaveDir -Recurse | Sort-Object Name | Select -ExpandProperty FullName) -join "`n"))).Replace("-", "")

# Save the new hash back to an environment variable for the next time

[System.Environment]::SetEnvironmentVariable($HashEnvVarName, $SaveDirHashAfter)

[System.Environment]::SetEnvironmentVariable($HashEnvVarName, $SaveDirHashAfter, 'User')

If (($SaveDirHashAfter -ne $SaveDirHashBefore) -OR ($Force)) {

# Function to escape double quotes in parameters before passing them to rclone

Function Format-rcloneCommandString ($StringToFormat) {

Return $StringToFormat.replace("`"","\`"")

}

# thumbs.db is not necessary - save an upload by deleting it first

If (Test-Path "$SaveDir\thumbs.db") {Remove-Item "$SaveDir\thumbs.db" -Force -Verbose}

# Check for rclone updates and download

If ($rcloneUpdate -eq $true) {& $rcloneExe selfupdate --stable}

# Parse the rclone config ini file

$RemoteConfig = Get-IniContent $rcloneConfig

# Put the rclone sync dirs into an array

$rcloneSyncDirArray = $rcloneSyncDir.Split(",")

# Loop through each rclone sync dir

ForEach ($rcloneSyncDir in $rcloneSyncDirArray) {

# Parse the rclone remote from the sync directory

$Remote = $rcloneSyncDir.Substring(0, $rcloneSyncDir.IndexOf(":"))

# Run through all script blocks that start with 'remote_'

ForEach ($RemoteItem in $(Get-Variable remote_*)) {

# Looks for a script block with a similar name to the remote config to run

If ($RemoteItem.Name -replace 'remote_*' -eq $Remote) {

Write-Output "**Running script block: $($RemoteItem.Name)"

# Execute the script block

& (Get-Variable -Name $RemoteItem.Name).Value

}

}

}

}

}