# SPDX-License-Identifier: MPL-2.0
# Messages en ASCII : compatible Windows PowerShell 5.1 sans BOM.

<#
.SYNOPSIS
    Telecharge (avec reprise) et installe le CUDA Toolkit NVIDIA pour Windows x86_64.

.DESCRIPTION
    Utilise pour le prototype prototypes/gpu_interop (etapes 2 et suivantes).
    CUDA est un composant proprietaire : il reste un plugin facultatif de SEQUA
    (docs, par. 10.2). Sa licence est acceptee par l'utilisateur lui-meme dans
    l'installateur NVIDIA ; ce script n'accepte rien automatiquement.

    Etapes :
      1. lit la version CUDA maximale acceptee par le pilote (nvidia-smi) ;
      2. detecte les CUDA Toolkit deja installes ;
      3. lit le nom exact de l'installateur et son MD5 dans la liste officielle
         NVIDIA (developer.download.nvidia.com/compute/cuda/<version>/docs/sidebar/md5sum.txt) ;
      4. telecharge l'installateur (~2,7 Go) avec reprise : en cas de coupure, relancer
         le script repart du dernier octet recu (curl -C -) ;
      5. verifie le MD5, puis lance l'installateur NVIDIA en mode interactif.

    A lancer dans une fenetre PowerShell externe (telechargement long, UAC).
    Pendant l'installation, choisir "Personnalisee" et decocher tout composant pilote
    graphique s'il est propose, pour conserver le pilote actuel.

.PARAMETER Version
    Version complete du CUDA Toolkit (ex. 13.5.0). Defaut : 13.5.0.

.PARAMETER CacheDir
    Dossier de telechargement. Defaut : %LOCALAPPDATA%\SEQUA\downloads\cuda.

.PARAMETER DryRun
    Affiche ce qui serait fait (pilote, installations, installateur, etat du cache)
    sans rien telecharger ni installer.

.PARAMETER DownloadOnly
    Telecharge et verifie l'installateur sans l'executer.

.PARAMETER Force
    Reinstalle meme si cette version est deja presente.

.PARAMETER MaxAttempts
    Nombre maximal de reprises du telechargement. Defaut : 50.

.PARAMETER Help
    Affiche cette aide.

.EXAMPLE
    powershell -ExecutionPolicy Bypass -File scripts\install-cuda.ps1 -DryRun

.EXAMPLE
    powershell -ExecutionPolicy Bypass -File scripts\install-cuda.ps1 -DownloadOnly

.EXAMPLE
    powershell -ExecutionPolicy Bypass -File scripts\install-cuda.ps1
#>

[CmdletBinding()]
param(
    [string]$Version = "13.5.0",
    [string]$CacheDir = (Join-Path $env:LOCALAPPDATA "SEQUA\downloads\cuda"),
    [switch]$DryRun,
    [switch]$DownloadOnly,
    [switch]$Force,
    [int]$MaxAttempts = 50,
    [Alias("h", "?")]
    [switch]$Help
)

if ($Help) {
    Get-Help $PSCommandPath -Detailed
    exit 0
}

$ErrorActionPreference = "Stop"
. (Join-Path $PSScriptRoot "lib\SequaDownload.ps1")
$nvidiaBase = "https://developer.download.nvidia.com/compute/cuda"

function Get-DriverCudaVersion {
    $smi = Get-Command nvidia-smi.exe -ErrorAction SilentlyContinue
    if (-not $smi) { throw "nvidia-smi introuvable : pilote NVIDIA absent." }
    $header = (& $smi.Source 2>$null) -join "`n"
    if ($header -match 'CUDA (?:UMD )?Version:\s*([0-9]+\.[0-9]+)') { return [version]$Matches[1] }
    throw "Impossible de lire la version CUDA du pilote dans la sortie de nvidia-smi."
}

function Get-InstalledCuda {
    $base = Join-Path $env:ProgramFiles "NVIDIA GPU Computing Toolkit\CUDA"
    if (-not (Test-Path $base)) { return @() }
    Get-ChildItem $base -Directory |
        Where-Object { $_.Name -match '^v([0-9]+\.[0-9]+)$' -and (Test-Path (Join-Path $_.FullName "bin\nvcc.exe")) } |
        ForEach-Object { [pscustomobject]@{ Version = [version]$_.Name.Substring(1); Path = $_.FullName } } |
        Sort-Object Version -Descending
}

# Nom de l'installateur local Windows x86_64 et son MD5, depuis la liste officielle NVIDIA.
function Get-InstallerInfo([string]$version) {
    $listUrl = "$nvidiaBase/$version/docs/sidebar/md5sum.txt"
    $list = & curl.exe -sL --fail $listUrl
    if ($LASTEXITCODE -ne 0) { throw "Liste NVIDIA introuvable pour CUDA $version ($listUrl). Verifier le numero de version (ex. 13.5.0)." }
    $entry = $list |
        ForEach-Object { if ($_ -match '^([0-9a-fA-F]{32})\s+(cuda_\S*windows\S*\.exe)$') { [pscustomobject]@{ Md5 = $Matches[1]; Name = $Matches[2] } } } |
        Where-Object { $_.Name -notmatch 'network|arm64|cross' } |
        Select-Object -First 1
    if (-not $entry) { throw "Aucun installateur local Windows x86_64 dans $listUrl." }
    [pscustomobject]@{
        Url  = "$nvidiaBase/$version/local_installers/$($entry.Name)"
        Name = $entry.Name
        Md5  = $entry.Md5.ToUpperInvariant()
    }
}

# --- Verifications ----------------------------------------------------------
if ($Version -notmatch '^[0-9]+\.[0-9]+\.[0-9]+$') { throw "-Version attend une version complete, ex. 13.5.0 (recu : $Version)." }
$wanted = [version]$Version

Write-Step "Pilote NVIDIA"
$driverCuda = Get-DriverCudaVersion
Write-Host "  Version CUDA maximale acceptee par le pilote : $driverCuda"
if ($wanted.Major -gt $driverCuda.Major -or ($wanted.Major -eq $driverCuda.Major -and $wanted.Minor -gt $driverCuda.Minor)) {
    throw "CUDA $Version demande un pilote plus recent (pilote limite a CUDA $driverCuda). Mettre a jour le pilote ou choisir une version $driverCuda.x."
}

Write-Step "Installations existantes"
$installed = @(Get-InstalledCuda)
if ($installed.Count -eq 0) {
    Write-Host "  Aucun CUDA Toolkit detecte."
}
else {
    $installed | ForEach-Object { Write-Host "  CUDA $($_.Version) : $($_.Path)" }
}
$same = $installed | Where-Object { $_.Version.Major -eq $wanted.Major -and $_.Version.Minor -eq $wanted.Minor }
if ($same -and -not $Force) {
    Write-Host "CUDA $($wanted.Major).$($wanted.Minor) deja installe. Rien a faire (utiliser -Force pour reinstaller)." -ForegroundColor Green
    exit 0
}

Write-Step "Installateur NVIDIA CUDA $Version"
$info = Get-InstallerInfo $Version
$size = Get-RemoteSize $info.Url
$installer = Join-Path $CacheDir $info.Name
Write-Host "  URL    : $($info.Url)"
Write-Host "  MD5    : $($info.Md5) (liste officielle NVIDIA)"
Write-Host ("  Taille : {0:N1} Go" -f ($size / 1GB))
Write-Host "  Cache  : $installer"

if ($DryRun) {
    $partial = "$installer.part"
    if (Test-Path $installer) { Write-Host "  Installateur deja telecharge." }
    elseif (Test-Path $partial) { Write-Host ("  Telechargement partiel : {0:N0} octets." -f (Get-Item $partial).Length) }
    Write-Host "DryRun : rien n'a ete telecharge ni installe." -ForegroundColor Yellow
    exit 0
}

# --- Telechargement ---------------------------------------------------------
New-Item -ItemType Directory -Force -Path $CacheDir | Out-Null
if (Test-Path $installer) {
    Write-Step "Installateur deja present dans le cache"
}
else {
    Assert-FreeSpace -Path $CacheDir -Needed ($size * 2)
    Write-Step "Telechargement avec reprise"
    Invoke-ResumableDownload $info.Url $installer $size $MaxAttempts
}

Write-Step "Verification MD5"
$hash = Get-FileDigest -Path $installer -Algorithm MD5
if ($hash -ne $info.Md5) {
    Remove-Item $installer -Force
    throw "MD5 incorrect ($hash) : fichier supprime, relancer le script pour le retelecharger."
}
Write-Host "  OK"

if ($DownloadOnly) {
    Write-Host "Installateur pret : $installer" -ForegroundColor Green
    exit 0
}

# --- Installation -----------------------------------------------------------
Write-Step "Installation (UAC et acceptation de la licence NVIDIA demandees)"
Write-Host "  Choisir l'installation PERSONNALISEE et decocher tout composant pilote graphique" -ForegroundColor Yellow
Write-Host "  s'il est propose, pour conserver le pilote actuel." -ForegroundColor Yellow
Write-Host "  Installateur : $installer"
# Le code de retour de l'installateur NVIDIA n'est pas documente et n'est pas fiable
# (code 8 observe alors que l'installation manuelle fonctionne) : seule la presence de
# nvcc apres coup fait foi.
$process = Start-Process -FilePath $installer -Wait -PassThru
$exitCode = $process.ExitCode
if ($exitCode -ne 0) {
    Write-Host "  L'installateur NVIDIA a retourne le code $exitCode (non documente) : verification de l'installation..." -ForegroundColor Yellow
}

# --- Verification -----------------------------------------------------------
Write-Step "Verification"
$installedNow = @(Get-InstalledCuda) | Where-Object { $_.Version.Major -eq $wanted.Major -and $_.Version.Minor -eq $wanted.Minor } | Select-Object -First 1
if (-not $installedNow) {
    Write-Host ""
    Write-Host "CUDA $($wanted.Major).$($wanted.Minor) n'est pas installe (code de l'installateur : $exitCode)." -ForegroundColor Red
    Write-Host "L'installateur verifie reste dans le cache. Le lancer a la main (double-clic) :" -ForegroundColor Yellow
    Write-Host "  $installer"
    Write-Host "puis relancer ce script pour verifier l'installation."
    exit 1
}
$nvcc = Join-Path $installedNow.Path "bin\nvcc.exe"
& $nvcc --version
Write-Host ""
Write-Host "CUDA installe. L'installateur peut etre supprime du cache : $installer" -ForegroundColor Green
Write-Host "Ouvrir un NOUVEAU terminal (PATH et CUDA_PATH mis a jour), puis :"
Write-Host "  .\scripts\build.ps1 -Preset windows-msvc-prototypes"