plugin_host/

scanner.rs

use crate::descriptor::{PluginDescriptor, PluginFormat};
use std::path::{Path, PathBuf};

/// Resultado de escanear un archivo de plugin.
#[derive(Debug)]
pub enum ScanResult {
    Ok(Vec<PluginDescriptor>),
    /// El archivo existe pero no es un plugin válido
    Invalid(String),
    /// Error al abrir la librería
    Error(String),
}

/// Escaneador de plugins del sistema.
///
/// Busca en las rutas estándar del OS y en rutas personalizadas.
/// El escaneo es pesado (abre librerías) — se hace en background
/// y los resultados se cachean en el `PluginRegistry`.
pub struct PluginScanner {
    /// Rutas adicionales definidas por el usuario
    extra_paths: Vec<PathBuf>,
}

impl PluginScanner {
    pub fn new() -> Self {
        Self { extra_paths: Vec::new() }
    }

    pub fn add_path(&mut self, path: impl Into<PathBuf>) {
        self.extra_paths.push(path.into());
    }

    /// Rutas estándar donde buscar plugins CLAP según el OS.
    pub fn clap_search_paths() -> Vec<PathBuf> {
        let mut paths = Vec::new();

        #[cfg(target_os = "linux")]
        {
            paths.push(PathBuf::from("/usr/lib/clap"));
            paths.push(PathBuf::from("/usr/local/lib/clap"));
            if let Ok(home) = std::env::var("HOME") {
                paths.push(PathBuf::from(format!("{}/.clap", home)));
            }
        }

        #[cfg(target_os = "macos")]
        {
            paths.push(PathBuf::from("/Library/Audio/Plug-Ins/CLAP"));
            if let Ok(home) = std::env::var("HOME") {
                paths.push(PathBuf::from(format!(
                    "{}/Library/Audio/Plug-Ins/CLAP", home
                )));
            }
        }

        #[cfg(target_os = "windows")]
        {
            if let Ok(program_files) = std::env::var("COMMONPROGRAMFILES") {
                paths.push(PathBuf::from(format!("{}\\CLAP", program_files)));
            }
            if let Ok(local) = std::env::var("LOCALAPPDATA") {
                paths.push(PathBuf::from(format!("{}\\Programs\\Common\\CLAP", local)));
            }
        }

        paths
    }

    /// Rutas estándar donde buscar plugins VST3.
    pub fn vst3_search_paths() -> Vec<PathBuf> {
        let mut paths = Vec::new();

        #[cfg(target_os = "linux")]
        {
            paths.push(PathBuf::from("/usr/lib/vst3"));
            paths.push(PathBuf::from("/usr/local/lib/vst3"));
            if let Ok(home) = std::env::var("HOME") {
                paths.push(PathBuf::from(format!("{}/.vst3", home)));
            }
        }

        #[cfg(target_os = "macos")]
        {
            paths.push(PathBuf::from("/Library/Audio/Plug-Ins/VST3"));
            if let Ok(home) = std::env::var("HOME") {
                paths.push(PathBuf::from(format!(
                    "{}/Library/Audio/Plug-Ins/VST3", home
                )));
            }
        }

        #[cfg(target_os = "windows")]
        {
            if let Ok(program_files) = std::env::var("PROGRAMFILES") {
                paths.push(PathBuf::from(format!("{}\\Common Files\\VST3", program_files)));
            }
        }

        paths
    }

    /// Escanea todas las rutas estándar + extras para un formato dado.
    /// Devuelve un iterator de (path, ScanResult).
    pub fn scan_format<'a>(
        &'a self,
        format: PluginFormat,
    ) -> impl Iterator<Item = (PathBuf, ScanResult)> + 'a {
        let standard = match format {
            PluginFormat::Clap => Self::clap_search_paths(),
            PluginFormat::Vst3 => Self::vst3_search_paths(),
        };

        let all_paths: Vec<PathBuf> = standard
            .into_iter()
            .chain(self.extra_paths.iter().cloned())
            .collect();

        all_paths.into_iter().flat_map(move |dir| {
            Self::find_plugins_in_dir(&dir, format)
                .into_iter()
                .map(move |path| {
                    let result = Self::scan_file(&path, format);
                    (path, result)
                })
        })
    }

    /// Encuentra todos los archivos de plugin en un directorio (recursivo).
    pub fn find_plugins_in_dir(dir: &Path, format: PluginFormat) -> Vec<PathBuf> {
        let ext = format.extension();
        let mut found = Vec::new();

        let Ok(entries) = std::fs::read_dir(dir) else { return found; };

        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_dir() {
                // VST3 son bundles (carpetas .vst3)
                if path.extension().map_or(false, |e| e == ext) {
                    found.push(path);
                } else {
                    found.extend(Self::find_plugins_in_dir(&path, format));
                }
            } else if path.extension().map_or(false, |e| e == ext) {
                found.push(path);
            }
        }

        found
    }

    /// Escanea un archivo de plugin específico y extrae sus descriptores.
    ///
    /// En producción esto abre la librería y llama a su factory.
    /// Aquí retornamos una implementación stub que será completada
    /// por ClapBridge y Vst3Bridge.
    pub fn scan_file(path: &Path, format: PluginFormat) -> ScanResult {
        if !path.exists() {
            return ScanResult::Error(format!("Path does not exist: {}", path.display()));
        }

        // El hash del archivo permite detectar si el plugin cambió
        // y necesita re-escanearse
        let file_hash = Self::hash_file(path).unwrap_or(0);

        match format {
            PluginFormat::Clap => crate::bridge::clap::scan_clap_file(path, file_hash),
            PluginFormat::Vst3 => crate::bridge::vst3::scan_vst3_file(path, file_hash),
        }
    }

    /// Hash rápido del archivo para detectar cambios (FNV-1a sobre los primeros 64KB).
    fn hash_file(path: &Path) -> std::io::Result<u64> {
        use std::io::Read;
        let mut file = std::fs::File::open(path)?;
        let mut buf = [0u8; 65536];
        let n = file.read(&mut buf)?;

        let mut hash: u64 = 0xcbf29ce484222325;
        for &byte in &buf[..n] {
            hash ^= byte as u64;
            hash = hash.wrapping_mul(0x100000001b3);
        }
        Ok(hash)
    }
}

impl Default for PluginScanner {
    fn default() -> Self {
        Self::new()
    }
}