# Script pour copier les fichiers de configuration vers le projet
# Lit files-config.txt et copie chaque fichier vers configs/{system}/

param(
    [string]$ConfigFile = "files-config.txt",
    [string]$MappingFile = "path-mapping.json"
)

$ErrorActionPreference = "Stop"

# Vérifier que le fichier de configuration existe
if (-not (Test-Path $ConfigFile)) {
    Write-Error "Le fichier de configuration '$ConfigFile' n'existe pas."
    exit 1
}

# Créer les répertoires de destination
$configsDir = "configs"
$windowsDir = Join-Path $configsDir "windows"
$wslDir = Join-Path $configsDir "wsl"

foreach ($dir in @($configsDir, $windowsDir, $wslDir)) {
    if (-not (Test-Path $dir)) {
        New-Item -ItemType Directory -Path $dir -Force | Out-Null
        Write-Host "Créé le répertoire: $dir"
    }
}

# Charger le mapping existant ou créer un nouveau
$mapping = @{
    windows = @{}
    wsl = @{}
}

if (Test-Path $MappingFile) {
    try {
        $existingMapping = Get-Content $MappingFile -Raw | ConvertFrom-Json
        if ($existingMapping.windows) {
            $mapping.windows = @{}
            $existingMapping.windows.PSObject.Properties | ForEach-Object {
                $mapping.windows[$_.Name] = $_.Value
            }
        }
        if ($existingMapping.wsl) {
            $mapping.wsl = @{}
            $existingMapping.wsl.PSObject.Properties | ForEach-Object {
                $mapping.wsl[$_.Name] = $_.Value
            }
        }
    } catch {
        Write-Warning "Impossible de charger le mapping existant, création d'un nouveau mapping."
    }
}

# Fonction pour résoudre un chemin Windows
function Resolve-WindowsPath {
    param([string]$path)
    
    # Remplacer les variables d'environnement
    $resolved = $path
    $resolved = $resolved -replace '%USERPROFILE%', $env:USERPROFILE
    $resolved = $resolved -replace '%APPDATA%', $env:APPDATA
    $resolved = $resolved -replace '%LOCALAPPDATA%', $env:LOCALAPPDATA
    $resolved = $resolved -replace '%HOME%', $env:HOME
    $resolved = $resolved -replace '%USERPROFILE%', $env:USERPROFILE
    
    # Remplacer les autres variables d'environnement
    $resolved = [System.Environment]::ExpandEnvironmentVariables($resolved)
    
    return $resolved
}

# Fonction pour résoudre un chemin WSL vers un chemin Windows accessible
function Resolve-WSLPath {
    param([string]$path)
    
    # Détecter la distribution WSL (par défaut Ubuntu)
    $wslDistro = "Ubuntu"
    
    # Expansion de ~ vers /home/toshiro (ou autre utilisateur)
    if ($path -match '^~') {
        $homePath = wsl bash -c "echo ~" 2>$null
        if ($LASTEXITCODE -eq 0 -and $homePath) {
            $path = $path -replace '^~', $homePath
        } else {
            # Fallback: utiliser toshiro
            $path = $path -replace '^~', "/home/toshiro"
        }
    }
    
    # Convertir le chemin WSL en chemin Windows accessible
    # Format: /home/toshiro/.bashrc -> \\wsl.localhost\Ubuntu\home\toshiro\.bashrc
    if ($path -match '^/') {
        # Enlever le slash initial
        $relativePath = $path.Substring(1)
        # Convertir en chemin Windows
        $windowsPath = "\\wsl.localhost\$wslDistro\$relativePath" -replace '/', '\'
        return $windowsPath
    }
    
    return $path
}

# Fonction pour obtenir le chemin relatif dans le projet
function Get-ProjectPath {
    param(
        [string]$system,
        [string]$originalPath
    )
    
    # Nettoyer chaque partie du chemin
    $parts = $originalPath -split '[\\/]'
    $safeParts = @()
    
    foreach ($part in $parts) {
        # Nettoyer chaque partie : remplacer les caractères invalides et les variables
        $safePart = $part -replace '[\\/:*?"<>|]', '_'
        $safePart = $safePart -replace '^%', 'var_' -replace '%$', '' -replace '%', '_'
        $safePart = $safePart -replace '^~', 'home'
        
        # Si la partie est vide après nettoyage, utiliser un nom par défaut
        if ([string]::IsNullOrWhiteSpace($safePart)) {
            $safePart = "root"
        }
        
        $safeParts += $safePart
    }
    
    # Rejoindre toutes les parties avec des underscores
    $safeName = $safeParts -join '_'
    
    # Construire le chemin final
    $basePath = Join-Path "configs" $system
    return Join-Path $basePath $safeName
}

# Lire et traiter le fichier de configuration
$lines = Get-Content $ConfigFile | Where-Object { 
    $_ -notmatch '^\s*#' -and $_.Trim() -ne '' 
}

$copiedCount = 0
$skippedCount = 0
$errorCount = 0

foreach ($line in $lines) {
    $line = $line.Trim()
    if ($line -eq '' -or $line -match '^\s*#') {
        continue
    }
    
    # Parser la ligne: système|chemin
    if ($line -notmatch '^(\w+)\|(.+)$') {
        Write-Warning "Ligne ignorée (format invalide): $line"
        continue
    }
    
    $system = $matches[1]
    $originalPath = $matches[2]
    
    if ($system -notin @('windows', 'wsl')) {
        Write-Warning "Système invalide '$system' dans la ligne: $line"
        continue
    }
    
    try {
        # Résoudre le chemin selon le système
        if ($system -eq 'windows') {
            $resolvedPath = Resolve-WindowsPath $originalPath
        } else {
            # Pour WSL, convertir en chemin Windows accessible
            $resolvedPath = Resolve-WSLPath $originalPath
        }
        
        # Vérifier que le fichier existe
        if (-not (Test-Path $resolvedPath)) {
            Write-Warning "Fichier introuvable: $resolvedPath (original: $originalPath)"
            $skippedCount++
            continue
        }
        
        # Obtenir le chemin de destination dans le projet
        $projectPath = Get-ProjectPath $system $originalPath
        
        # Créer le répertoire parent si nécessaire
        $projectDir = Split-Path $projectPath -Parent
        if (-not (Test-Path $projectDir)) {
            New-Item -ItemType Directory -Path $projectDir -Force | Out-Null
        }
        
        # Copier le fichier
        # Maintenant que les chemins WSL sont convertis en chemins Windows, on peut utiliser Copy-Item pour les deux
        Copy-Item -Path $resolvedPath -Destination $projectPath -Force
        
        # Enregistrer le mapping
        $mapping[$system][$originalPath] = $projectPath
        
        Write-Host "Copié: $originalPath -> $projectPath"
        $copiedCount++
        
    } catch {
        Write-Error "Erreur lors du traitement de '$line': $_"
        $errorCount++
    }
}

# Sauvegarder le mapping
$mappingJson = @{
    windows = $mapping.windows
    wsl = $mapping.wsl
} | ConvertTo-Json -Depth 10

Set-Content -Path $MappingFile -Value $mappingJson -Encoding UTF8

Write-Host "`nRésumé:"
Write-Host "  Fichiers copiés: $copiedCount"
Write-Host "  Fichiers ignorés: $skippedCount"
Write-Host "  Erreurs: $errorCount"
Write-Host "  Mapping sauvegardé dans: $MappingFile"