pub struct InputFilter {
    blocklist: Vec<String>,
    line_buffer: Vec<u8>,
}

#[derive(Debug, PartialEq)]
pub enum FilterResult {
    Allowed,
    Blocked(String),
}

impl InputFilter {
    pub fn new(blocklist: Vec<String>) -> Self {
        Self {
            blocklist,
            line_buffer: Vec::new(),
        }
    }

    /// Feed data through the filter, checking complete lines against blocklist.
    /// Returns results for any completed lines.
    pub fn feed(&mut self, data: &[u8]) -> Vec<FilterResult> {
        let mut results = Vec::new();
        for &byte in data {
            if byte == b'\r' || byte == b'\n' {
                if !self.line_buffer.is_empty() {
                    let line = String::from_utf8_lossy(&self.line_buffer).to_string();
                    results.push(self.check_line(&line));
                    self.line_buffer.clear();
                }
            } else {
                self.line_buffer.push(byte);
            }
        }
        results
    }

    pub fn check_line(&self, line: &str) -> FilterResult {
        for pattern in &self.blocklist {
            if line.contains(pattern.as_str()) {
                return FilterResult::Blocked(pattern.clone());
            }
        }
        FilterResult::Allowed
    }
}