reputation-core 0.1.0

//! Example demonstrating utility methods for reputation analysis

use reputation_core::Calculator;
use reputation_types::AgentDataBuilder;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Reputation Score Utility Methods ===\n");
    
    let calc = Calculator::default();
    
    // Example 1: Confidence planning
    println!("1. Planning for Target Confidence:");
    println!("   Current interactions: 20");
    
    let targets = vec![0.5, 0.7, 0.9, 0.95];
    for target in targets {
        let needed = calc.interactions_for_confidence(20, target)?;
        println!("   - For {:.0}% confidence: need {} more interactions", 
                 target * 100.0, needed);
    }
    
    // Show confidence progression
    println!("\n   Confidence progression:");
    for additional in [0, 10, 30, 80, 180] {
        let conf = calc.confidence_after_interactions(20, additional);
        println!("   - After {} more: {:.1}% confidence", 
                 additional, conf * 100.0);
    }
    
    // Example 2: Score explanation
    println!("\n2. Detailed Score Explanation:");
    
    let agent = AgentDataBuilder::new("did:example:alice")
        .with_reviews(75, 4.2)
        .total_interactions(120)
        .mcp_level(2)
        .identity_verified(true)
        .security_audit_passed(true)
        .build()?;
    
    let explanation = calc.explain_score(&agent)?;
    println!("{}", explanation.explanation);
    
    // Example 3: Score predictions
    println!("\n3. Score Change Predictions:");
    
    let current_agent = AgentDataBuilder::new("did:example:bob")
        .with_reviews(50, 3.8)
        .total_interactions(60)
        .build()?;
    
    println!("   Current state: 50 reviews, 3.8 average rating");
    
    let scenarios = vec![
        (10, 5.0, "10 five-star reviews"),
        (20, 4.5, "20 reviews at 4.5 stars"),
        (10, 2.0, "10 two-star reviews"),
        (50, 4.0, "50 four-star reviews"),
    ];
    
    for (count, rating, desc) in scenarios {
        let prediction = calc.predict_score_change(&current_agent, count, rating)?;
        println!("\n   Scenario: {}", desc);
        println!("   - Current score: {:.1}", prediction.current_score);
        println!("   - Predicted score: {:.1}", prediction.predicted_score);
        println!("   - Change: {:+.1} points", prediction.score_change);
        println!("   - Confidence: {:.1}% → {:.1}% ({:+.1}%)", 
                 (prediction.confidence_change * 100.0 - prediction.confidence_change * 100.0) + (calc.calculate(&current_agent)?.confidence * 100.0),
                 (prediction.confidence_change * 100.0 + calc.calculate(&current_agent)?.confidence * 100.0),
                 prediction.confidence_change * 100.0);
    }
    
    // Example 4: Agent comparison
    println!("\n4. Comparing Two Agents:");
    
    let alice = AgentDataBuilder::new("did:example:alice")
        .with_reviews(200, 4.3)
        .total_interactions(250)
        .mcp_level(2)
        .identity_verified(true)
        .build()?;
    
    let charlie = AgentDataBuilder::new("did:example:charlie")
        .with_reviews(20, 4.8)
        .total_interactions(25)
        .mcp_level(1)
        .build()?;
    
    let comparison = calc.compare_agents(&alice, &charlie)?;
    
    println!("\n   Alice vs Charlie:");
    println!("   - Scores: {:.1} vs {:.1} (difference: {:+.1})",
             comparison.score_a, comparison.score_b, comparison.score_difference);
    println!("   - Confidence: {:.1}% vs {:.1}%",
             comparison.confidence_a * 100.0, comparison.confidence_b * 100.0);
    println!("   - Higher score: {}", 
             if comparison.higher_score_agent.contains("alice") { "Alice" } else { "Charlie" });
    println!("   - More reliable: {}",
             if comparison.more_reliable_agent.contains("alice") { "Alice" } else { "Charlie" });
    
    // Example 5: Working with low confidence scores
    println!("\n5. Understanding Provisional Scores:");
    
    let new_agent = AgentDataBuilder::new("did:example:newbie")
        .with_reviews(3, 4.7)
        .total_interactions(3)
        .build()?;
    
    let _explanation = calc.explain_score(&new_agent)?;
    let score = calc.calculate(&new_agent)?;
    
    println!("   New agent with only 3 reviews:");
    println!("   - Score: {:.1} ({})", 
             score.score,
             if score.is_provisional { "⚠️ Provisional" } else { "Established" });
    println!("   - Confidence: {:.1}% ({})", 
             score.confidence * 100.0,
             match score.level {
                 reputation_core::ConfidenceLevel::Low => "Low",
                 reputation_core::ConfidenceLevel::Medium => "Medium",
                 reputation_core::ConfidenceLevel::High => "High",
             });
    
    let needed = calc.interactions_for_confidence(3, 0.2)?;
    println!("   - Needs {} more interactions to exit provisional status", needed);
    
    // Example 6: Custom calculator configurations
    println!("\n6. Using Different Calculator Configurations:");
    
    let conservative_calc = Calculator::builder()
        .preset(reputation_core::CalculatorPreset::Conservative)
        .build()?;
    
    let test_agent = AgentDataBuilder::new("did:example:test")
        .with_reviews(30, 4.0)
        .total_interactions(40)
        .build()?;
    
    let default_score = calc.calculate(&test_agent)?;
    let conservative_score = conservative_calc.calculate(&test_agent)?;
    
    println!("   Same agent, different calculators:");
    println!("   - Default: score={:.1}, confidence={:.1}%",
             default_score.score, default_score.confidence * 100.0);
    println!("   - Conservative: score={:.1}, confidence={:.1}%",
             conservative_score.score, conservative_score.confidence * 100.0);
    
    println!("\n   Interactions needed for 80% confidence:");
    println!("   - Default: {} more", calc.interactions_for_confidence(40, 0.8)?);
    println!("   - Conservative: {} more", conservative_calc.interactions_for_confidence(40, 0.8)?);
    
    Ok(())
}