use consumer_choice_metamodel::*;

let agent_id = AgentId::new();
let attributes = BasicAgentAttributes::new(agent_id)
    .with_psychological_attribute("risk_aversion".to_string(), 0.7)
    .with_socioeconomic_attribute("income".to_string(), 75000.0);

let choice_module = SimpleChoiceModule::new();
let agent = ConsumerAgent::new(attributes, choice_module);

// Create environment with rules
let environment = Environment::new(interaction_rules);

// Create information processing
let mut transformer = Transformer::new(100.0);
transformer.add_filter(ReliabilityFilter::new(0.5));

// Create and configure model
let config = ModelConfiguration::new(
    "My Simulation".to_string(),
    "Consumer choice simulation".to_string()
);
let mut model = ConsumerChoiceModel::new(config, environment, transformer);

// Add agents and run
model.add_agent(agent)?;
model.run()?;

#[derive(Debug)]
struct MyChoiceModule {
    preferences: HashMap<String, f64>,
}

impl ChoiceModule for MyChoiceModule {
    type Choice = ProductChoice;
    type Context = MarketContext;
    
    fn make_choice(&self, choices: Vec<Self::Choice>, context: &Self::Context, trigger: TriggerType) -> Result<Option<Self::Choice>> {
        // Your custom decision logic here
        Ok(choices.into_iter().next())
    }
    
    // Implement other required methods...
}

#[derive(Debug)]
struct TopicFilter {
    allowed_topics: Vec<String>,
}

impl InformationFilter for TopicFilter {
    fn filter_information(&self, information: Vec<Information>, agent_id: &AgentId, context: &FilterContext) -> Result<Vec<Information>> {
        Ok(information.into_iter()
            .filter(|info| self.allowed_topics.iter().any(|topic| info.topic.contains(topic)))
            .collect())
    }
    
    // Implement other required methods...
}

#[cfg(feature = "async")]
{
    // Run async simulation
    model.run().await?;
    
    // Process agents concurrently
    for agent in agents {
        let choice = agent.process_trigger(trigger, choices, &context, time).await?;
    }
}

#[cfg(feature = "serde")]
{
    // Save model state
    let json = serde_json::to_string(&model.statistics())?;
    
    // Load agent attributes  
    let attributes: BasicAgentAttributes = serde_json::from_str(&data)?;
}