//! # Time Unit Conversion
//!
//! A unit of time is any particular time interval, used as a standard way of
//! measuring or expressing duration. The base unit of time in the International
//! System of Units (SI), and by extension most of the Western world, is the second,
//! defined as about 9 billion oscillations of the caesium atom.
//!
//! More information: <https://en.wikipedia.org/wiki/Unit_of_time>

/// Supported time units for conversion
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum TimeUnit {
    Seconds,
    Minutes,
    Hours,
    Days,
    Weeks,
    Months,
    Years,
}

impl TimeUnit {
    /// Returns the value of the time unit in seconds
    fn to_seconds(self) -> f64 {
        match self {
            TimeUnit::Seconds => 1.0,
            TimeUnit::Minutes => 60.0,
            TimeUnit::Hours => 3600.0,
            TimeUnit::Days => 86400.0,
            TimeUnit::Weeks => 604800.0,
            TimeUnit::Months => 2_629_800.0, // Approximate value
            TimeUnit::Years => 31_557_600.0, // Approximate value
        }
    }

    /// Parse a string into a TimeUnit (case-insensitive)
    fn from_str(s: &str) -> Result<Self, String> {
        match s.to_lowercase().as_str() {
            "seconds" => Ok(TimeUnit::Seconds),
            "minutes" => Ok(TimeUnit::Minutes),
            "hours" => Ok(TimeUnit::Hours),
            "days" => Ok(TimeUnit::Days),
            "weeks" => Ok(TimeUnit::Weeks),
            "months" => Ok(TimeUnit::Months),
            "years" => Ok(TimeUnit::Years),
            _ => Err(format!(
                "Invalid unit {s} is not in seconds, minutes, hours, days, weeks, months, years."
            )),
        }
    }
}

/// Convert time from one unit to another
///
/// # Arguments
///
/// * `time_value` - The time value to convert (must be non-negative)
/// * `unit_from` - The source unit (case-insensitive)
/// * `unit_to` - The target unit (case-insensitive)
///
/// # Returns
///
/// Returns the converted time value rounded to 3 decimal places
///
/// # Errors
///
/// Returns an error if:
/// * `time_value` is negative or not a valid number
/// * `unit_from` or `unit_to` is not a valid time unit
pub fn convert_time(time_value: f64, unit_from: &str, unit_to: &str) -> Result<f64, String> {
    // Validate that time_value is non-negative
    if time_value < 0.0 || time_value.is_nan() || time_value.is_infinite() {
        return Err("'time_value' must be a non-negative number.".to_string());
    }

    // Parse units
    let from_unit = TimeUnit::from_str(unit_from)?;
    let to_unit = TimeUnit::from_str(unit_to)?;

    // Convert: time_value -> seconds -> target unit
    let seconds = time_value * from_unit.to_seconds();
    let result = seconds / to_unit.to_seconds();

    // Round to 3 decimal places
    Ok((result * 1000.0).round() / 1000.0)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_seconds_to_hours() {
        assert_eq!(convert_time(3600.0, "seconds", "hours").unwrap(), 1.0);
    }

    #[test]
    fn test_case_insensitive() {
        assert_eq!(convert_time(3500.0, "Seconds", "Hours").unwrap(), 0.972);
        assert_eq!(convert_time(1.0, "DaYs", "hours").unwrap(), 24.0);
        assert_eq!(convert_time(120.0, "minutes", "SeCoNdS").unwrap(), 7200.0);
    }

    #[test]
    fn test_weeks_to_days() {
        assert_eq!(convert_time(2.0, "WEEKS", "days").unwrap(), 14.0);
    }

    #[test]
    fn test_hours_to_minutes() {
        assert_eq!(convert_time(0.5, "hours", "MINUTES").unwrap(), 30.0);
    }

    #[test]
    fn test_days_to_months() {
        assert_eq!(convert_time(360.0, "days", "months").unwrap(), 11.828);
    }

    #[test]
    fn test_months_to_years() {
        assert_eq!(convert_time(360.0, "months", "years").unwrap(), 30.0);
    }

    #[test]
    fn test_years_to_seconds() {
        assert_eq!(convert_time(1.0, "years", "seconds").unwrap(), 31_557_600.0);
    }

    #[test]
    fn test_negative_value() {
        let result = convert_time(-3600.0, "seconds", "hours");
        assert!(result.is_err());
        assert_eq!(
            result.unwrap_err(),
            "'time_value' must be a non-negative number."
        );
    }

    #[test]
    fn test_invalid_from_unit() {
        let result = convert_time(1.0, "cool", "century");
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("Invalid unit cool"));
    }

    #[test]
    fn test_invalid_to_unit() {
        let result = convert_time(1.0, "seconds", "hot");
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("Invalid unit hot"));
    }

    #[test]
    fn test_zero_value() {
        assert_eq!(convert_time(0.0, "hours", "minutes").unwrap(), 0.0);
    }

    #[test]
    fn test_same_unit() {
        assert_eq!(convert_time(100.0, "seconds", "seconds").unwrap(), 100.0);
    }
}