1use battery;
  2use log::error;
  3
  4#[repr(C)]
  5#[derive(Debug)]
  6pub enum BatteryError {
  7    Success = 0,
  8    NoBattery = 1,
  9    NoCycleCount = 2,
 10    ManagerError = 3,
 11}
 12
 13#[repr(C)]
 14pub struct BatteryResult {
 15    pub cycle_count: u32,
 16    pub error: BatteryError,
 17}
 18
 19#[no_mangle]
 20pub extern "C" fn battery_cycle_count() -> BatteryResult {
 21    match battery::Manager::new() {
 22        Ok(manager) => {
 23            match manager.batteries() {
 24                Ok(batteries) => {
 25                    // Get the first battery if available
 26                    if let Some(battery) = batteries.into_iter().next() {
 27                        match battery {
 28                            Ok(bat) => {
 29                                match bat.cycle_count() {
 30                                    Some(count) => BatteryResult {
 31                                        cycle_count: count,
 32                                        error: BatteryError::Success,
 33                                    },
 34                                    None => {
 35                                        error!("No cycle count available");
 36                                        BatteryResult {
 37                                            cycle_count: 0,
 38                                            error: BatteryError::NoCycleCount,
 39                                        }
 40                                    }
 41                                }
 42                            }
 43                            Err(e) => {
 44                                error!("Battery error: {}", e);
 45                                BatteryResult {
 46                                    cycle_count: 0,
 47                                    error: BatteryError::NoBattery,
 48                                }
 49                            }
 50                        }
 51                    } else {
 52                        error!("No batteries found");
 53                        BatteryResult {
 54                            cycle_count: 0,
 55                            error: BatteryError::NoBattery,
 56                        }
 57                    }
 58                }
 59                Err(e) => {
 60                    error!("Failed to get batteries: {}", e);
 61                    BatteryResult {
 62                        cycle_count: 0,
 63                        error: BatteryError::ManagerError,
 64                    }
 65                }
 66            }
 67        }
 68        Err(e) => {
 69            error!("Failed to create battery manager: {}", e);
 70            BatteryResult {
 71                cycle_count: 0,
 72                error: BatteryError::ManagerError,
 73            }
 74        }
 75    }
 76}
 77
 78#[cfg(test)]
 79mod test {
 80    use super::*;
 81
 82    #[test]
 83    fn test_battery_cycle_count() {
 84        let result = battery_cycle_count();
 85
 86        match result.error {
 87            BatteryError::Success => {
 88                println!("Battery cycle count: {}", result.cycle_count);
 89                assert!(result.cycle_count >= 1);
 90            }
 91            BatteryError::NoBattery => {
 92                println!("No battery found");
 93                assert_eq!(result.cycle_count, 0);
 94            }
 95            BatteryError::NoCycleCount => {
 96                println!("No cycle count available");
 97                assert_eq!(result.cycle_count, 0);
 98            }
 99            BatteryError::ManagerError => {
100                println!("Battery manager error");
101                assert_eq!(result.cycle_count, 0);
102            }
103        }
104
105        assert!(matches!(
106            result.error,
107            BatteryError::Success
108                | BatteryError::NoBattery
109                | BatteryError::NoCycleCount
110                | BatteryError::ManagerError
111        ));
112    }
113}