Facade Pattern

// Complex subsystem components
pub struct DataLoader {
    source: String,
}
 
impl DataLoader {
    pub fn new(source: &str) -> Self {
        Self { source: source.to_string() }
    }
 
    pub fn load_data(&self) -> Vec<String> {
        println!("Loading data from {}", self.source);
        vec!["data1".to_string(), "data2".to_string()]
    }
}
 
pub struct DataProcessor {
    algorithm: String,
}
 
impl DataProcessor {
    pub fn new(algorithm: &str) -> Self {
        Self { algorithm: algorithm.to_string() }
    }
 
    pub fn process(&self, data: &[String]) -> Vec<String> {
        println!("Processing with {}", self.algorithm);
        data.iter().map(|d| format!("processed_{}", d)).collect()
    }
}
 
pub struct ModelTrainer {
    model_type: String,
}
 
impl ModelTrainer {
    pub fn new(model_type: &str) -> Self {
        Self { model_type: model_type.to_string() }
    }
 
    pub fn train(&self, data: &[String]) -> String {
        println!("Training {} model", self.model_type);
        format!("{}_model_trained", self.model_type)
    }
}
 
pub struct ResultExporter {
    format: String,
}
 
impl ResultExporter {
    pub fn new(format: &str) -> Self {
        Self { format: format.to_string() }
    }
 
    pub fn export(&self, model: &str, results: &[String]) -> String {
        println!("Exporting to {}", self.format);
        format!("exported_{}_{}", model, self.format)
    }
}
 
// Facade that simplifies the complex workflow
pub struct AIWorkflowFacade {
    loader: DataLoader,
    processor: DataProcessor,
    trainer: ModelTrainer,
    exporter: ResultExporter,
}
 
impl AIWorkflowFacade {
    pub fn new() -> Self {
        Self {
            loader: DataLoader::new("default_source"),
            processor: DataProcessor::new("neural_network"),
            trainer: ModelTrainer::new("classification"),
            exporter: ResultExporter::new("json"),
        }
    }
 
    pub fn run_complete_workflow(&self) -> String {
        // Orchestrate the complex workflow
        let data = self.loader.load_data();
        let processed_data = self.processor.process(&data);
        let model = self.trainer.train(&processed_data);
        self.exporter.export(&model, &processed_data)
    }
 
    pub fn run_data_analysis_only(&self) -> Vec<String> {
        let data = self.loader.load_data();
        self.processor.process(&data)
    }
 
    pub fn configure_source(&mut self, source: &str) {
        self.loader = DataLoader::new(source);
    }
}

// Simple usage through facade
let mut workflow = AIWorkflowFacade::new();
workflow.configure_source("customer_database");
 
// Run complete workflow with one call
let result = workflow.run_complete_workflow();
println!("Workflow result: {}", result);
 
// Or run partial workflow
let analysis = workflow.run_data_analysis_only();
println!("Analysis result: {:?}", analysis);