//! Validators for subscription tiers and payment-related fields.

use crate::constants;
use crate::error::AppError;
use super::limits;

/// Validate a subscription tier name
pub fn validate_tier_name(name: &str) -> Result<(), AppError> {
    if name.is_empty() {
        return Err(AppError::validation("Tier name is required".to_string()));
    }
    if name.chars().count() > limits::TIER_NAME_MAX {
        return Err(AppError::validation(format!(
            "Tier name must be {} characters or less",
            limits::TIER_NAME_MAX
        )));
    }
    Ok(())
}

/// Validate a subscription tier description
pub fn validate_tier_description(description: &str) -> Result<(), AppError> {
    if description.chars().count() > limits::TIER_DESCRIPTION_MAX {
        return Err(AppError::validation(format!(
            "Tier description must be {} characters or less",
            limits::TIER_DESCRIPTION_MAX
        )));
    }
    Ok(())
}

/// Validate a subscription tier price in cents (must be at least $1.00)
pub fn validate_tier_price(price_cents: i32) -> Result<(), AppError> {
    if price_cents < crate::constants::MIN_SUBSCRIPTION_PRICE_CENTS {
        return Err(AppError::validation(format!(
            "Subscription price must be at least ${:.2}",
            crate::constants::MIN_SUBSCRIPTION_PRICE_CENTS as f64 / 100.0
        )));
    }
    if price_cents > constants::MAX_PRICE_CENTS {
        return Err(AppError::validation("Subscription price cannot exceed $10,000".to_string()));
    }
    Ok(())
}

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

    #[test]
    fn test_validate_tier_name() {
        assert!(validate_tier_name("Basic Tier").is_ok());
        assert!(validate_tier_name("X").is_ok());
        assert!(validate_tier_name("").is_err()); // empty
        assert!(validate_tier_name(&"a".repeat(100)).is_ok()); // at limit
        assert!(validate_tier_name(&"a".repeat(101)).is_err()); // over limit
    }

    #[test]
    fn test_validate_tier_description() {
        assert!(validate_tier_description("Access to all content").is_ok());
        assert!(validate_tier_description("").is_ok()); // empty is valid
        assert!(validate_tier_description(&"a".repeat(2000)).is_ok()); // at limit
        assert!(validate_tier_description(&"a".repeat(2001)).is_err()); // over limit
    }

    #[test]
    fn test_validate_tier_price() {
        assert!(validate_tier_price(100).is_ok()); // $1.00 minimum
        assert!(validate_tier_price(999).is_ok());
        assert!(validate_tier_price(1_000_000).is_ok()); // $10,000
        assert!(validate_tier_price(99).is_err()); // below minimum
        assert!(validate_tier_price(0).is_err()); // zero
        assert!(validate_tier_price(-1).is_err()); // negative
        assert!(validate_tier_price(1_000_001).is_err()); // over cap
    }
}