1use log::error;
  2use starship_battery as battery;
  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) => match bat.cycle_count() {
 29                                Some(count) => BatteryResult {
 30                                    cycle_count: count,
 31                                    error: BatteryError::Success,
 32                                },
 33                                None => {
 34                                    error!("No cycle count available");
 35                                    BatteryResult {
 36                                        cycle_count: 0,
 37                                        error: BatteryError::NoCycleCount,
 38                                    }
 39                                }
 40                            },
 41                            Err(e) => {
 42                                error!("Battery error: {}", e);
 43                                BatteryResult {
 44                                    cycle_count: 0,
 45                                    error: BatteryError::NoBattery,
 46                                }
 47                            }
 48                        }
 49                    } else {
 50                        error!("No batteries found");
 51                        BatteryResult {
 52                            cycle_count: 0,
 53                            error: BatteryError::NoBattery,
 54                        }
 55                    }
 56                }
 57                Err(e) => {
 58                    error!("Failed to get batteries: {}", e);
 59                    BatteryResult {
 60                        cycle_count: 0,
 61                        error: BatteryError::ManagerError,
 62                    }
 63                }
 64            }
 65        }
 66        Err(e) => {
 67            error!("Failed to create battery manager: {}", e);
 68            BatteryResult {
 69                cycle_count: 0,
 70                error: BatteryError::ManagerError,
 71            }
 72        }
 73    }
 74}
 75
 76#[cfg(test)]
 77mod test {
 78    use super::*;
 79
 80    #[test]
 81    fn test_battery_cycle_count() {
 82        let result = battery_cycle_count();
 83
 84        match result.error {
 85            BatteryError::Success => {
 86                println!("Battery cycle count: {}", result.cycle_count);
 87                assert!(result.cycle_count >= 1);
 88            }
 89            BatteryError::NoBattery => {
 90                println!("No battery found");
 91                assert_eq!(result.cycle_count, 0);
 92            }
 93            BatteryError::NoCycleCount => {
 94                println!("No cycle count available");
 95                assert_eq!(result.cycle_count, 0);
 96            }
 97            BatteryError::ManagerError => {
 98                println!("Battery manager error");
 99                assert_eq!(result.cycle_count, 0);
100            }
101        }
102
103        assert!(matches!(
104            result.error,
105            BatteryError::Success
106                | BatteryError::NoBattery
107                | BatteryError::NoCycleCount
108                | BatteryError::ManagerError
109        ));
110    }
111}