RubenZagon/powershell-setup.ps1

## powershell-setup.ps1
<#
.SYNOPSIS
    Script to Initialize my custom powershell setup.
.DESCRIPTION
    Script uses scoop, winget and chocolatey to install some applications
    to be ready to work.

Creation inspired by the script created by Mike Pruett

.NOTES
    **NOTE** Will configure the Execution Policy for the "CurrentUser" to Unrestricted.
    Author: Rubén Zamora
    Date: January 26th, 2023
    Last Updated on January 31th, 2023
#>

$VerbosePreference = "Continue"

function Install-ScoopApp
{
    param (
        [string]$Package
    )
    Write-Verbose -Message "Preparing to install $Package"
    if (!(scoop info $Package).Installed)
    {
        Write-Verbose -Message "Installing $Package"
        scoop install $Package
    }
    else
    {
        Write-Verbose -Message "Package $Package already installed! Skipping..."
    }
}

function Install-WinGetApp
{
    param (
        [string]$PackageID
    )
    Write-Verbose -Message "Preparing to install $PackageID"
    # Added accept options based on this issue - https://github.com/microsoft/winget-cli/issues/1559
    #$listApp = winget list --exact -q $PackageID --accept-source-agreements
    #if (winget list --exact --id "$PackageID" --accept-source-agreements) {
    #    Write-Verbose -Message "Package $PackageID already installed! Skipping..."
    #} else {
    #    Write-Verbose -Message "Installing $Package"
    #    winget install --silent --id "$PackageID" --accept-source-agreements --accept-package-agreements
    #}
    Write-Verbose -Message "Installing $Package"
    try
    {
        winget install --silent --id "$PackageID" --accept-source-agreements --accept-package-agreements
    }
    catch
    {
        Write-Output "Puedes cerrar esta ventana y cuando el script termine, vuelve a lanzarlo en otra vetana nueva en administrador"
        Write-Output "para que terminen de cargarse las configuracines. Si sigue sin funcionar es bueno que reinicies momentaneamente el ordenador..."
        Exit
    }
}

function Install-ChocoApp
{
    param (
        [string]$Package
    )
    Write-Verbose -Message "Preparing to install $Package"
    $listApp = choco list --local $Package
    if ($listApp -like "0 packages installed.")
    {
        Write-Verbose -Message "Installing $Package"
        Start-Process -FilePath "PowerShell" -ArgumentList "choco", "install", "$Package", "-y" -Verb RunAs -Wait
    }
    else
    {
        Write-Verbose -Message "Package $Package already installed! Skipping..."
    }
}

function Extract-Download
{
    param (
        [string]$Folder,
        [string]$File
    )
    if (!(Test-Path -Path "$Folder" -PathType Container))
    {
        Write-Error "$Folder does not exist!!!"
        Break
    }
    if (Test-Path -Path "$File" -PathType Leaf)
    {
        switch ($File.Split(".") | Select-Object -Last 1)
        {
            "rar" {
                Start-Process -FilePath "UnRar.exe" -ArgumentList "x", "-op'$Folder'", "-y", "$File" -WorkingDirectory "$Env:ProgramFiles\WinRAR\" -Wait | Out-Null
            }
            "zip" {
                7z x -o"$Folder" -y "$File" | Out-Null
            }
            "7z" {
                7z x -o"$Folder" -y "$File" | Out-Null
            }
            "exe" {
                7z x -o"$Folder" -y "$File" | Out-Null
            }
            Default {
                Write-Error "No way to Extract $File !!!"; Break
            }
        }
    }
}

function Download-CustomApp
{
    param (
        [string]$Link,
        [string]$Folder
    )
    if ((curl -sIL "$Link" | Select-String -Pattern "Content-Disposition") -ne $Null)
    {
        $Package = $( curl -sIL "$Link" | Select-String -Pattern "filename=" | Split-String -Separator "=" | Select-Object -Last 1 ).Trim('"')
    }
    else
    {
        $Package = $Link.split("/") | Select-Object -Last 1
    }
    Write-Verbose -Message "Preparing to download $Package"
    aria2c --quiet --dir = "$Folder" "$Link"
    Return $Package
}

function Install-CustomApp
{
    param (
        [string]$URL,
        [string]$Folder
    )
    $Package = Download-CustomApp -Link $URL -Folder "$Env:UserProfile\Downloads\"
    if (Test-Path -Path "$Env:UserProfile\Downloads\$Package" -PathType Leaf)
    {
        if (Test-Path Variable:Folder)
        {
            if (!(Test-Path -Path "$Env:UserProfile\bin\$Folder"))
            {
                New-Item -Path "$Env:UserProfile\bin\$Folder" -ItemType Directory | Out-Null
            }
            Extract-Download -Folder "$Env:UserProfile\bin\$Folder" -File "$Env:UserProfile\Downloads\$Package"
        }
        else
        {
            Extract-Download -Folder "$Env:UserProfile\bin\" -File "$Env:UserProfile\Downloads\$Package"
        }
        Remove-Item -Path "$Env:UserProfile\Downloads\$Package"
    }
}

function Install-CustomPackage
{
    param (
        [string]$URL
    )
    $Package = Download-CustomApp -Link $URL
    if (Test-Path -Path "$Env:UserProfile\Downloads\$Package" -PathType Leaf)
    {
        Start-Process -FilePath ".\$Package" -ArgumentList "/S" -WorkingDirectory "${Env:UserProfile}\Downloads\" -Verb RunAs -Wait #-WindowStyle Hidden
        Remove-Item -Path "$Env:UserProfile\Downloads\$Package"
    }
}

function Remove-InstalledApp
{
    param (
        [string]$Package
    )
    Write-Verbose -Message "Uninstalling: $Package"
    Start-Process -FilePath "PowerShell" -ArgumentList "Get-AppxPackage", "-AllUsers", "-Name", "'$Package'" -Verb RunAs -WindowStyle Hidden
}

function Enable-Bucket
{
    param (
        [string]$Bucket
    )
    if (!($( scoop bucket list ).Name -eq "$Bucket"))
    {
        Write-Verbose -Message "Adding Bucket $Bucket to scoop..."
        scoop bucket add $Bucket
    }
    else
    {
        Write-Verbose -Message "Bucket $Bucket already added! Skipping..."
    }
}

function Continue-Installation-In-New-Window
{
    Write-Output "Continuamos la instalación en otra ventana para cargar las nuevas configuraciones..."
    Write-Output "Puedes cerrar esta ventana y cuando el script termine, vuelve a lanzarlo en otra vetana nueva en administrador"
    Write-Output "para que terminen de cargarse las configuracines."
    Start-Process powershell -ArgumentList "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", "iex ((New-Object System.Net.WebClient).DownloadString(`'https://gist.githubusercontent.com/RubenZagon/1d4931f2547757c3d5ddce75f6b65378/raw/powershell-setup.ps1`'))" -Verb runAs
    Exit
}

# Configure ExecutionPolicy to Unrestricted for CurrentUser Scope
if ((Get-ExecutionPolicy -Scope CurrentUser) -notcontains "Unrestricted")
{
    Write-Verbose -Message "Setting Execution Policy for Current User..."
    Start-Process -FilePath "PowerShell" -ArgumentList "Set-ExecutionPolicy", "-Scope", "CurrentUser", "-ExecutionPolicy", "Unrestricted", "-Force" -Verb RunAs -Wait
    #    Write-Output "Restart/Re-Run script!!!"
    #    Start-Sleep -Seconds 10
    Continue-Installation-In-New-Window
    Break
}

# Install Scoop, if not already installed
#$scoopInstalled = Get-Command "scoop"
if (!(Get-Command -Name "scoop" -CommandType Application -ErrorAction SilentlyContinue))
{
    Write-Verbose -Message "Installing Scoop..."
    iex "& {$( irm get.scoop.sh )} -RunAsAdmin"
}


# Install Chocolatey, if not already installed
#$chocoInstalled = Get-Command -Name "choco" -CommandType Application -ErrorAction SilentlyContinue | Out-Null
if (!(Get-Command -Name "choco" -CommandType Application -ErrorAction SilentlyContinue))
{
    Write-Verbose -Message "Installing Chocolatey..."
    @'
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
'@ > $Env:Temp\choco.ps1
    Start-Process -FilePath "PowerShell" -ArgumentList "$Env:Temp\choco.ps1" -Verb RunAs -Wait
    Remove-Item -Path $Env:Temp\choco.ps1 -Force
}

# Install WinGet, if not already installed
# From crutkas's gist - https://gist.github.com/crutkas/6c2096eae387e544bd05cde246f23901
#$hasPackageManager = Get-AppPackage -name "Microsoft.DesktopAppInstaller"
if (!(Get-AppPackage -name "Microsoft.DesktopAppInstaller"))
{
    Write-Verbose -Message "Installing WinGet..."
    @'
# Set URL and Enable TLSv12
$releases_url = "https://api.github.com/repos/microsoft/winget-cli/releases/latest"
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12

# Dont Think We Need This!!!
#Install-PackageProvider -Name NuGet

# Install Nuget as Package Source Provider
Register-PackageSource -Name Nuget -Location "http://www.nuget.org/api/v2" -ProviderName Nuget -Trusted

# Grab "Latest" release
$releases = Invoke-RestMethod -uri $releases_url
$latestRelease = $releases.assets | Where { $_.browser_download_url.EndsWith('msixbundle') } | Select -First 1

# Install Microsoft.DesktopAppInstaller Package
Add-AppxPackage -Path $latestRelease.browser_download_url
'@ > $Env:Temp\winget.ps1
    Start-Process -FilePath "PowerShell" -ArgumentList "$Env:Temp\winget.ps1" -Verb RunAs -Wait
    Remove-Item -Path $Env:Temp\winget.ps1 -Force
}

# Only install OpenSSH Package, if not on Windows 10
if ([Environment]::OSVersion.Version.Major -lt 10)
{
    Install-ScoopApp -Package "openssh"
}

# Install OpenSSH.Client on Windows 10+
@'
if ((Get-WindowsCapability -Online -Name OpenSSH.Client*).State -ne "Installed") {
    Add-WindowsCapability -Online -Name OpenSSH.Client*
}
'@ > "${Env:Temp}\openssh.ps1"
Start-Process -FilePath "PowerShell" -ArgumentList "${Env:Temp}\openssh.ps1" -Verb RunAs -Wait -WindowStyle Hidden
Remove-Item -Path "${Env:Temp}\openssh.ps1" -Force

# Se prueba si está winget bien instalado, si no que se reinicie y vuelva a lanzar el comando
try
{
    Write-Output "Comprobando que winget está bien instalado..."
    winget --list
    Write-Output "Okay !"
}
catch
{
    Start-Sleep -Seconds 5
    Write-Error "`nReiniciar el ordenador para que se cojan bien los cambios y comenzar hacer la instalación sin probla"
    Write-Output "`n`nPor favor, tras reiniciar vuelve a lanzar el script para continuar :)`n`n"
    Write-Output "Reiniciando en 10 segundos..."
    Start-Sleep -Seconds 10
    Restart-Computer -Force
}

if ((Get-Command -Name "choco" -CommandType Application -ErrorAction SilentlyContinue))
{
    Write-Host "`n`n
Vamos a comenzar la instalación auto-mágica de una serie de configuraciones para que sea más fácil programar
en Windows, para ello vamos a instalar mínimo las siguientes aplicaciones:
    - Microsoft.PowerToys: Nos da un sinfin de herramientas útiles
    - PuTTY:
    - Git:
    - WinRAR: Para extraer paquetes .rar
    - Slack: Comunicación por chat
    - Zoom: Para hacer videollamadas
    - JetBrains -Toolbox: Gestor para instalar IDEs de JetBrains
    - Bitwarden: Gestor de contraseñas
    - Malwarebytes: Antivirus
    - Greenshot: Para hacer capturas de pantallas, con más utilidades
    - chrisant996.Clink: Un add-on para la consola de Windows que mejora la funcionalidad y la experiencia de usuario al agregar características como el autocompletado y la compatibilidad con la línea de comandos Unix.
`n
Más adelante se preguntará por qué navegadores webs quieres instalar y aplicaciones opcionales.

IMPORTANTE: Si en ocasiones sientes que 'esta trabado el script' pulsa un par de veces (ENTER) para seguir teniendo feedback del proceso
`n"

    while ($confirmation -eq $null)
    {

        $confirmation = Read-Host -Prompt "Lo has entendido bien? ([Y]es/[N]o)?"
        if ($confirmation -eq "n" -or $confirmation -eq "N")
        {
            Write-Host "`n`nEntonces es mejor que hagas la instalación de las aplicaciones de manera manual, vamos a salir de este modo :)"
            exit
        }

    }

    Write-Host "`nComenzamos la instalación ...`n"

}

# Configure git
Write-Verbose -Message "Installing Git..."
if (Get-Command -Name "choco" -CommandType Application -ErrorAction SilentlyContinue)
{
    choco install git -y
    # Make `refreshenv` available right away, by defining the $env:ChocolateyInstall
    # variable and importing the Chocolatey profile module.
    # Note: Using `. $PROFILE` instead *may* work, but isn't guaranteed to.
    $env:ChocolateyInstall = Convert-Path "$( (Get-Command choco).Path )\..\.."
    Import-Module "$env:ChocolateyInstall\helpers\chocolateyProfile.psm1"

    # refreshenv is now an alias for Update-SessionEnvironment
    # (rather than invoking refreshenv.cmd, the *batch file* for use with cmd.exe)
    # This should make git.exe accessible via the refreshed $env:PATH, so that it
    # can be called by name only.
    refreshenv
    Start-Sleep -Seconds 5
}
else
{
    Write-Verbose -Message "Chocolatey not are installed, please try to re-run the script or solve the problem installing manually..."
    Exit
}

if (!$( git config --global credential.helper ) -eq "manager-core")
{
    Write-Verbose -Message "Configure git config --clobal credential.helper to manager-core"
    git config --global credential.helper manager-core
}
if (!($Env:GIT_SSH))
{
    Write-Verbose -Message "Setting GIT_SSH User Environment Variable"
    [System.Environment]::SetEnvironmentVariable('GIT_SSH', (Resolve-Path (scoop which ssh)), 'USER')
}

Write-Output "`nVamos a configurar tus credenciales de git...`n"
while ($gitUserMail -eq $null -or $gitUserName -eq $null)
{
    $gitUserMail = Read-Host -Prompt "Email: "
    if ($gitUserMail -eq $null -or $gitUserMail -eq "")
    {
        Write-Output "No se ha introducido un email válido. Por favor, introduzca un email válido."
    }
    $gitUserName = Read-Host -Prompt "Tu nombre: "
    if ($gitUserName -eq $null -or $gitUserName -eq "")
    {
        Write-Output "No se ha introducido un nombre válido. Por favor, introduzca un nombre válido."
    }
}

git config --global user.email "$gitUserMail"
git config --global user.name "$gitUserName"

<#
    Este bloque de código se encarga de verificar si el servicio ssh-agent está corriendo, y si no lo esta, lo
    inicia en modo manual, utilizando la linea de comando Set-Service.

    Poner el servicio ssh-agent en modo manual permite a los usuarios tener mayor control sobre cuándo se
    inicia el servicio, mejorar el rendimiento del sistema, aumentar la seguridad y facilitar la administración.
    Sin embargo, esto también significa que el usuario debe recordar manualmente iniciar el servicio cada
    vez que desee utilizar una conexión SSH.
 #>
#>
#>
if ((Get-Service -Name ssh-agent).Status -ne "Running")
{
    Start-Process -FilePath "PowerShell" -ArgumentList "Set-Service", "ssh-agent", "-StartupType", "Manual" -Verb RunAs -Wait -WindowStyle Hidden
}

# Configure Aria2 Download Manager
<#
    Necesitamos esto para habilitar la multi-conexión de descargas en scoop por ejemplo y agilizar el proceso
    de instalación
 #>
Install-ScoopApp -Package "aria2"
if (!$( scoop config aria2-enabled ) -eq $True)
{
    scoop config aria2-enabled true
}
if (!$( scoop config aria2-warning-enabled ) -eq $False)
{
    scoop config aria2-warning-enabled false
}
if (!(Get-ScheduledTaskInfo -TaskName "Aria2RPC" -ErrorAction Ignore))
{
    @'
$Action = New-ScheduledTaskAction -Execute $Env:UserProfile\scoop\apps\aria2\current\aria2c.exe -Argument "--enable-rpc --rpc-listen-all" -WorkingDirectory $Env:UserProfile\Downloads
$Trigger = New-ScheduledTaskTrigger -AtStartup
$Principal = New-ScheduledTaskPrincipal -UserID "$Env:ComputerName\$Env:Username" -LogonType S4U
$Settings = New-ScheduledTaskSettingsSet -ExecutionTimeLimit 0 -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries
Register-ScheduledTask -TaskName "Aria2RPC" -Action $Action -Trigger $Trigger -Principal $Principal -Settings $Settings
'@ > $Env:Temp\aria2.ps1
    Start-Process -FilePath "PowerShell" -ArgumentList "$Env:Temp\aria2.ps1" -Verb RunAs -Wait #-WindowStyle Hidden
    Remove-Item -Path $Env:Temp\aria2.ps1 -Force
}

## Add Buckets
Enable-Bucket -Bucket "extras"
Enable-Bucket -Bucket "java"
Enable-Bucket -Bucket "nirsoft"
scoop bucket add foosel https://github.com/foosel/scoop-bucket

# UNIX Tools
Write-Verbose -Message "Removing curl Alias..."
<#
    Uso de otra herramienta: Como vamos a estar utilizando otra herramienta de línea de comandos para descargar
    contenido de una URL, como wget o aria2c, y no deseamos tener el alias "curl" disponible.
    Porque el de por defecto usa el objeto de power shell Invoke-WebRequest
 #>
#>
if (Get-Alias -Name curl -ErrorAction SilentlyContinue)
{
    Remove-Item alias:curl
}
if (!($Env:TERM))
{
    Write-Verbose -Message "Setting TERM User Environment Variable"
    [System.Environment]::SetEnvironmentVariable("TERM", "xterm-256color", "USER")
}

# Install Scoop Packages
$Scoop = @(
#"concfg", # https://github.com/lukesampson/concfg
"scoop-tray",
"curl",
"busybox", # BusyBox es una herramienta que permite tener muchas utilidades Unix en un solo ejecutable, incluye una gran variedad de herramientas, como ls, cat, echo, grep, etc.
"fzf", # Proporciona una interfaz interactiva para buscar y seleccionar archivos, directorios, historiales de comandos, etc. en el sistema de archivos. Es altamente personalizable y se integra fácilmente con otras herramientas de línea de comando.
"vim",
"cacert", # Proporciona una colección de certificados de autoridad de confianza que pueden ser utilizados por el sistema para validar las conexiones seguras
"colortool", # Con colortool puede cambiar los colores de fondo, texto, selección, etc. También puede importar y exportar configuraciones de color de diferentes esquemas de color.
"sudo",
"gpg", # "GPG" es un acrónimo de "GNU Privacy Guard" (Guardia de Privacidad de GNU en español), es una herramienta de software libre para la cifrado de datos y la verificación de firmas digitales. GPG es compatible con el estándar OpenPGP, lo que significa que puede utilizarse para cifrar y firmar mensajes de correo electrónico y archivos de forma segura.
"spacesniffer", # Permite analizar el espacio de almacenamiento en disco. Permite ver de manera gráfica cómo el espacio de almacenamiento está siendo utilizado en un sistema de archivos
<#
Sysinternals es un conjunto de herramientas de sistema de Microsoft para Windows. El conjunto incluye una variedad de herramientas para ayudar a los administradores de sistemas y desarrolladores a solucionar problemas, monitorear y analizar el rendimiento del sistema, y rastrear procesos y servicios.

Algunas de las herramientas más conocidas de Sysinternals incluyen:

Process Explorer: una herramienta de monitoreo de procesos que permite ver detalles completos sobre los procesos que se están ejecutando en el sistema.
Autoruns: una herramienta para ver y administrar los programas que se inician automáticamente con el sistema.
Process Monitor: una herramienta para monitorear el sistema en tiempo real y ver detalles sobre procesos, registros de registro, E/S de archivos y más.
PsTools: un conjunto de herramientas de línea de comando para interactuar con procesos, servicios y sistemas remotos.
Disk2vhd: una herramienta para crear imágenes de disco de máquinas virtuales a partir de volúmenes de disco físicos.
Sysinternals es un recurso valioso para los administradores de sistemas y desarrolladores que buscan solucionar problemas y optimizar el rendimiento de Windows. Muchas de las herramientas de Sysinternals son muy populares entre las personas que trabajan en sistemas y se utilizan a menudo para solucionar problemas y hacer seguimiento de problemas complejos.
#>
"sysinternals",
"pshazz", # https://github.com/lukesampson/pshazz , Es como poner Oh-My-Zsh

"mpv" # Alternativa a VLC Player
)
foreach ($item in $Scoop)
{
    if (!(scoop list | Select-String "$item" -Quiet))
    {
        Install-ScoopApp -Package "$item"
    }
}

# Install WinGet Packages
$WinGet = @(
"Microsoft.PowerToys",
"PuTTY.PuTTY",
"RARLab.WinRAR",
"SlackTechnologies.Slack",
"Zoom.Zoom",
"JetBrains.Toolbox",
"Bitwarden.Bitwarden", # Gestor de contraseñas
"Malwarebytes.Malwarebytes", # Antivirus
"Greenshot.Greenshot",
"chrisant996.Clink"# https://chrisant996.github.io/clink/ - Clink combines the native Windows shell cmd.exe with the powerful command line editing features of the GNU Readline library
)

foreach ($item in $WinGet)
{
    Install-WinGetApp -PackageID "$item"
}

# Seleccionar qué navegadores web quieres instalar
$applicationsOpt =
[PsCustomObject]@{
    Name = "Google Chrome"; Id = "Google.Chrome"
},
[PsCustomObject]@{
    Name = "Sidekick"; Id = "PushPlayLabs.Sidekick"
},
[PsCustomObject]@{
    Name = "Mozilla.Firefox"; Id = "Mozilla.Firefox"
},
[PsCustomObject]@{
    Name = "Opera"; Id = "Opera.Opera"
}

$selectedApplicationsOpt = $applicationsOpt | Select-Object -Property Name, Id |
        Out-GridView -Title "Selecciona con (Shift + clic) o (Ctrl + clic) una o más navegares web a instalar y pulsa (ENTER) para ejecutar:" -PassThru |
        Select-Object -ExpandProperty Id

Write-Host "Navegadores web seleccionados para instalar: $selectedApplicationsOpt"

$WinGet = @( $selectedApplicationsOpt )
foreach ($item in $WinGet)
{
    Install-WinGetApp -PackageID "$item"
}

# Seleccionar qué aplicaciones opcionales a instalar
$applicationsOpt =
[PsCustomObject]@{
    Name = "Obsidian"; Id = "Obsidian.Obsidian"; Description = "Aplicación de notas enfocada en conexiones, organización y estructuración de información. Permite tomar notas en formato de texto plano y crear vínculos entre ellas para construir una estructura de conocimiento personal."
},
[PsCustomObject]@{
    Name = "HWMonitor"; Id = "CPUID.HWMonitor"; Description = "HWMonitor es útil para los usuarios que deseen monitorear el rendimiento de su sistema, detectar problemas de sobrecalentamiento y verificar el estado de la batería. También es útil para los profesionales de TI que deseen monitorear los servidores y equipos en una red."
},
[PsCustomObject]@{
    Name = "BleachBit"; Id = "BleachBit.BleachBit"; Description = "BleachBit es una herramienta de limpieza de sistema. Te permite limpiar archivos temporales, cachés, historiales, cookies y otros datos no deseados de tu sistema para liberar espacio en disco y mejorar el rendimiento."
},
[PsCustomObject]@{
    Name = "SumatraPDF"; Id = "SumatraPDF.SumatraPDF"; Description = "Lector de PDF gratuito y de código abierto para Windows. Ofrece una interfaz de usuario sencilla y una respuesta rápida, y es capaz de abrir y ver archivos PDF y otros formatos de libro electrónico, como ePub, MOBI, y XPS"
},
[PsCustomObject]@{
    Name = "Spark"; Id = "Readdle.Spark"; Description = "Gestor de mail inteligente"
},
[PsCustomObject]@{
    Name = "OBS Studio"; Id = "com.obsproject.Studio"; Description = "Grabadora de pantalla"
},
[PsCustomObject]@{
    Name = "DBeaver"; Id = "dbeaver.dbeaver"; Description = "Herramienta para administradores de bases de datos y desarrolladores que permite conectarse y gestionar varios tipos de bases de datos."
},
[PsCustomObject]@{
    Name = "DiskGenius"; Id = "Eassos.DiskGenius"; Description = "Software de gestión de disco. Ofrece funciones como la recuperación de archivos, la partición de disco, la copia de seguridad y la clonación de disco, la gestión de archivos y la comprobación de errores en el disco duro."
},
[PsCustomObject]@{
    Name = "AutoHotkey"; Id = "Lexikos.AutoHotkey"; Description = "Permite crear scripts para realizar tareas repetitivas de manera rápida y sencilla, como mapear teclas, enviar texto, crear ventanas emergentes y mucho más."
},
[PsCustomObject]@{
    Name = "RevoUninstaller"; Id = "RevoUninstaller.RevoUninstaller"; Description = "Es una herramienta muy útil para desinstalar programas que no se pueden desinstalar de forma normal, limpiar el registro y eliminar archivos y carpetas dejados en el sistema después de la desinstalación. Además, su interfaz es fácil de usar y permite desinstalar varios programas de forma masiva."
},
[PsCustomObject]@{
    Name = "Starship"; Id = "Starship.Starship"; Description = "El objetivo de Starship es proporcionar una experiencia de línea de comando rápida, eficiente y vistosa para los usuarios."
}

$selectedApplicationsOpt = $applicationsOpt | Select-Object -Property Name, Description, Id |
        Out-GridView -Title "Selecciona con (Shift + clic) o (Ctrl + clic) una o más aplicaciones opcionales a instalar y pulsa (ENTER) para ejecutar:" -PassThru |
        Select-Object -ExpandProperty Id

Write-Host "Aplicaciones seleccionados para instalar: $selectedApplicationsOpt"

$WinGet = @( $selectedApplicationsOpt )
foreach ($item in $WinGet)
{
    Install-WinGetApp -PackageID "$item"
}

# Install Chocolatey Packages
$Choco = @(
"syspin" # To pin application in task desktop
)
foreach ($item in $Choco)
{
    Install-ChocoApp -Package "$item"
}

# Create scoop-tray shortcut in shell:startup
if (!(Test-Path -Path "$Env:AppData\Microsoft\Windows\Start Menu\Programs\Startup\scoop-tray.lnk" -PathType Leaf))
{
    Write-Verbose -Message "Create scoop-tray shortcut in shell:startup..."
    $WSHShell = New-Object -ComObject WScript.Shell
    $Shortcut = $WSHShell.CreateShortcut("$Env:AppData\Microsoft\Windows\Start Menu\Programs\Startup\scoop-tray.lnk")
    $Shortcut.TargetPath = "$Env:UserProfile\scoop\apps\scoop-tray\current\scoop-tray.bat"
    $Shortcut.WindowStyle = 7
    $Shortcut.IconLocation = "%USERPROFILE%\scoop\apps\scoop-tray\current\updates-available.ico"
    $Shortcut.Description = "scoop-tray.bat"
    $Shortcut.WorkingDirectory = Split-Path "$Env:UserProfile\scoop\apps\scoop-tray\current\scoop-tray.bat" -Resolve
    $Shortcut.Save()
}

# Customize DOS/PowerShell Environment
Write-Verbose -Message "Customize DOS/PowerShell Environment..."
if ((Get-ItemProperty -Path "HKCU:\Software\Microsoft\Command Processor").AutoRun -eq $Null)
{
    Start-Process -FilePath "cmd" -ArgumentList "/c", "clink", "autorun", "install" -Wait -WindowStyle Hidden
}

# Pin Google Chrome to Taskbar
Write-Verbose -Message "Pin Google Chrome to Taskbar..."
Start-Process -FilePath "PowerShell" -ArgumentList "syspin", "'$Env:ProgramData\Microsoft\Windows\Start Menu\Programs\Google Chrome.lnk'", "c:5386" -Wait -NoNewWindow

# Pin PowerShell to Taskbar
Write-Verbose -Message "Pin PowerShell to Taskbar..."
Start-Process -FilePath "PowerShell" -ArgumentList "syspin", "'$Env:AppData\Microsoft\Windows\Start Menu\Programs\Windows PowerShell\Windows PowerShell.lnk'", "c:5386" -Wait -NoNewWindow

# Install PowerShell 7
$PS7 = winget list --exact -q Microsoft.PowerShell
if (!$PS7)
{
    Write-Verbose -Message "Installing PowerShell 7..."
    @'
iex "& { $(irm https://aka.ms/install-powershell.ps1) } -UseMSI -Quiet"
'@ > $Env:Temp\ps7.ps1
    Start-Process -FilePath "PowerShell" -ArgumentList "$Env:Temp\ps7.ps1" -Verb RunAs -Wait -WindowStyle Hidden
    Remove-Item -Path $Env:Temp\ps7.ps1 -Force
}
# Pin PowerShell 7 to Taskbar
Write-Verbose -Message "Pin PowerShell 7 to Taskbar..."
Start-Process -FilePath "PowerShell" -ArgumentList "syspin", "'$Env:ProgramData\Microsoft\Windows\Start Menu\Programs\PowerShell\PowerShell 7 (x64).lnk'", "c:5386" -Wait -NoNewWindow

# Remove unused Packages/Applications
Write-Verbose -Message "Removing Unused Applications..."
$RemoveApps = @(
)
foreach ($item in $RemoveApps)
{
    Remove-InstalledApp -Package $item
}

# Set alias
set-alias -name gco -value 'git checkout' -Scope Global
# set-alias -name gl -value 'git pull' -Scope Global #(No puedo sobrescribirlo, porque ya se está usando)
set-alias -name gst -value 'git status' -Scope Global
set-alias -name gf -value 'git fetch --all --prune' -Scope Global
set-alias -name git-clean-local-branches -value 'git branch --merged | Select-String -AllMatches "(^\*|master|main|dev)" | ForEach-Object {git branch -d $_}' -Scope Global

# Instalación de Docker, la dejo al final porque requiere de reinicio y es complicado de en Windows Home, porque necesita de instalación de una distri de Linux
Write-Host "`n`n
Deseas realizar la instalación de Docker Desktop?
`n
Para ello debemos instalar una distribución de Linux, en este caso instalaremos Ubuntu 20.04, para que funcione correctamente. Y se reiniciará el equipo para aplicar los cambios.
`n"

while ($dockerConfirmation -eq $null)
{
    $dockerConfirmation = Read-Host -Prompt "Deseas continuar ([Y]es/[N]o)?"
    if ($dockerConfirmation -eq "y" -or $dockerConfirmation -eq "Y")
    {
        Write-Verbose -Message "Instalando Ubuntu 20.04..."
        wsl --set-default-version 2
        wsl --update
        wsl --install -d Ubuntu-20.04
        Start-Sleep -Seconds 5
        if ((wsl --list --verbose))
        {
            # Aqui tiene que verificar que se ha instalado la distribución linux primero... antes de continuar
            Write-Verbose -Message "Instalando Docker Desktop..."
            winget install --exact --id Docker.DockerDesktop --accept-source-agreements --accept-package-agreements
            Write-Verbose -Message "Reiniciando equipo..."
            Start-Sleep -Seconds 5
            Restart-Computer -Force
        }
        else
        {
            Write-Verbose -Message "Se necesita instalar una distribución de Linux para instalar Docker, reinicia el script tras hacer esto."
        }
    }
}


Write-Output "`nInstalación completada! Por favor reinicia tu máquina para que terminen de aplicarse los cambios!"
Start-Sleep -Seconds 3
if ($( Read-Host -Prompt "`nQuieres reiniciar ahora para aplicar los cambios ([Y]es/[N]o)?" ) -eq "y")
{
    Restart-Computer -Force
}
else
{
    exit
}


<#
TODO:
    Ver cómo hacer para instalar plugins en Google Chrome o tal
    Configuracione y plugins de Obsidian
    Que  tras hacer las instalaciones de WinGet, no se abran las aplicaciones automáticamente
#>
<#
Links utiles:
- https://4sysops.com/archives/install-windows-subsystem-for-linux-wsl-in-windows-11/
- https://4sysops.com/archives/install-docker-in-windows-10-and-windows-11/
#>