lk-inside 0.3.1

use polars::prelude::{DataFrame, col, lit, IntoLazy};
use anyhow::{Result, anyhow};

pub fn apply_filter(df: &DataFrame, filter_expr: &str) -> Result<DataFrame> {
    let parts: Vec<&str> = filter_expr.split_whitespace().collect();

    if parts.len() == 3 {
        let column_name = parts[0];
        let operator = parts[1];
        let value_str = parts[2];

        // Attempt to parse as f64, otherwise treat as string
        let literal_value_expr = if let Ok(val) = value_str.parse::<f64>() {
            lit(val)
        } else {
            // If parsing as f64 fails, assume it's a string literal.
            // Remove quotes if present.
            let clean_value = value_str.trim_matches('"');
            lit(clean_value)
        };

        let filter_expression = match operator {
            "==" => col(column_name).eq(literal_value_expr),
            "!=" => col(column_name).neq(literal_value_expr),
            ">" => col(column_name).gt(literal_value_expr),
            ">=" => col(column_name).gt_eq(literal_value_expr),
            "<" => col(column_name).lt(literal_value_expr),
            "<=" => col(column_name).lt_eq(literal_value_expr),
            _ => return Err(anyhow!("Unsupported operator: {}", operator)),
        };

        df.clone().lazy()
            .filter(filter_expression)
            .collect()
            .map_err(|e| anyhow!("Failed to apply filter: {}", e))
    } else {
        Err(anyhow!("Invalid filter expression format. Expected 'column_name operator value'"))
    }
}