Configuration

pub struct ManagerConfig {
    pub cache_path: String,
    pub fallback_driver_from_cache: bool,
    pub browser_version: String,
    pub driver_version: String,
    pub browser_path: String,
    pub driver_mirror_url: String,
    pub browser_mirror_url: String,
    pub os: String,
    pub arch: String,
    pub proxy: String,
    pub timeout: u64,
    pub ttl: u64,
    pub offline: bool,
    pub force_browser_download: bool,
    pub avoid_browser_download: bool,
    pub language_binding: String,
    pub selenium_version: String,
    pub avoid_stats: bool,
    pub skip_driver_in_path: bool,
    pub skip_browser_in_path: bool,
}

impl ManagerConfig {
    pub fn default(browser_name: &str, driver_name: &str) -> ManagerConfig;
}

pub enum OS {
    WINDOWS,
    MACOS,
    LINUX,
}

impl OS {
    pub fn is(&self, os: &str) -> bool;
}

pub enum ARCH {
    X32,
    X64,
    ARM64,
}

impl ARCH {
    pub fn is(&self, arch: &str) -> bool;
}

pub struct StringKey(pub Vec<&str>, pub &str);

impl StringKey {
    pub fn get_value(&self) -> String;
}

pub struct IntegerKey(pub &str, pub u64);

impl IntegerKey {
    pub fn get_value(&self) -> u64;
}

pub struct BooleanKey(pub &str, pub bool);

impl BooleanKey {
    pub fn get_value(&self) -> bool;
}

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

fn basic_configuration() -> Result<()> {
    // Create default configuration
    let config = ManagerConfig::default("chrome", "chromedriver");
    
    // Create manager and apply configuration
    let mut manager = get_manager_by_browser("chrome".to_string())?;
    manager.set_config(config);
    
    let driver_path = manager.setup()?;
    println!("Driver ready at: {}", driver_path.display());
    Ok(())
}

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

fn custom_configuration() -> Result<()> {
    let mut config = ManagerConfig::default("firefox", "geckodriver");
    
    // Customize configuration
    config.browser_version = "esr".to_string();
    config.cache_path = "/tmp/selenium-cache".to_string();
    config.timeout = 600;
    config.offline = false;
    config.force_browser_download = true;
    
    let mut manager = get_manager_by_browser("firefox".to_string())?;
    manager.set_config(config);
    
    let driver_path = manager.setup()?;
    println!("Firefox ESR driver ready at: {}", driver_path.display());
    Ok(())
}

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

fn proxy_configuration() -> Result<()> {
    let mut config = ManagerConfig::default("edge", "msedgedriver");
    
    // Configure proxy
    config.proxy = "https://proxy.company.com:8080".to_string();
    config.timeout = 900; // Longer timeout for proxy
    
    let mut manager = get_manager_by_browser("edge".to_string())?;
    manager.set_config(config);
    
    let driver_path = manager.setup()?;
    println!("Edge driver ready at: {}", driver_path.display());
    Ok(())
}

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

fn mirror_configuration() -> Result<()> {
    let mut config = ManagerConfig::default("chrome", "chromedriver");
    
    // Use Chinese mirrors
    config.driver_mirror_url = "https://npm.taobao.org/mirrors/chromedriver/".to_string();
    config.browser_mirror_url = "https://npm.taobao.org/mirrors/chromium-browser-snapshots/".to_string();
    
    let mut manager = get_manager_by_browser("chrome".to_string())?;
    manager.set_config(config);
    
    let driver_path = manager.setup()?;
    println!("Driver ready at: {}", driver_path.display());
    Ok(())
}

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

fn offline_configuration() -> Result<()> {
    let mut config = ManagerConfig::default("chrome", "chromedriver");
    
    // Enable offline mode
    config.offline = true;
    config.fallback_driver_from_cache = true;
    
    let mut manager = get_manager_by_browser("chrome".to_string())?;
    manager.set_config(config);
    
    // This will only use cached drivers/browsers
    match manager.setup() {
        Ok(driver_path) => {
            println!("Using cached driver at: {}", driver_path.display());
        }
        Err(e) => {
            println!("No cached driver available: {}", e);
        }
    }
    
    Ok(())
}

cache_path = "/custom/cache/path"
browser_version = "stable"
timeout = 600
offline = false
avoid_stats = true

[proxy]
url = "https://proxy.example.com:8080"

[mirrors]
driver_url = "https://custom-mirror.com/drivers/"
browser_url = "https://custom-mirror.com/browsers/"