PlantData

#[derive(Debug, Serialize, Deserialize)]
pub struct PlantData {
    #[serde(rename = "plantName")]
    pub plant_name: Option<String>,
    #[serde(rename = "plantId")]
    pub plant_id: Option<String>,
    #[serde(rename = "capacity")]
    pub capacity: Option<f64>,
    #[serde(rename = "todayEnergy")]
    pub today_energy: Option<f64>,
    #[serde(rename = "totalEnergy")]
    pub total_energy: Option<f64>,
    #[serde(rename = "currentPower")]
    pub current_power: Option<f64>,
}

use growatt::Growatt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = Growatt::new();
    client.login("username", "password").await?;
    
    let plant_id = "12345";
    
    // Get detailed plant data
    let plant_data = client.get_plant(plant_id).await?;
    
    // Access fields with safe unwrapping
    if let Some(name) = plant_data.plant_name {
        println!("Plant: {}", name);
    }
    
    if let Some(capacity) = plant_data.capacity {
        println!("Capacity: {} kW", capacity);
    }
    
    if let Some(today) = plant_data.today_energy {
        println!("Today's Energy: {} kWh", today);
    }
    
    if let Some(total) = plant_data.total_energy {
        println!("Total Energy: {} kWh", total);
    }
    
    if let Some(power) = plant_data.current_power {
        println!("Current Power: {} W", power);
    }
    
    Ok(())
}

// Using if let
if let Some(energy) = plant_data.today_energy {
    println!("Today: {} kWh", energy);
} else {
    println!("Today's energy data not available");
}

// Using unwrap_or for defaults
let current = plant_data.current_power.unwrap_or(0.0);

// Using map for transformations
let efficiency = plant_data.capacity
    .and_then(|cap| plant_data.current_power.map(|pow| (pow / (cap * 1000.0)) * 100.0));

if let Some(eff) = efficiency {
    println!("Current efficiency: {:.2}%", eff);
}

// Calculate capacity factor for today
if let (Some(today_energy), Some(capacity)) = 
    (plant_data.today_energy, plant_data.capacity) {
    let capacity_factor = (today_energy / (capacity * 24.0)) * 100.0;
    println!("Today's capacity factor: {:.2}%", capacity_factor);
}

// Check if plant is currently producing
if let Some(current_power) = plant_data.current_power {
    if current_power > 0.0 {
        println!("Plant is actively producing power");
    } else {
        println!("Plant is idle");
    }
}