rjango 0.1.1

use crate::core::validators::ValidationError;

use super::FieldType;

pub fn validate_boolean_field(_value: bool) -> Result<(), ValidationError> {
    Ok(())
}

pub fn parse_boolean_field(value: &str) -> Result<bool, ValidationError> {
    match value.trim().to_ascii_lowercase().as_str() {
        "1" | "true" | "t" | "yes" | "y" | "on" => Ok(true),
        "0" | "false" | "f" | "no" | "n" | "off" => Ok(false),
        _ => Err(
            ValidationError::new("Enter a valid boolean value.", "invalid")
                .with_param("value", value),
        ),
    }
}

#[must_use]
pub fn db_type(field: &FieldType, vendor: &str) -> Option<String> {
    match field {
        FieldType::Boolean | FieldType::NullBoolean => Some(match vendor {
            "postgres" => "boolean".to_string(),
            "sqlite" | "mysql" => "bool".to_string(),
            _ => "boolean".to_string(),
        }),
        _ => None,
    }
}

pub fn get_prep_value(value: &str) -> Result<String, ValidationError> {
    parse_boolean_field(value).map(|parsed| parsed.to_string())
}

pub fn from_db_value(value: &str) -> Result<bool, ValidationError> {
    parse_boolean_field(value)
}

#[must_use]
pub fn formfield(field: &FieldType) -> Option<&'static str> {
    match field {
        FieldType::Boolean => Some("BooleanField"),
        FieldType::NullBoolean => Some("NullBooleanField"),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::{FieldType, db_type, formfield, from_db_value, get_prep_value};

    #[test]
    fn db_type_for_postgres_uses_boolean() {
        assert_eq!(
            db_type(&FieldType::Boolean, "postgres").as_deref(),
            Some("boolean")
        );
    }

    #[test]
    fn get_prep_value_normalizes_truthy_input() {
        let prepared = get_prep_value("YES").expect("truthy input should normalize");
        assert_eq!(prepared, "true");
    }

    #[test]
    fn from_db_value_parses_database_flags() {
        let parsed = from_db_value("0").expect("database booleans should parse");
        assert!(!parsed);
    }

    #[test]
    fn formfield_returns_correct_type() {
        assert_eq!(formfield(&FieldType::NullBoolean), Some("NullBooleanField"));
    }
}