turbo-vision 1.1.0

// (C) 2025 - Enzo Lombardi

//! PictureValidator - validates and formats input using picture mask patterns.
// Picture Mask Validator (TPXPictureValidator)
//
// Validates and formats input according to a picture mask.
// Borland's TPXPictureValidator from validate.h and tvalidat.cc
//
// Mask Characters:
// - # : Digit (0-9)
// - @ : Alpha (A-Z, a-z)
// - ! : Any character
// - * : Optional character (makes following characters optional)
// - Literal characters : Must match exactly
//
// Examples:
// - "(###) ###-####" : Phone number (555) 123-4567
// - "##/##/####"     : Date 12/25/2023
// - "@@@@-####"      : Code ABCD-1234
// - "###*-####"      : Optional dash 123-4567 or 1234567
//
// Reference: Borland Turbo Vision tvalidat.cc, validate.h

use crate::views::validator::{Validator, ValidatorRef};
use std::cell::RefCell;
use std::rc::Rc;

/// Picture mask validator for formatted input
pub struct PictureValidator {
    /// Picture mask string
    mask: String,
    /// Whether to auto-format as user types
    auto_format: bool,
}

impl PictureValidator {
    /// Create a new picture validator with the given mask
    ///
    /// # Example
    /// ```
    /// use turbo_vision::views::picture_validator::PictureValidator;
    ///
    /// // Phone number mask
    /// let validator = PictureValidator::new("(###) ###-####");
    ///
    /// // Date mask
    /// let validator = PictureValidator::new("##/##/####");
    /// ```
    pub fn new(mask: &str) -> Self {
        PictureValidator {
            mask: mask.to_string(),
            auto_format: true,
        }
    }

    /// Create a new picture validator without auto-formatting
    pub fn new_no_format(mask: &str) -> Self {
        PictureValidator {
            mask: mask.to_string(),
            auto_format: false,
        }
    }

    /// Get the mask string
    pub fn mask(&self) -> &str {
        &self.mask
    }

    /// Set whether to auto-format input
    pub fn set_auto_format(&mut self, auto_format: bool) {
        self.auto_format = auto_format;
    }

    /// Check if a character is valid for the given mask position
    fn is_valid_char_for_mask(&self, ch: char, mask_ch: char) -> bool {
        match mask_ch {
            '#' => ch.is_ascii_digit(),
            '@' => ch.is_ascii_alphabetic(),
            '!' => true,
            '*' => true, // Optional marker - accept anything
            _ => ch == mask_ch, // Literal must match
        }
    }

    /// Format input according to the mask
    ///
    /// Returns the formatted string, filling in literal characters from the mask.
    pub fn format(&self, input: &str) -> String {
        let mut result = String::new();
        let mut input_chars = input.chars().filter(|&c| !c.is_whitespace());
        let mask_chars: Vec<char> = self.mask.chars().collect();
        let mut optional = false;

        for &mask_ch in &mask_chars {
            if mask_ch == '*' {
                optional = true;
                continue;
            }

            match mask_ch {
                '#' | '@' | '!' => {
                    // Field character - consume from input
                    if let Some(ch) = input_chars.next() {
                        if self.is_valid_char_for_mask(ch, mask_ch) {
                            result.push(ch);
                        } else if optional {
                            // Invalid in optional section - stop
                            break;
                        } else {
                            // Invalid character for required field
                            // Skip it and try next
                            continue;
                        }
                    } else if optional {
                        // No more input and we're in optional section - done
                        break;
                    } else {
                        // Required field but no more input - incomplete
                        break;
                    }
                }
                _ => {
                    // Literal character - add to result
                    result.push(mask_ch);
                }
            }
        }

        result
    }

    /// Check if input matches the mask completely
    fn matches_mask(&self, input: &str) -> bool {
        let mask_chars: Vec<char> = self.mask.chars().collect();
        let input_chars: Vec<char> = input.chars().collect();
        let mut mask_idx = 0;
        let mut input_idx = 0;
        let mut optional = false;

        while mask_idx < mask_chars.len() {
            let mask_ch = mask_chars[mask_idx];

            if mask_ch == '*' {
                optional = true;
                mask_idx += 1;
                continue;
            }

            match mask_ch {
                '#' | '@' | '!' => {
                    // Field character - must match input
                    if input_idx >= input_chars.len() {
                        return optional; // OK if optional section
                    }

                    let input_ch = input_chars[input_idx];
                    if !self.is_valid_char_for_mask(input_ch, mask_ch) {
                        return false;
                    }

                    input_idx += 1;
                }
                _ => {
                    // Literal character - must match exactly
                    if input_idx >= input_chars.len() {
                        return optional;
                    }

                    if input_chars[input_idx] != mask_ch {
                        return false;
                    }

                    input_idx += 1;
                }
            }

            mask_idx += 1;
        }

        // All input consumed?
        input_idx == input_chars.len()
    }
}

impl Validator for PictureValidator {
    fn is_valid(&self, input: &str) -> bool {
        if input.is_empty() {
            return true; // Empty is valid (might be required by parent)
        }

        self.matches_mask(input)
    }

    fn is_valid_input(&self, input: &str, _append: bool) -> bool {
        if input.is_empty() {
            return true;
        }

        // For auto-format mode, check if the formatted version is valid
        if self.auto_format {
            let formatted = self.format(input);
            return !formatted.is_empty();
        }

        // For non-auto-format, check if it's on track to match the mask
        let mask_chars: Vec<char> = self.mask.chars().collect();
        let input_chars: Vec<char> = input.chars().collect();
        let mut mask_idx = 0;
        let mut input_idx = 0;
        let mut _optional = false;

        while input_idx < input_chars.len() && mask_idx < mask_chars.len() {
            let mask_ch = mask_chars[mask_idx];

            if mask_ch == '*' {
                _optional = true;
                mask_idx += 1;
                continue;
            }

            match mask_ch {
                '#' | '@' | '!' => {
                    if !self.is_valid_char_for_mask(input_chars[input_idx], mask_ch) {
                        return false;
                    }
                    input_idx += 1;
                }
                _ => {
                    // Literal must match
                    if input_chars[input_idx] != mask_ch {
                        return false;
                    }
                    input_idx += 1;
                }
            }

            mask_idx += 1;
        }

        true // Partial input is valid
    }

    fn error(&self) {
        // In a full implementation, this would show a message box
        // For now, just a no-op (the InputLine will handle visual feedback)
    }

    fn valid(&self, input: &str) -> bool {
        if self.is_valid(input) {
            true
        } else {
            self.error();
            false
        }
    }
}

/// Helper function to create a ValidatorRef for a PictureValidator
pub fn picture_validator(mask: &str) -> ValidatorRef {
    Rc::new(RefCell::new(PictureValidator::new(mask)))
}

/// Builder for creating picture validators with a fluent API.
///
/// # Examples
///
/// ```ignore
/// use turbo_vision::views::picture_validator::PictureValidatorBuilder;
///
/// // Create a phone number validator with auto-formatting
/// let validator = PictureValidatorBuilder::new()
///     .mask("(###) ###-####")
///     .build();
///
/// // Create a date validator without auto-formatting
/// let validator = PictureValidatorBuilder::new()
///     .mask("##/##/####")
///     .auto_format(false)
///     .build();
/// ```
pub struct PictureValidatorBuilder {
    mask: Option<String>,
    auto_format: bool,
}

impl PictureValidatorBuilder {
    /// Creates a new PictureValidatorBuilder with default values.
    pub fn new() -> Self {
        Self {
            mask: None,
            auto_format: true,
        }
    }

    /// Sets the picture mask pattern (required).
    ///
    /// Mask characters:
    /// - `#` : Digit (0-9)
    /// - `@` : Alpha (A-Z, a-z)
    /// - `!` : Any character
    /// - `*` : Optional character marker
    /// - Other : Literal characters
    #[must_use]
    pub fn mask(mut self, mask: impl Into<String>) -> Self {
        self.mask = Some(mask.into());
        self
    }

    /// Sets whether to auto-format input (default: true).
    #[must_use]
    pub fn auto_format(mut self, auto_format: bool) -> Self {
        self.auto_format = auto_format;
        self
    }

    /// Builds the PictureValidator.
    ///
    /// # Panics
    ///
    /// Panics if required fields (mask) are not set.
    pub fn build(self) -> PictureValidator {
        let mask = self.mask.expect("PictureValidator mask must be set");

        PictureValidator {
            mask,
            auto_format: self.auto_format,
        }
    }

    /// Builds the PictureValidator as a ValidatorRef.
    pub fn build_ref(self) -> ValidatorRef {
        Rc::new(RefCell::new(self.build()))
    }
}

impl Default for PictureValidatorBuilder {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_phone_number_mask() {
        let validator = PictureValidator::new("(###) ###-####");

        // Valid complete input
        assert!(validator.is_valid("(555) 123-4567"));

        // Invalid - wrong format
        assert!(!validator.is_valid("555-123-4567"));
        assert!(!validator.is_valid("(abc) def-ghij"));
    }

    #[test]
    fn test_date_mask() {
        let validator = PictureValidator::new("##/##/####");

        // Valid dates
        assert!(validator.is_valid("12/25/2023"));
        assert!(validator.is_valid("01/01/2000"));

        // Invalid dates
        assert!(!validator.is_valid("12-25-2023")); // Wrong separator
        assert!(!validator.is_valid("1/1/2023"));   // Missing leading zeros
    }

    #[test]
    fn test_format_phone_number() {
        let validator = PictureValidator::new("(###) ###-####");

        // Format digits only
        assert_eq!(validator.format("5551234567"), "(555) 123-4567");
        assert_eq!(validator.format("555 123 4567"), "(555) 123-4567");
    }

    #[test]
    fn test_format_date() {
        let validator = PictureValidator::new("##/##/####");

        assert_eq!(validator.format("12252023"), "12/25/2023");
        assert_eq!(validator.format("01012000"), "01/01/2000");
    }

    #[test]
    fn test_alpha_mask() {
        let validator = PictureValidator::new("@@@@-####");

        assert!(validator.is_valid("ABCD-1234"));
        assert!(!validator.is_valid("1234-ABCD")); // Wrong order
    }

    #[test]
    fn test_optional_section() {
        let validator = PictureValidator::new("###*-####");

        // With optional dash
        assert!(validator.is_valid("123-4567"));
        // Without optional dash (not fully supported yet)
        // This test shows the current limitation
    }

    #[test]
    fn test_any_character_mask() {
        let validator = PictureValidator::new("!!!-!!!!");

        assert!(validator.is_valid("abc-123d"));
        assert!(validator.is_valid("XYZ-ABCD"));
    }

    #[test]
    fn test_partial_input_validation() {
        let validator = PictureValidator::new("(###) ###-####");

        // Partial inputs should be valid during typing
        assert!(validator.is_valid_input("(5", false));
        assert!(validator.is_valid_input("(55", false));
        assert!(validator.is_valid_input("(555", false));
        assert!(validator.is_valid_input("(555) ", false));
        assert!(validator.is_valid_input("(555) 1", false));
    }

    #[test]
    fn test_empty_input() {
        let validator = PictureValidator::new("##/##/####");
        assert!(validator.is_valid("")); // Empty is valid
    }

    #[test]
    fn test_validator_trait() {
        let validator = PictureValidator::new("(###) ###-####");
        assert!(validator.valid("(555) 123-4567"));
        assert!(!validator.valid("invalid"));
    }

    #[test]
    fn test_picture_validator_builder() {
        let validator = PictureValidatorBuilder::new()
            .mask("##/##/####")
            .build();

        assert!(validator.is_valid("12/25/2023"));
        assert_eq!(validator.mask(), "##/##/####");
    }

    #[test]
    fn test_picture_validator_builder_no_format() {
        let validator = PictureValidatorBuilder::new()
            .mask("(###) ###-####")
            .auto_format(false)
            .build();

        assert!(validator.is_valid("(555) 123-4567"));
    }
}