Browser Managers

impl ChromeManager {
    pub fn new() -> Result<Box<Self>, Error>;
}

use selenium_manager::ChromeManager;
use anyhow::Result;

fn setup_chrome() -> Result<()> {
    let mut manager = ChromeManager::new()?;
    let driver_path = manager.setup()?;
    println!("ChromeDriver ready at: {}", driver_path.display());
    Ok(())
}

impl FirefoxManager {
    pub fn new() -> Result<Box<Self>, Error>;
}

use selenium_manager::FirefoxManager;
use anyhow::Result;

fn setup_firefox() -> Result<()> {
    let mut manager = FirefoxManager::new()?;
    let driver_path = manager.setup()?;
    println!("GeckoDriver ready at: {}", driver_path.display());
    Ok(())
}

impl EdgeManager {
    pub fn new() -> Result<Box<Self>, Error>;
    pub fn new_with_name(browser_name: String) -> Result<Box<Self>, Error>;
}

use selenium_manager::EdgeManager;
use anyhow::Result;

fn setup_edge() -> Result<()> {
    let mut manager = EdgeManager::new()?;
    let driver_path = manager.setup()?;
    println!("EdgeDriver ready at: {}", driver_path.display());
    Ok(())
}

fn setup_webview2() -> Result<()> {
    let mut manager = EdgeManager::new_with_name("webview2".to_string())?;
    let driver_path = manager.setup()?;
    println!("EdgeDriver for WebView2 ready at: {}", driver_path.display());
    Ok(())
}

impl SafariManager {
    pub fn new() -> Result<Box<Self>, Error>;
}

use selenium_manager::SafariManager;
use anyhow::Result;

fn setup_safari() -> Result<()> {
    let mut manager = SafariManager::new()?;
    let driver_path = manager.setup()?;
    println!("SafariDriver ready at: {}", driver_path.display());
    Ok(())
}

impl SafariTPManager {
    pub fn new() -> Result<Box<Self>, Error>;
}

use selenium_manager::SafariTPManager;
use anyhow::Result;

fn setup_safari_tp() -> Result<()> {
    let mut manager = SafariTPManager::new()?;
    let driver_path = manager.setup()?;
    println!("Safari TP Driver ready at: {}", driver_path.display());
    Ok(())
}

impl IExplorerManager {
    pub fn new() -> Result<Box<Self>, Error>;
}

use selenium_manager::IExplorerManager;
use anyhow::Result;

fn setup_internet_explorer() -> Result<()> {
    let mut manager = IExplorerManager::new()?;
    let driver_path = manager.setup()?;
    println!("IEDriverServer ready at: {}", driver_path.display());
    Ok(())
}

impl GridManager {
    pub fn new(grid_version: String) -> Result<Box<Self>, Error>;
}

use selenium_manager::GridManager;
use anyhow::Result;

fn setup_grid() -> Result<()> {
    let mut manager = GridManager::new("4.15.0".to_string())?;
    let grid_path = manager.setup()?;
    println!("Selenium Grid ready at: {}", grid_path.display());
    Ok(())
}

fn get_manager_by_browser(browser_name: String) -> Result<Box<dyn SeleniumManager>, Error>;

use selenium_manager::{get_manager_by_browser, SeleniumManager};
use anyhow::Result;

fn setup_any_browser(browser: &str) -> Result<()> {
    let mut manager = get_manager_by_browser(browser.to_string())?;
    let driver_path = manager.setup()?;
    println!("{} driver ready at: {}", browser, driver_path.display());
    Ok(())
}

fn get_manager_by_driver(driver_name: String) -> Result<Box<dyn SeleniumManager>, Error>;

use selenium_manager::{get_manager_by_driver, SeleniumManager};
use anyhow::Result;

fn setup_by_driver_name(driver: &str) -> Result<()> {
    let mut manager = get_manager_by_driver(driver.to_string())?;
    let driver_path = manager.setup()?;
    println!("Driver {} ready at: {}", driver, driver_path.display());
    Ok(())
}

use selenium_manager::{get_manager_by_browser, SeleniumManager};
use anyhow::Result;

fn setup_multiple_browsers() -> Result<()> {
    let browsers = vec!["chrome", "firefox", "edge"];
    let mut driver_paths = Vec::new();
    
    for browser in browsers {
        match get_manager_by_browser(browser.to_string()) {
            Ok(mut manager) => {
                match manager.setup() {
                    Ok(path) => {
                        println!("{} driver: {}", browser, path.display());
                        driver_paths.push((browser, path));
                    }
                    Err(e) => {
                        eprintln!("Failed to setup {}: {}", browser, e);
                    }
                }
            }
            Err(e) => {
                eprintln!("Failed to create {} manager: {}", browser, e);
            }
        }
    }
    
    println!("Setup complete for {} browsers", driver_paths.len());
    Ok(())
}