hawk_data/

filter.rs

use serde_json::Value;

use crate::{Error, apply_stats_operation, print_data_info, string_ops, value_to_string};

pub fn apply_simple_filter(data: Vec<Value>, filter: &str) -> Result<Vec<Value>, Error> {
    if filter.starts_with("select(") && filter.ends_with(")") {
        // "select(.age > 30)" から ".age > 30" を抽出
        let condition = &filter[7..filter.len() - 1];

        // パイプラインがある場合の処理
        if condition.contains(" | ") {
            apply_filter_with_string_operations(data, condition)
        } else {
            apply_existing_simple_filter(data, condition)
        }
    } else {
        Err(Error::InvalidQuery(format!(
            "Unsupported filter: {}",
            filter
        )))
    }
}

/// 文字列操作付きフィルタの適用
fn apply_filter_with_string_operations(
    data: Vec<Value>,
    condition: &str,
) -> Result<Vec<Value>, Error> {
    // not演算子のチェック
    let (condition, is_negated) = parse_not_condition_with_parentheses(condition)?;

    let parts: Vec<&str> = condition.split(" | ").map(|s| s.trim()).collect();

    if parts.len() < 2 {
        return Err(Error::InvalidQuery("Invalid filter condition".to_string()));
    }

    let field_access = parts[0];
    let string_operations: Vec<&str> = parts[1..].to_vec();

    // 最後の操作は比較操作である必要がある
    let last_operation = string_operations
        .last()
        .ok_or_else(|| Error::InvalidQuery("Missing comparison operation".to_string()))?;

    if !is_comparison_operation(last_operation) {
        return Err(Error::InvalidQuery(
            "Last operation must be a comparison".to_string(),
        ));
    }

    let mut results = Vec::new();

    for item in data {
        // フィールド値を取得
        let field_value = extract_field_value(&item, field_access)?;

        // 文字列操作を適用（比較操作まで）
        let final_value = string_ops::apply_string_pipeline(&field_value, &string_operations)?;

        // 比較結果を評価し、not演算子を適用
        let condition_result = matches!(final_value, Value::Bool(true));
        let final_result = if is_negated {
            !condition_result
        } else {
            condition_result
        };

        if final_result {
            results.push(item);
        }
    }

    Ok(results)
}

/// 比較操作かどうかを判定
fn is_comparison_operation(operation: &str) -> bool {
    let trimmed = operation.trim();

    trimmed.starts_with("contains(")
        || trimmed.starts_with("starts_with(")
        || trimmed.starts_with("ends_with(")
        || trimmed == "=="
        || trimmed == "!="
        || trimmed.starts_with("== ")
        || trimmed.starts_with("!= ")
}

/// 既存のシンプルフィルタ処理
fn apply_existing_simple_filter(data: Vec<Value>, condition: &str) -> Result<Vec<Value>, Error> {
    // not演算子のチェック
    let (condition, is_negated) = parse_not_condition_with_parentheses(condition)?;

    // 条件をパース
    let (field_path, operator, value) = parse_condition(&condition)?;

    // フィルタリングを実行
    let filtered: Vec<Value> = data
        .into_iter()
        .filter(|item| {
            let result = evaluate_condition(item, &field_path, &operator, &value);
            if is_negated { !result } else { result }
        })
        .collect();

    Ok(filtered)
}

fn parse_not_condition_with_parentheses(condition: &str) -> Result<(String, bool), Error> {
    let trimmed = condition.trim();

    if trimmed.starts_with("not ") {
        let rest = trimmed[4..].trim();

        // 括弧で囲まれているかチェック
        if rest.starts_with('(') && rest.ends_with(')') {
            let inner_condition = rest[1..rest.len() - 1].trim().to_string();
            Ok((inner_condition, true))
        } else {
            Err(Error::InvalidQuery(
                "not operator requires parentheses around condition: not (.condition)".to_string(),
            ))
        }
    } else {
        Ok((trimmed.to_string(), false))
    }
}

fn parse_multi_field_spec(field_spec: &str) -> Vec<String> {
    if field_spec.contains(',') {
        // カンマ区切りの複数フィールド
        field_spec
            .split(',')
            .map(|s| {
                let trimmed = s.trim();
                if trimmed == "." {
                    ".".to_string()
                } else {
                    trimmed.trim_start_matches('.').to_string()
                }
            })
            .collect()
    } else {
        // 単一フィールド（従来の動作）
        let field_name = if field_spec == "." {
            ".".to_string()
        } else {
            field_spec.trim_start_matches('.').to_string()
        };
        vec![field_name]
    }
}

/// 複数フィールド対応の集約関数（非グループ化データ用）
fn apply_multi_field_aggregation(
    data: Vec<Value>,
    operation: &str,
    field_spec: &str,
) -> Result<Vec<Value>, Error> {
    let field_names = parse_multi_field_spec(field_spec);
    
    if field_names.len() == 1 {
        // 単一フィールドの場合は従来の実装を使用
        apply_single_field_aggregation(data, operation, &field_names[0])
    } else {
        // 複数フィールドの場合
        let mut result_obj = serde_json::Map::new();
        
        for field_name in field_names {
            let field_result = apply_single_field_aggregation(data.clone(), operation, &field_name)?;
            let field_key = if field_name == "." {
                format!("{}_root", operation)
            } else {
                format!("{}_{}", operation, field_name)
            };
            
            if let Some(value) = field_result.first() {
                result_obj.insert(field_key, value.clone());
            }
        }
        
        Ok(vec![Value::Object(result_obj)])
    }
}

/// 単一フィールドの集約処理（従来の実装）
fn apply_single_field_aggregation(
    data: Vec<Value>,
    operation: &str,
    field_name: &str,
) -> Result<Vec<Value>, Error> {
    match operation {
        "sum" => {
            let sum: f64 = if field_name == "." {
                data.iter().filter_map(|val| val.as_f64()).sum()
            } else {
                data.iter()
                    .filter_map(|item| item.get(field_name))
                    .filter_map(|val| val.as_f64())
                    .sum()
            };
            
            let round_sum = if sum.fract() == 0.0 { sum } else { (sum * 10.0).round() / 10.0 };
            Ok(vec![Value::Number(serde_json::Number::from_f64(round_sum).unwrap())])
        }
        "avg" => {
            let values: Vec<f64> = if field_name == "." {
                data.iter().filter_map(|val| val.as_f64()).collect()
            } else {
                data.iter()
                    .filter_map(|item| item.get(field_name))
                    .filter_map(|val| val.as_f64())
                    .collect()
            };
            
            if values.is_empty() {
                Ok(vec![Value::Null])
            } else {
                let avg = values.iter().sum::<f64>() / values.len() as f64;
                let round_avg = (avg * 10.0).round() / 10.0;
                Ok(vec![Value::Number(serde_json::Number::from_f64(round_avg).unwrap())])
            }
        }
        "min" => {
            let min_val = if field_name == "." {
                data.iter()
                    .filter_map(|val| val.as_f64())
                    .fold(f64::INFINITY, f64::min)
            } else {
                data.iter()
                    .filter_map(|item| item.get(field_name))
                    .filter_map(|val| val.as_f64())
                    .fold(f64::INFINITY, f64::min)
            };
            
            if min_val == f64::INFINITY {
                Ok(vec![Value::Null])
            } else {
                Ok(vec![Value::Number(serde_json::Number::from_f64(min_val).unwrap())])
            }
        }
        "max" => {
            let max_val = if field_name == "." {
                data.iter()
                    .filter_map(|val| val.as_f64())
                    .fold(f64::NEG_INFINITY, f64::max)
            } else {
                data.iter()
                    .filter_map(|item| item.get(field_name))
                    .filter_map(|val| val.as_f64())
                    .fold(f64::NEG_INFINITY, f64::max)
            };
            
            if max_val == f64::NEG_INFINITY {
                Ok(vec![Value::Null])
            } else {
                Ok(vec![Value::Number(serde_json::Number::from_f64(max_val).unwrap())])
            }
        }
        _ => Err(Error::InvalidQuery(format!("Unsupported operation: {}", operation))),
    }
}

/// 複数フィールド対応の集約関数（グループ化データ用）
fn apply_multi_field_aggregation_to_groups(
    data: Vec<Value>,
    operation: &str,
    field_spec: &str,
) -> Result<Vec<Value>, Error> {
    let field_names = parse_multi_field_spec(field_spec);
    let mut results = Vec::new();

    for group_data in data {
        if let Value::Object(group_obj) = group_data {
            let group_name = group_obj.get("group").unwrap();
            let items = group_obj.get("items").and_then(|v| v.as_array()).unwrap();

            if field_names.len() == 1 {
                // 単一フィールドの場合（従来の動作）
                let aggregated_value = apply_single_field_aggregation_to_group(items, operation, &field_names[0])?;
                
                let mut result_obj = serde_json::Map::new();
                result_obj.insert("group".to_string(), group_name.clone());
                result_obj.insert(operation.to_string(), aggregated_value);
                results.push(Value::Object(result_obj));
            } else {
                // 複数フィールドの場合
                let mut result_obj = serde_json::Map::new();
                result_obj.insert("group".to_string(), group_name.clone());
                
                for field_name in &field_names {
                    let aggregated_value = apply_single_field_aggregation_to_group(items, operation, field_name)?;
                    let field_key = if field_name == "." {
                        format!("{}_root", operation)
                    } else {
                        format!("{}_{}", operation, field_name)
                    };
                    result_obj.insert(field_key, aggregated_value);
                }
                
                results.push(Value::Object(result_obj));
            }
        }
    }

    Ok(results)
}

/// 単一フィールドのグループ集約処理
fn apply_single_field_aggregation_to_group(
    items: &[Value],
    operation: &str,
    field_name: &str,
) -> Result<Value, Error> {
    match operation {
        "sum" => calculate_sum(items, field_name),
        "avg" => calculate_avg(items, field_name),
        "min" => calculate_min(items, field_name),
        "max" => calculate_max(items, field_name),
        _ => Ok(Value::Null),
    }
}

pub fn apply_pipeline_operation(data: Vec<Value>, operation: &str) -> Result<Vec<Value>, Error> {
    let trimmed_op = operation.trim();

    if operation.starts_with(".[") && operation.ends_with("]") {
        return apply_universal_slice_operation(data, operation);
    }

    if trimmed_op.starts_with("select(") && trimmed_op.ends_with(")") {
        // フィルタリング操作
        apply_simple_filter(data, trimmed_op)
    } else if trimmed_op == "count" {
        // カウント操作
        if is_grouped_data(&data) {
            apply_aggregation_to_groups(data, "count", "")
        } else {
            let count = data.len();
            let count_value = Value::Number(serde_json::Number::from(count));
            Ok(vec![count_value])
        }
    } else if trimmed_op.starts_with("map(") && trimmed_op.ends_with(")") {
        apply_map_operation(data, trimmed_op)
    } else if trimmed_op.starts_with("select_fields(") && trimmed_op.ends_with(")") {
        // 複数フィールド選択
        let fields_str = &trimmed_op[14..trimmed_op.len() - 1]; // "name,age,department"
        let field_list: Vec<String> = fields_str
            .split(',')
            .map(|s| s.trim().to_string())
            .collect();

        apply_field_selection(data, field_list)
    } else if trimmed_op == "info" {
        // info操作
        print_data_info(&data);
        Ok(vec![]) // Return empty vector
    } else if trimmed_op.starts_with("sum(") && trimmed_op.ends_with(")") {
        let field_spec = &trimmed_op[4..trimmed_op.len() - 1];
        
        if is_grouped_data(&data) {
            apply_multi_field_aggregation_to_groups(data, "sum", field_spec)
        } else {
            apply_multi_field_aggregation(data, "sum", field_spec)
        }
    } else if trimmed_op.starts_with("avg(") && trimmed_op.ends_with(")") {
        let field_spec = &trimmed_op[4..trimmed_op.len() - 1];
        
        if is_grouped_data(&data) {
            apply_multi_field_aggregation_to_groups(data, "avg", field_spec)
        } else {
            apply_multi_field_aggregation(data, "avg", field_spec)
        }
    } else if trimmed_op.starts_with("min(") && trimmed_op.ends_with(")") {
        let field_spec = &trimmed_op[4..trimmed_op.len() - 1];
        
        if is_grouped_data(&data) {
            apply_multi_field_aggregation_to_groups(data, "min", field_spec)
        } else {
            apply_multi_field_aggregation(data, "min", field_spec)
        }
    } else if trimmed_op.starts_with("max(") && trimmed_op.ends_with(")") {
        let field_spec = &trimmed_op[4..trimmed_op.len() - 1];
        
        if is_grouped_data(&data) {
            apply_multi_field_aggregation_to_groups(data, "max", field_spec)
        } else {
            apply_multi_field_aggregation(data, "max", field_spec)
        }
    } else if trimmed_op.starts_with("group_by(") && trimmed_op.ends_with(")") {
        // group_by(.department) の処理
        let field = &trimmed_op[9..trimmed_op.len() - 1];
        let field_name = if field == "." {
            "."  // ルート要素の場合はそのまま
        } else {
            field.trim_start_matches('.')  // .を除去
        };

        let grouped = group_data_by_field(data, field_name)?;
        Ok(grouped)
    } else if trimmed_op == "unique" {
        // unique操作（重複除去）
        let result = apply_stats_operation(&data, "unique", None)?;
        if let Value::Array(arr) = result {
            Ok(arr)
        } else {
            Ok(vec![result])
        }
    } else if trimmed_op == "sort" {
        // sort操作
        let result = apply_stats_operation(&data, "sort", None)?;
        if let Value::Array(arr) = result {
            Ok(arr)
        } else {
            Ok(vec![result])
        }
    } else if trimmed_op == "length" {
        // length操作（配列の長さ）
        let result = apply_stats_operation(&data, "length", None)?;
        Ok(vec![result])
    } else if trimmed_op == "median" {
        // median操作（中央値）
        let result = apply_stats_operation(&data, "median", None)?;
        Ok(vec![result])
    } else if trimmed_op == "stddev" {
        // stddev操作（標準偏差）
        let result = apply_stats_operation(&data, "stddev", None)?;
        Ok(vec![result])
    } else if trimmed_op.starts_with("unique(") && trimmed_op.ends_with(")") {
        // unique(.field) - フィールド指定
        let field = &trimmed_op[7..trimmed_op.len() - 1];
        let field_name = field.trim_start_matches('.');
        let result = apply_stats_operation(&data, "unique", Some(field_name))?;
        if let Value::Array(arr) = result {
            Ok(arr)
        } else {
            Ok(vec![result])
        }
    } else if trimmed_op.starts_with("sort(") && trimmed_op.ends_with(")") {
        // sort(.field) - フィールド指定
        let content = &trimmed_op[5..trimmed_op.len() - 1];
        apply_sort_operation(data, content)
    } else if trimmed_op.starts_with("median(") && trimmed_op.ends_with(")") {
        // median(.field) - フィールド指定
        let field = &trimmed_op[7..trimmed_op.len() - 1];
        let field_name = field.trim_start_matches('.');
        let result = apply_stats_operation(&data, "median", Some(field_name))?;
        Ok(vec![result])
    } else if trimmed_op.starts_with("stddev(") && trimmed_op.ends_with(")") {
        // stddev(.field) - フィールド指定
        let field = &trimmed_op[7..trimmed_op.len() - 1];
        let field_name = field.trim_start_matches('.');
        let result = apply_stats_operation(&data, "stddev", Some(field_name))?;
        Ok(vec![result])
    } else {
        // より詳細なエラーメッセージ
        Err(Error::InvalidQuery(format!(
            "Unsupported operation: '{}' (length: {}, starts with 'map(': {}, ends with ')': {})",
            trimmed_op,
            trimmed_op.len(),
            trimmed_op.starts_with("map("),
            trimmed_op.ends_with(")")
        )))
    }
}

// pub fn apply_pipeline_operation(data: Vec<Value>, operation: &str) -> Result<Vec<Value>, Error> {
//     let trimmed_op = operation.trim();
// 
//     if operation.starts_with(".[") && operation.ends_with("]") {
//         return apply_universal_slice_operation(data, operation);
//     }
// 
// 
//     if trimmed_op.starts_with("select(") && trimmed_op.ends_with(")") {
//         // フィルタリング操作
//         apply_simple_filter(data, trimmed_op)
//     } else if trimmed_op == "count" {
//         // カウント操作
//         if is_grouped_data(&data) {
//             apply_aggregation_to_groups(data, "count", "")
//         } else {
//             let count = data.len();
//             let count_value = Value::Number(serde_json::Number::from(count));
//             Ok(vec![count_value])
//         }
//     } else if trimmed_op.starts_with("map(") && trimmed_op.ends_with(")") {
//         apply_map_operation(data, trimmed_op)
//     } else if trimmed_op.starts_with("select_fields(") && trimmed_op.ends_with(")") {
//         // 複数フィールド選択
//         let fields_str = &trimmed_op[14..trimmed_op.len() - 1]; // "name,age,department"
//         let field_list: Vec<String> = fields_str
//             .split(',')
//             .map(|s| s.trim().to_string())
//             .collect();
// 
//         apply_field_selection(data, field_list)
//     } else if trimmed_op == "info" {
//         // info操作
//         print_data_info(&data);
//         Ok(vec![]) // Return empty vector
//     } else if trimmed_op.starts_with("sum(") && trimmed_op.ends_with(")") {
//         let field = &trimmed_op[4..trimmed_op.len() - 1];
//         let field_name = if field == "." {
//             "."  // ルート要素
//         } else {
//             field.trim_start_matches('.')
//         };
// 
//         if is_grouped_data(&data) {
//             apply_aggregation_to_groups(data, "sum", field_name)
//         } else {
//             let sum: f64 = if field_name == "." {
//                 // ルート要素の場合：各値を数値として扱う
//                 data.iter()
//                     .filter_map(|val| val.as_f64())
//                     .sum()
//             } else {
//                 // フィールド指定の場合：既存の実装
//                 data.iter()
//                     .filter_map(|item| item.get(field_name))
//                     .filter_map(|val| val.as_f64())
//                     .sum()
//             };
// 
//             let round_sum = if sum.fract() == 0.0 {
//                 sum
//             } else {
//                 (sum * 10.0).round() / 10.0
//             };
//             let sum_value = Value::Number(serde_json::Number::from_f64(round_sum).unwrap());
//             Ok(vec![sum_value])
//         }
//     } else if trimmed_op.starts_with("avg(") && trimmed_op.ends_with(")") {
//         // avg(.field) または avg(.) の処理
//         let field = &trimmed_op[4..trimmed_op.len() - 1];
//         let field_name = if field == "." {
//             "."
//         } else {
//             field.trim_start_matches('.')
//         };
// 
//         if is_grouped_data(&data) {
//             apply_aggregation_to_groups(data, "avg", field_name)
//         } else {
//             let values: Vec<f64> = if field_name == "." {
//                 // ルート要素の場合：各値を数値として扱う
//                 data.iter()
//                     .filter_map(|val| val.as_f64())
//                     .collect()
//             } else {
//                 // フィールド指定の場合：既存の実装
//                 data.iter()
//                     .filter_map(|item| item.get(field_name))
//                     .filter_map(|val| val.as_f64())
//                     .collect()
//             };
// 
//             if values.is_empty() {
//                 Ok(vec![Value::Null])
//             } else {
//                 let avg = values.iter().sum::<f64>() / values.len() as f64;
//                 let round_avg = (avg * 10.0).round() / 10.0;
//                 let avg_value = Value::Number(serde_json::Number::from_f64(round_avg).unwrap());
//                 Ok(vec![avg_value])
//             }
//         }
//     } else if trimmed_op.starts_with("min(") && trimmed_op.ends_with(")") {
//         // min(.field) または min(.) の処理
//         let field = &trimmed_op[4..trimmed_op.len() - 1];
//         let field_name = if field == "." {
//             "."
//         } else {
//             field.trim_start_matches('.')
//         };
// 
//         if is_grouped_data(&data) {
//             apply_aggregation_to_groups(data, "min", field_name)
//         } else {
//             let min_val = if field_name == "." {
//                 // ルート要素の場合：各値を数値として扱う
//                 data.iter()
//                     .filter_map(|val| val.as_f64())
//                     .fold(f64::INFINITY, f64::min)
//             } else {
//                 // フィールド指定の場合：既存の実装
//                 data.iter()
//                     .filter_map(|item| item.get(field_name))
//                     .filter_map(|val| val.as_f64())
//                     .fold(f64::INFINITY, f64::min)
//             };
// 
//             if min_val == f64::INFINITY {
//                 Ok(vec![Value::Null])
//             } else {
//                 let min_value = Value::Number(serde_json::Number::from_f64(min_val).unwrap());
//                 Ok(vec![min_value])
//             }
//         }
//     } else if trimmed_op.starts_with("max(") && trimmed_op.ends_with(")") {
//         // max(.field) または max(.) の処理
//         let field = &trimmed_op[4..trimmed_op.len() - 1];
//         let field_name = if field == "." {
//             "."
//         } else {
//             field.trim_start_matches('.')
//         };
// 
//         if is_grouped_data(&data) {
//             apply_aggregation_to_groups(data, "max", field_name)
//         } else {
//             let max_val = if field_name == "." {
//                 // ルート要素の場合：各値を数値として扱う
//                 data.iter()
//                     .filter_map(|val| val.as_f64())
//                     .fold(f64::NEG_INFINITY, f64::max)
//             } else {
//                 // フィールド指定の場合：既存の実装
//                 data.iter()
//                     .filter_map(|item| item.get(field_name))
//                     .filter_map(|val| val.as_f64())
//                     .fold(f64::NEG_INFINITY, f64::max)
//             };
// 
//             if max_val == f64::NEG_INFINITY {
//                 Ok(vec![Value::Null])
//             } else {
//                 let max_value = Value::Number(serde_json::Number::from_f64(max_val).unwrap());
//                 Ok(vec![max_value])
//             }
//         }
//     } else if trimmed_op.starts_with("group_by(") && trimmed_op.ends_with(")") {
//         // group_by(.department) の処理
//         let field = &trimmed_op[9..trimmed_op.len() - 1];
//         let field_name = if field == "." {
//             "."  // ルート要素の場合はそのまま
//         } else {
//             field.trim_start_matches('.')  // .を除去
//         };
// 
//         let grouped = group_data_by_field(data, field_name)?;
//         Ok(grouped)
//     } else if trimmed_op == "unique" {
//         // unique操作（重複除去）
//         let result = apply_stats_operation(&data, "unique", None)?;
//         if let Value::Array(arr) = result {
//             Ok(arr)
//         } else {
//             Ok(vec![result])
//         }
//     } else if trimmed_op == "sort" {
//         // sort操作
//         let result = apply_stats_operation(&data, "sort", None)?;
//         if let Value::Array(arr) = result {
//             Ok(arr)
//         } else {
//             Ok(vec![result])
//         }
//     } else if trimmed_op == "length" {
//         // length操作（配列の長さ）
//         let result = apply_stats_operation(&data, "length", None)?;
//         Ok(vec![result])
//     } else if trimmed_op == "median" {
//         // median操作（中央値）
//         let result = apply_stats_operation(&data, "median", None)?;
//         Ok(vec![result])
//     } else if trimmed_op == "stddev" {
//         // stddev操作（標準偏差）
//         let result = apply_stats_operation(&data, "stddev", None)?;
//         Ok(vec![result])
//     } else if trimmed_op.starts_with("unique(") && trimmed_op.ends_with(")") {
//         // unique(.field) - フィールド指定
//         let field = &trimmed_op[7..trimmed_op.len() - 1];
//         let field_name = field.trim_start_matches('.');
//         let result = apply_stats_operation(&data, "unique", Some(field_name))?;
//         if let Value::Array(arr) = result {
//             Ok(arr)
//         } else {
//             Ok(vec![result])
//         }
//     } else if trimmed_op.starts_with("sort(") && trimmed_op.ends_with(")") {
//         // sort(.field) - フィールド指定
//         let field = &trimmed_op[5..trimmed_op.len() - 1];
//         let field_name = field.trim_start_matches('.');
//         let result = apply_stats_operation(&data, "sort", Some(field_name))?;
//         if let Value::Array(arr) = result {
//             Ok(arr)
//         } else {
//             Ok(vec![result])
//         }
//     } else if trimmed_op.starts_with("median(") && trimmed_op.ends_with(")") {
//         // median(.field) - フィールド指定
//         let field = &trimmed_op[7..trimmed_op.len() - 1];
//         let field_name = field.trim_start_matches('.');
//         let result = apply_stats_operation(&data, "median", Some(field_name))?;
//         Ok(vec![result])
//     } else if trimmed_op.starts_with("stddev(") && trimmed_op.ends_with(")") {
//         // stddev(.field) - フィールド指定
//         let field = &trimmed_op[7..trimmed_op.len() - 1];
//         let field_name = field.trim_start_matches('.');
//         let result = apply_stats_operation(&data, "stddev", Some(field_name))?;
//         Ok(vec![result])
//     } else {
//         // より詳細なエラーメッセージ
//         Err(Error::InvalidQuery(format!(
//             "Unsupported operation: '{}' (length: {}, starts with 'map(': {}, ends with ')': {})",
//             trimmed_op,
//             trimmed_op.len(),
//             trimmed_op.starts_with("map("),
//             trimmed_op.ends_with(")")
//         )))
//     }
// }
//

/// ソート操作を処理（昇順・降順対応、グループ化データ対応）
fn apply_sort_operation(data: Vec<Value>, sort_spec: &str) -> Result<Vec<Value>, Error> {
    // グループ化データかどうかをチェック
    if is_grouped_data(&data) {
        apply_sort_to_grouped_data(data, sort_spec)
    } else {
        apply_sort_to_regular_data(data, sort_spec)
    }
}

/// 通常データのソート処理
fn apply_sort_to_regular_data(data: Vec<Value>, sort_spec: &str) -> Result<Vec<Value>, Error> {
    let (field_name, is_descending) = parse_sort_spec(sort_spec)?;
    
    if field_name.is_empty() {
        // フィールド指定なし：値そのものでソート
        let mut sorted_data = data;
        sorted_data.sort_by(|a, b| {
            let comparison = compare_sort_values(a, b);
            if is_descending {
                comparison.reverse()
            } else {
                comparison
            }
        });
        Ok(sorted_data)
    } else {
        // フィールド指定あり：指定フィールドでソート
        let mut sorted_data = data;
        sorted_data.sort_by(|a, b| {
            let value_a = extract_sort_key(a, &format!(".{}", field_name));
            let value_b = extract_sort_key(b, &format!(".{}", field_name));
            let comparison = compare_sort_values(&value_a, &value_b);
            if is_descending {
                comparison.reverse()
            } else {
                comparison
            }
        });
        Ok(sorted_data)
    }
}

/// グループ化データのソート処理
fn apply_sort_to_grouped_data(data: Vec<Value>, sort_spec: &str) -> Result<Vec<Value>, Error> {
    let (field_name, is_descending) = parse_sort_spec(sort_spec)?;
    
    let mut sorted_data = data;
    
    if field_name.is_empty() {
        // フィールド指定なし：グループ名でソート
        sorted_data.sort_by(|a, b| {
            let group_a = a.get("group").unwrap_or(&Value::Null);
            let group_b = b.get("group").unwrap_or(&Value::Null);
            let comparison = compare_sort_values(group_a, group_b);
            if is_descending {
                comparison.reverse()
            } else {
                comparison
            }
        });
    } else {
        // フィールド指定あり：集約結果のフィールドでソート
        sorted_data.sort_by(|a, b| {
            let value_a = extract_aggregation_value(a, &field_name);
            let value_b = extract_aggregation_value(b, &field_name);
            let comparison = compare_sort_values(&value_a, &value_b);
            if is_descending {
                comparison.reverse()
            } else {
                comparison
            }
        });
    }
    
    Ok(sorted_data)
}

/// ソート指定を解析（フィールド名と昇順/降順）
fn parse_sort_spec(sort_spec: &str) -> Result<(String, bool), Error> {
    if sort_spec.is_empty() {
        return Ok((String::new(), false)); // デフォルトは昇順
    }
    
    let parts: Vec<&str> = sort_spec.split(',').map(|s| s.trim()).collect();
    
    if parts.len() == 1 {
        // フィールド名のみ：昇順
        let field_name = parts[0].trim_start_matches('.').to_string();
        Ok((field_name, false))
    } else if parts.len() == 2 {
        // フィールド名 + 方向指定
        let field_name = parts[0].trim_start_matches('.').to_string();
        let direction = parts[1].trim_matches('"').trim_matches('\'');
        let is_descending = match direction.to_lowercase().as_str() {
            "desc" | "descending" | "down" => true,
            "asc" | "ascending" | "up" => false,
            _ => return Err(Error::InvalidQuery(format!(
                "Invalid sort direction: '{}'. Use 'asc' or 'desc'", direction
            ))),
        };
        Ok((field_name, is_descending))
    } else {
        Err(Error::InvalidQuery(
            "Invalid sort specification. Use: sort(.field) or sort(.field, \"desc\")".to_string()
        ))
    }
}

/// グループ化データから集約値を抽出
fn extract_aggregation_value(group_obj: &Value, field_name: &str) -> Value {
    if let Value::Object(obj) = group_obj {
        // 集約関数の結果を探す
        let possible_keys = vec![
            field_name.to_string(),
            format!("sum_{}", field_name),
            format!("avg_{}", field_name),
            format!("min_{}", field_name),
            format!("max_{}", field_name),
            format!("count_{}", field_name),
            "sum".to_string(),
            "avg".to_string(),
            "min".to_string(),
            "max".to_string(),
            "count".to_string(),
        ];
        
        for key in possible_keys {
            if let Some(value) = obj.get(&key) {
                return value.clone();
            }
        }
        
        // 見つからない場合はgroup名を返す
        obj.get("group").cloned().unwrap_or(Value::Null)
    } else {
        Value::Null
    }
}


/// map操作の実装
fn apply_map_operation(data: Vec<Value>, operation: &str) -> Result<Vec<Value>, Error> {
    // "map(.field | string_operation)" または "map(.field1, .field2 | operation)" の解析
    let content = &operation[4..operation.len() - 1]; // "map(" と ")" を除去

    // **新機能: 複数フィールド対応**
    if content.contains(',') && content.contains('|') {
        // 複数フィールドの場合: "map(.skills, .projects | join(\",\"))"
        apply_multi_field_map_operation(data, content)
    } else {
        // 単一フィールドの場合: "map(.field | operation)"
        apply_single_field_map_operation(data, content)
    }
}

/// 単一フィールドのmap操作（既存）
fn apply_single_field_map_operation(data: Vec<Value>, content: &str) -> Result<Vec<Value>, Error> {
    let (field_access, string_operations) = parse_map_content(content)?;

    let mut results = Vec::new();

    for item in data {
        // フィールドにアクセス
        let field_value = extract_field_value(&item, &field_access)?;

        // 文字列操作を適用
        let transformed_value = apply_string_operations(&field_value, &string_operations)?;

        // 元のオブジェクトを更新または新しい値を作成
        let result = update_or_create_value(&item, &field_access, transformed_value)?;
        results.push(result);
    }

    Ok(results)
}

/// 複数フィールドのmap操作（ケース1: 各フィールドに同じ操作）
fn apply_multi_field_map_operation(data: Vec<Value>, content: &str) -> Result<Vec<Value>, Error> {
    // "(.skills, .projects | join(\",\"))" を解析
    let parts: Vec<&str> = content.split('|').map(|s| s.trim()).collect();

    if parts.len() != 2 {
        return Err(Error::InvalidQuery(
            "Multi-field map must have format: (.field1, .field2 | operation)".to_string(),
        ));
    }

    let fields_part = parts[0].trim();
    let operation = parts[1].trim();

    // フィールド部分をパース: ".skills, .projects"
    let field_paths: Vec<&str> = fields_part.split(',').map(|s| s.trim()).collect();

    // 各フィールドパスが "." で始まることを確認
    for field_path in &field_paths {
        if !field_path.starts_with('.') {
            return Err(Error::InvalidQuery(format!(
                "Field path must start with '.': {}",
                field_path
            )));
        }
    }

    let mut results = Vec::new();

    for item in data {
        // 各フィールドに同じ操作を適用（ケース1）
        let transformed_item =
            crate::string_ops::apply_operation_to_multiple_fields(&item, &field_paths, operation)?;
        results.push(transformed_item);
    }

    Ok(results)
}

/// map操作の内容を解析（例: ".name | upper | trim"）
fn parse_map_content(content: &str) -> Result<(String, Vec<String>), Error> {
    let parts: Vec<&str> = content.split('|').map(|s| s.trim()).collect();

    if parts.is_empty() {
        return Err(Error::InvalidQuery("Empty map operation".to_string()));
    }

    // 最初の部分はフィールドアクセス
    let field_access = parts[0].to_string();

    // 残りは文字列操作
    let string_operations: Vec<String> = parts[1..].iter().map(|s| s.to_string()).collect();

    Ok((field_access, string_operations))
}

/// フィールド値を抽出
fn extract_field_value(item: &Value, field_access: &str) -> Result<Value, Error> {
    if field_access == "." {
        // ルート値（Text配列の場合の各行）
        return Ok(item.clone());
    }

    if field_access.starts_with('.') {
        let field_name = &field_access[1..]; // '.' を除去

        if let Some(value) = item.get(field_name) {
            Ok(value.clone())
        } else {
            Err(Error::InvalidQuery(format!(
                "Field '{}' not found",
                field_name
            )))
        }
    } else {
        Err(Error::InvalidQuery(format!(
            "Invalid field access: {}",
            field_access
        )))
    }
}

/// 文字列操作を順次適用
fn apply_string_operations(value: &Value, operations: &[String]) -> Result<Value, Error> {
    if operations.is_empty() {
        return Ok(value.clone());
    }

    let operations_str: Vec<&str> = operations.iter().map(|s| s.as_str()).collect();
    string_ops::apply_string_pipeline(value, &operations_str)
}

/// 値を更新または新しい値を作成
fn update_or_create_value(
    original: &Value,
    field_access: &str,
    new_value: Value,
) -> Result<Value, Error> {
    if field_access == "." {
        // ルート値の場合は直接置き換え
        Ok(new_value)
    } else if field_access.starts_with('.') {
        let field_name = &field_access[1..];

        // オブジェクトの場合はフィールドを更新
        if let Value::Object(mut obj) = original.clone() {
            obj.insert(field_name.to_string(), new_value);
            Ok(Value::Object(obj))
        } else {
            // オブジェクトでない場合は新しいオブジェクトを作成
            let mut new_obj = serde_json::Map::new();
            new_obj.insert(field_name.to_string(), new_value);
            Ok(Value::Object(new_obj))
        }
    } else {
        Err(Error::InvalidQuery(format!(
            "Invalid field access: {}",
            field_access
        )))
    }
}

fn apply_field_selection(data: Vec<Value>, field_list: Vec<String>) -> Result<Vec<Value>, Error> {
    let mut results = Vec::new();

    for item in data {
        if let Value::Object(obj) = item {
            let mut selected_obj = serde_json::Map::new();

            // 指定されたフィールドのみを抽出
            for field_name in &field_list {
                if let Some(value) = obj.get(field_name) {
                    selected_obj.insert(field_name.clone(), value.clone());
                }
            }

            results.push(Value::Object(selected_obj));
        } else {
            // オブジェクト以外は無視するか、エラーにする
            return Err(Error::InvalidQuery(
                "select_fields can only be applied to objects".into(),
            ));
        }
    }

    Ok(results)
}

fn group_data_by_field(data: Vec<Value>, field_name: &str) -> Result<Vec<Value>, Error> {
    use std::collections::HashMap;

    let mut groups: HashMap<String, Vec<Value>> = HashMap::new();

    for item in data {
        let key = if field_name == "." {
            // ルート要素の場合は、値そのものを使用
            value_to_string(&item)
        } else {
            // 通常のフィールドアクセス
            if let Some(field_value) = item.get(field_name) {
                value_to_string(field_value)
            } else {
                "null".to_string()
            }
        };
        
        groups.entry(key).or_default().push(item);
    }

    // グループを配列として返す
    let result: Vec<Value> = groups
        .into_iter()
        .map(|(group_name, group_items)| {
            let mut group_obj = serde_json::Map::new();
            group_obj.insert("group".to_string(), Value::String(group_name));
            group_obj.insert("items".to_string(), Value::Array(group_items));
            Value::Object(group_obj)
        })
        .collect();

    Ok(result)
}

fn parse_condition(condition: &str) -> Result<(String, String, String), Error> {
    let condition = condition.trim();

    // 演算子を検出
    if let Some(pos) = condition.find(" >= ") {
        let field = condition[..pos].trim().to_string();
        let value = condition[pos + 4..].trim().to_string();
        return Ok((field, ">=".to_string(), value));
    }

    if let Some(pos) = condition.find(" <= ") {
        let field = condition[..pos].trim().to_string();
        let value = condition[pos + 4..].trim().to_string();
        return Ok((field, "<=".to_string(), value));
    }

    if let Some(pos) = condition.find(" > ") {
        let field = condition[..pos].trim().to_string();
        let value = condition[pos + 3..].trim().to_string();
        return Ok((field, ">".to_string(), value));
    }

    if let Some(pos) = condition.find(" < ") {
        let field = condition[..pos].trim().to_string();
        let value = condition[pos + 3..].trim().to_string();
        return Ok((field, "<".to_string(), value));
    }

    if let Some(pos) = condition.find(" == ") {
        let field = condition[..pos].trim().to_string();
        let value = condition[pos + 4..].trim().to_string();
        return Ok((field, "==".to_string(), value));
    }

    if let Some(pos) = condition.find(" != ") {
        let field = condition[..pos].trim().to_string();
        let value = condition[pos + 4..].trim().to_string();
        return Ok((field, "!=".to_string(), value));
    }

    Err(Error::InvalidQuery("Invalid condition format".into()))
}

fn evaluate_condition(item: &Value, field_path: &str, operator: &str, value: &str) -> bool {
    // フィールドパスから値を取得 (.age -> age)
    let field_name = if field_path.starts_with('.') {
        &field_path[1..]
    } else {
        field_path
    };

    let field_value = match item.get(field_name) {
        Some(val) => val,
        None => return false,
    };

    match operator {
        ">" => compare_greater(field_value, value),
        "<" => compare_less(field_value, value),
        ">=" => compare_greater_equal(field_value, value),
        "<=" => compare_less_equal(field_value, value),
        "==" => compare_equal(field_value, value),
        "!=" => !compare_equal(field_value, value),
        _ => false,
    }
}

fn compare_greater(field_value: &Value, target: &str) -> bool {
    match field_value {
        Value::Number(n) => {
            if let Ok(target_num) = target.parse::<f64>() {
                n.as_f64().unwrap_or(0.0) > target_num
            } else {
                false
            }
        }
        _ => false,
    }
}

fn compare_less(field_value: &Value, target: &str) -> bool {
    match field_value {
        Value::Number(n) => {
            if let Ok(target_num) = target.parse::<f64>() {
                n.as_f64().unwrap_or(0.0) < target_num
            } else {
                false
            }
        }
        _ => false,
    }
}

fn compare_equal(field_value: &Value, target: &str) -> bool {
    match field_value {
        Value::String(s) => {
            // 文字列比較（引用符を除去）
            let target_clean = target.trim_matches('"');
            s == target_clean
        }
        Value::Number(n) => {
            if let Ok(target_num) = target.parse::<f64>() {
                n.as_f64().unwrap_or(0.0) == target_num
            } else {
                false
            }
        }
        Value::Bool(b) => match target {
            "true" => *b,
            "false" => !*b,
            _ => false,
        },
        _ => false,
    }
}

fn compare_greater_equal(field_value: &Value, target: &str) -> bool {
    match field_value {
        Value::Number(n) => {
            if let Ok(target_num) = target.parse::<f64>() {
                n.as_f64().unwrap_or(0.0) >= target_num
            } else {
                false
            }
        }
        _ => false,
    }
}

fn compare_less_equal(field_value: &Value, target: &str) -> bool {
    match field_value {
        Value::Number(n) => {
            if let Ok(target_num) = target.parse::<f64>() {
                n.as_f64().unwrap_or(0.0) <= target_num
            } else {
                false
            }
        }
        _ => false,
    }
}

fn is_grouped_data(data: &[Value]) -> bool {
    data.iter().all(|item| {
        if let Value::Object(obj) = item {
            obj.contains_key("group") && obj.contains_key("items")
        } else {
            false
        }
    })
}

fn apply_aggregation_to_groups(
    data: Vec<Value>,
    operation: &str,
    field_name: &str,
) -> Result<Vec<Value>, Error> {
    let mut results = Vec::new();

    for group_data in data {
        if let Value::Object(group_obj) = group_data {
            let group_name = group_obj.get("group").unwrap();
            let items = group_obj.get("items").and_then(|v| v.as_array()).unwrap();

            // 各グループのitemsに対して集約を実行
            let aggregated_value = match operation {
                "avg" => calculate_avg(items, field_name)?,
                "sum" => calculate_sum(items, field_name)?,
                "count" => Value::Number(serde_json::Number::from(items.len())),
                "min" => calculate_min(items, field_name)?,
                "max" => calculate_max(items, field_name)?,
                _ => Value::Null,
            };

            // 結果オブジェクトを作成
            let mut result_obj = serde_json::Map::new();
            result_obj.insert("group".to_string(), group_name.clone());
            result_obj.insert(operation.to_string(), aggregated_value);
            results.push(Value::Object(result_obj));
        }
    }

    Ok(results)
}

fn calculate_avg(items: &[Value], field_name: &str) -> Result<Value, Error> {
    let values: Vec<f64> = items
        .iter()
        .filter_map(|item| item.get(field_name))
        .filter_map(|val| val.as_f64())
        .collect();

    if values.is_empty() {
        Ok(Value::Null)
    } else {
        let avg = values.iter().sum::<f64>() / values.len() as f64;
        let rounded_avg = (avg * 10.0).round() / 10.0;
        Ok(Value::Number(
            serde_json::Number::from_f64(rounded_avg).unwrap(),
        ))
    }
}

fn calculate_sum(items: &[Value], field_name: &str) -> Result<Value, Error> {
    let sum: f64 = items
        .iter()
        .filter_map(|item| item.get(field_name))
        .filter_map(|val| val.as_f64())
        .sum();

    let rounded_sum = if sum.fract() == 0.0 {
        sum
    } else {
        (sum * 10.0).round() / 10.0
    };

    Ok(Value::Number(
        serde_json::Number::from_f64(rounded_sum).unwrap(),
    ))
}

fn calculate_min(items: &[Value], field_name: &str) -> Result<Value, Error> {
    let min_val = items
        .iter()
        .filter_map(|item| item.get(field_name))
        .filter_map(|val| val.as_f64())
        .fold(f64::INFINITY, f64::min);

    if min_val == f64::INFINITY {
        Ok(Value::Null)
    } else {
        Ok(Value::Number(
            serde_json::Number::from_f64(min_val).unwrap(),
        ))
    }
}

fn calculate_max(items: &[Value], field_name: &str) -> Result<Value, Error> {
    let max_val = items
        .iter()
        .filter_map(|item| item.get(field_name))
        .filter_map(|val| val.as_f64())
        .fold(f64::NEG_INFINITY, f64::max);

    if max_val == f64::NEG_INFINITY {
        Ok(Value::Null)
    } else {
        Ok(Value::Number(
            serde_json::Number::from_f64(max_val).unwrap(),
        ))
    }
}

/// 配列に対してスライス操作を適用（汎用関数）
pub fn apply_array_slice(array: &[Value], start: Option<usize>, end: Option<usize>) -> Vec<Value> {
    let len = array.len();

    let start_idx = start.unwrap_or(0);
    let end_idx = end.unwrap_or(len);

    // 範囲チェック
    let start_idx = start_idx.min(len);
    let end_idx = end_idx.min(len);

    if start_idx >= end_idx {
        return Vec::new(); // 無効な範囲の場合は空を返す
    }

    array[start_idx..end_idx].to_vec()
}

/// グループ化されたデータに対してスライスを適用
pub fn apply_slice_to_grouped_data(
    data: Vec<Value>,
    start: Option<usize>,
    end: Option<usize>,
) -> Result<Vec<Value>, Error> {
    let mut result = Vec::new();

    for group in data {
        if let Value::Array(group_items) = group {
            // 各グループに対してスライスを適用
            let sliced_group = apply_array_slice(&group_items, start, end);

            // スライス結果を展開して結果に追加
            result.extend(sliced_group);
        } else {
            // 配列でない場合はそのまま追加（エラー回避）
            result.push(group);
        }
    }

    Ok(result)
}

/// スライス記法をパース ([start:end] 形式)
pub fn parse_slice_notation(
    bracket_content: &str,
) -> Result<(Option<usize>, Option<usize>), Error> {
    if !bracket_content.contains(':') {
        return Err(Error::InvalidQuery("Not a slice notation".to_string()));
    }

    let parts: Vec<&str> = bracket_content.split(':').collect();
    if parts.len() != 2 {
        return Err(Error::InvalidQuery(
            "Invalid slice format, expected start:end".to_string(),
        ));
    }

    let start = if parts[0].is_empty() {
        None // 空の場合は先頭から
    } else {
        Some(
            parts[0]
                .parse::<usize>()
                .map_err(|_| Error::InvalidQuery(format!("Invalid start index: {}", parts[0])))?,
        )
    };

    let end = if parts[1].is_empty() {
        None // 空の場合は末尾まで
    } else {
        Some(
            parts[1]
                .parse::<usize>()
                .map_err(|_| Error::InvalidQuery(format!("Invalid end index: {}", parts[1])))?,
        )
    };

    Ok((start, end))
}

/// 負のインデックスに対応したスライス解析
pub fn parse_slice_notation_with_negative(
    bracket_content: &str,
    data_len: usize,
) -> Result<(Option<usize>, Option<usize>), Error> {
    let parts: Vec<&str> = bracket_content.split(':').collect();
    if parts.len() != 2 {
        return Err(Error::InvalidQuery(
            "Invalid slice format, expected start:end".to_string(),
        ));
    }

    let start = if parts[0].is_empty() {
        None
    } else {
        Some(parse_index_with_negative(parts[0], data_len)?)
    };

    let end = if parts[1].is_empty() {
        None
    } else {
        Some(parse_index_with_negative(parts[1], data_len)?)
    };

    Ok((start, end))
}

/// 負のインデックス対応のインデックス解析
pub fn parse_index_with_negative(index_str: &str, data_len: usize) -> Result<usize, Error> {
    if index_str.starts_with('-') {
        let negative_index = index_str[1..]
            .parse::<usize>()
            .map_err(|_| Error::InvalidQuery(format!("Invalid negative index: {}", index_str)))?;

        if negative_index > data_len {
            Ok(0) // 範囲外の場合は0に
        } else {
            Ok(data_len - negative_index)
        }
    } else {
        index_str
            .parse::<usize>()
            .map_err(|_| Error::InvalidQuery(format!("Invalid index: {}", index_str)))
    }
}

/// データ構造の種類を判定
#[derive(Debug, PartialEq)]
pub enum DataStructure {
    GroupedData,  // group_by後：全て配列
    RegularArray, // 通常の配列：オブジェクトや値の配列
    NestedArrays, // ネストした配列：配列の配列（group_byではない）
    Mixed,        // 混合
}

pub fn detect_data_structure(data: &[Value]) -> DataStructure {
    if data.is_empty() {
        return DataStructure::RegularArray;
    }

    let all_arrays = data.iter().all(|item| item.is_array());
    let all_objects = data.iter().all(|item| item.is_object());
    let all_primitives = data.iter().all(|item| {
        matches!(
            item,
            Value::String(_) | Value::Number(_) | Value::Bool(_) | Value::Null
        )
    });

    if all_arrays {
        // 全て配列の場合、group_byの結果かネストした配列かを判定
        if is_likely_grouped_data(data) {
            DataStructure::GroupedData
        } else {
            DataStructure::NestedArrays
        }
    } else if all_objects || all_primitives {
        DataStructure::RegularArray
    } else {
        DataStructure::Mixed
    }
}

/// group_byの結果らしいデータかを判定
pub fn is_likely_grouped_data(data: &[Value]) -> bool {
    // 簡単なヒューリスティック：
    // 1. 全て配列
    // 2. 各配列が空でない
    // 3. 各配列の最初の要素が同じ構造（オブジェクト）

    if data.len() < 2 {
        return false; // グループが1個だけの場合は判定困難
    }

    for item in data {
        if let Value::Array(arr) = item {
            if arr.is_empty() {
                return false;
            }
            if !arr[0].is_object() {
                return false;
            }
        } else {
            return false;
        }
    }

    true
}

/// ユニバーサルスライス操作（あらゆるデータに対応）
pub fn apply_universal_slice_operation(
    data: Vec<Value>,
    operation: &str,
) -> Result<Vec<Value>, Error> {
    let bracket_content = &operation[2..operation.len() - 1]; // ".["と"]"を除去

    // 負のインデックス対応の確認
    if bracket_content.starts_with('-') && !bracket_content.contains(':') {
        return apply_negative_index_slice(data, bracket_content);
    }

    // 通常のスライス記法かどうかチェック
    if !bracket_content.contains(':') {
        // 単一インデックスの場合
        let index = bracket_content
            .parse::<usize>()
            .map_err(|_| Error::InvalidQuery(format!("Invalid index: {}", bracket_content)))?;

        if let Some(item) = data.get(index) {
            return Ok(vec![item.clone()]);
        } else {
            return Ok(vec![]); // インデックスが範囲外の場合は空を返す
        }
    }

    // スライス記法の解析
    let (start, end) = parse_slice_notation_with_negative(bracket_content, data.len())?;

    // データ構造に応じた適切な処理
    match detect_data_structure(&data) {
        DataStructure::GroupedData => apply_slice_to_grouped_data(data, start, end),
        DataStructure::RegularArray => apply_slice_to_regular_array(data, start, end),
        DataStructure::NestedArrays => apply_slice_to_nested_arrays(data, start, end),
        DataStructure::Mixed => apply_slice_to_regular_array(data, start, end), // デフォルト
    }
}

/// 負のインデックス単体の処理
pub fn apply_negative_index_slice(data: Vec<Value>, index_str: &str) -> Result<Vec<Value>, Error> {
    let data_len = data.len();
    let negative_index = index_str[1..]
        .parse::<usize>()
        .map_err(|_| Error::InvalidQuery(format!("Invalid negative index: {}", index_str)))?;

    if negative_index > data_len || negative_index == 0 {
        return Ok(vec![]); // 範囲外または-0の場合
    }

    let actual_index = data_len - negative_index;
    if let Some(item) = data.get(actual_index) {
        Ok(vec![item.clone()])
    } else {
        Ok(vec![])
    }
}

/// 通常の配列に対するスライス
pub fn apply_slice_to_regular_array(
    data: Vec<Value>,
    start: Option<usize>,
    end: Option<usize>,
) -> Result<Vec<Value>, Error> {
    let sliced = apply_array_slice(&data, start, end);
    Ok(sliced)
}

/// ネストした配列に対するスライス
pub fn apply_slice_to_nested_arrays(
    data: Vec<Value>,
    start: Option<usize>,
    end: Option<usize>,
) -> Result<Vec<Value>, Error> {
    // ネストした配列の場合、外側の配列をスライスする（より直感的）
    let sliced = apply_array_slice(&data, start, end);
    Ok(sliced)
}

/// フィールド指定ソート操作
pub fn apply_sort_with_field_operation(
    data: Vec<Value>,
    operation: &str,
) -> Result<Vec<Value>, Error> {
    let field_path = &operation[5..operation.len() - 1]; // "sort(" と ")" を除去

    let mut sorted_data = data;
    sorted_data.sort_by(|a, b| {
        let value_a = extract_sort_key(a, field_path);
        let value_b = extract_sort_key(b, field_path);

        compare_sort_values(&value_a, &value_b)
    });

    Ok(sorted_data)
}

/// ソート用のキー値を抽出
// pub fn extract_sort_key(item: &Value, field_path: &str) -> Value {
//     if field_path.starts_with('.') {
//         let field_name = &field_path[1..];
//         item.get(field_name).cloned().unwrap_or(Value::Null)
//     } else {
//         item.clone()
//     }
// }

fn extract_sort_key(item: &Value, field_path: &str) -> Value {
    if field_path == "." || field_path.is_empty() {
        item.clone()
    } else if field_path.starts_with('.') {
        let field_name = &field_path[1..];
        item.get(field_name).cloned().unwrap_or(Value::Null)
    } else {
        item.get(field_path).cloned().unwrap_or(Value::Null)
    }
}

/// ソート用の値比較
// pub fn compare_sort_values(a: &Value, b: &Value) -> std::cmp::Ordering {
//     use std::cmp::Ordering;
// 
//     match (a, b) {
//         (Value::Number(n1), Value::Number(n2)) => {
//             let f1 = n1.as_f64().unwrap_or(0.0);
//             let f2 = n2.as_f64().unwrap_or(0.0);
//             f1.partial_cmp(&f2).unwrap_or(Ordering::Equal)
//         }
//         (Value::String(s1), Value::String(s2)) => s1.cmp(s2),
//         (Value::Bool(b1), Value::Bool(b2)) => b1.cmp(b2),
//         (Value::Null, Value::Null) => Ordering::Equal,
//         (Value::Null, _) => Ordering::Less,
//         (_, Value::Null) => Ordering::Greater,
//         _ => Ordering::Equal,
//     }
// }

fn compare_sort_values(a: &Value, b: &Value) -> std::cmp::Ordering {
    use std::cmp::Ordering;

    match (a, b) {
        (Value::Number(n1), Value::Number(n2)) => {
            let f1 = n1.as_f64().unwrap_or(0.0);
            let f2 = n2.as_f64().unwrap_or(0.0);
            f1.partial_cmp(&f2).unwrap_or(Ordering::Equal)
        }
        (Value::String(s1), Value::String(s2)) => s1.cmp(s2),
        (Value::Bool(b1), Value::Bool(b2)) => b1.cmp(b2),
        (Value::Null, Value::Null) => Ordering::Equal,
        (Value::Null, _) => Ordering::Less,
        (_, Value::Null) => Ordering::Greater,
        // 異なる型の場合は文字列化して比較
        _ => {
            let s1 = value_to_string(a);
            let s2 = value_to_string(b);
            s1.cmp(&s2)
        }
    }
}


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

    #[test]
    fn test_apply_array_slice_basic() {
        let array = vec![json!("a"), json!("b"), json!("c"), json!("d"), json!("e")];

        // [0:3] -> ["a", "b", "c"]
        let result = apply_array_slice(&array, Some(0), Some(3));
        assert_eq!(result.len(), 3);
        assert_eq!(result[0], json!("a"));
        assert_eq!(result[2], json!("c"));

        // [1:4] -> ["b", "c", "d"]
        let result = apply_array_slice(&array, Some(1), Some(4));
        assert_eq!(result.len(), 3);
        assert_eq!(result[0], json!("b"));

        // [:3] -> ["a", "b", "c"]
        let result = apply_array_slice(&array, None, Some(3));
        assert_eq!(result.len(), 3);
        assert_eq!(result[0], json!("a"));

        // [2:] -> ["c", "d", "e"]
        let result = apply_array_slice(&array, Some(2), None);
        assert_eq!(result.len(), 3);
        assert_eq!(result[0], json!("c"));

        // 範囲外の場合
        let result = apply_array_slice(&array, Some(10), Some(20));
        assert_eq!(result.len(), 0);

        // 無効な範囲
        let result = apply_array_slice(&array, Some(3), Some(1));
        assert_eq!(result.len(), 0);
    }

    #[test]
    fn test_apply_slice_to_grouped_data() {
        // group_by後のデータ形式をシミュレート
        let grouped_data = vec![
            json!([
                {"category": "Electronics", "name": "Laptop", "price": 1200},
                {"category": "Electronics", "name": "Phone", "price": 800},
                {"category": "Electronics", "name": "Tablet", "price": 600},
                {"category": "Electronics", "name": "Mouse", "price": 25}
            ]),
            json!([
                {"category": "Books", "name": "Fiction", "price": 20},
                {"category": "Books", "name": "Science", "price": 30},
                {"category": "Books", "name": "History", "price": 25},
                {"category": "Books", "name": "Biography", "price": 35}
            ]),
            json!([
                {"category": "Clothing", "name": "Shirt", "price": 40},
                {"category": "Clothing", "name": "Pants", "price": 60},
                {"category": "Clothing", "name": "Shoes", "price": 80}
            ]),
        ];

        // 各グループから最初の2個を取得
        let result = apply_slice_to_grouped_data(grouped_data.clone(), Some(0), Some(2)).unwrap();

        // 結果の検証：3グループ × 2個 = 6個
        assert_eq!(result.len(), 6);

        // Electronics グループの最初の2個
        assert_eq!(result[0].get("name").unwrap(), &json!("Laptop"));
        assert_eq!(result[1].get("name").unwrap(), &json!("Phone"));

        // Books グループの最初の2個
        assert_eq!(result[2].get("name").unwrap(), &json!("Fiction"));
        assert_eq!(result[3].get("name").unwrap(), &json!("Science"));

        // Clothing グループの最初の2個
        assert_eq!(result[4].get("name").unwrap(), &json!("Shirt"));
        assert_eq!(result[5].get("name").unwrap(), &json!("Pants"));
    }

    #[test]
    fn test_apply_slice_to_grouped_data_different_ranges() {
        let grouped_data = vec![
            json!([
                {"id": 1, "group": "A"},
                {"id": 2, "group": "A"},
                {"id": 3, "group": "A"},
                {"id": 4, "group": "A"},
                {"id": 5, "group": "A"}
            ]),
            json!([
                {"id": 6, "group": "B"},
                {"id": 7, "group": "B"},
                {"id": 8, "group": "B"},
                {"id": 9, "group": "B"}
            ]),
        ];

        // 各グループから2番目から4番目まで（インデックス1-3）
        let result = apply_slice_to_grouped_data(grouped_data.clone(), Some(1), Some(4)).unwrap();

        // A群：3個（id: 2,3,4）、B群：3個（id: 7,8,9）= 合計6個
        assert_eq!(result.len(), 6);

        // A群の結果確認
        assert_eq!(result[0].get("id").unwrap(), &json!(2));
        assert_eq!(result[1].get("id").unwrap(), &json!(3));
        assert_eq!(result[2].get("id").unwrap(), &json!(4));

        // B群の結果確認
        assert_eq!(result[3].get("id").unwrap(), &json!(7));
        assert_eq!(result[4].get("id").unwrap(), &json!(8));
        assert_eq!(result[5].get("id").unwrap(), &json!(9));
    }

    #[test]
    fn test_parse_slice_notation() {
        // 通常のスライス
        let (start, end) = parse_slice_notation("0:5").unwrap();
        assert_eq!(start, Some(0));
        assert_eq!(end, Some(5));

        // 開始インデックスなし
        let (start, end) = parse_slice_notation(":5").unwrap();
        assert_eq!(start, None);
        assert_eq!(end, Some(5));

        // 終了インデックスなし
        let (start, end) = parse_slice_notation("2:").unwrap();
        assert_eq!(start, Some(2));
        assert_eq!(end, None);

        // 両方なし（全体）
        let (start, end) = parse_slice_notation(":").unwrap();
        assert_eq!(start, None);
        assert_eq!(end, None);

        // エラーケース
        assert!(parse_slice_notation("abc:def").is_err());
        assert!(parse_slice_notation("0:5:10").is_err());
    }

    #[test]
    fn test_parse_index_with_negative() {
        // 正のインデックス
        assert_eq!(parse_index_with_negative("5", 10).unwrap(), 5);

        // 負のインデックス
        assert_eq!(parse_index_with_negative("-1", 10).unwrap(), 9);
        assert_eq!(parse_index_with_negative("-3", 10).unwrap(), 7);

        // 範囲外の負のインデックス
        assert_eq!(parse_index_with_negative("-15", 10).unwrap(), 0);

        // エラーケース
        assert!(parse_index_with_negative("abc", 10).is_err());
        assert!(parse_index_with_negative("-abc", 10).is_err());
    }

    #[test]
    fn test_detect_data_structure() {
        // 通常の配列
        let regular = vec![json!({"id": 1}), json!({"id": 2})];
        assert_eq!(detect_data_structure(&regular), DataStructure::RegularArray);

        // グループ化されたデータ
        let grouped = vec![
            json!([{"cat": "A", "val": 1}, {"cat": "A", "val": 2}]),
            json!([{"cat": "B", "val": 3}, {"cat": "B", "val": 4}]),
        ];
        assert_eq!(detect_data_structure(&grouped), DataStructure::GroupedData);

        // プリミティブ値の配列
        let primitives = vec![json!(1), json!(2), json!(3)];
        assert_eq!(
            detect_data_structure(&primitives),
            DataStructure::RegularArray
        );

        // 空配列
        let empty: Vec<Value> = vec![];
        assert_eq!(detect_data_structure(&empty), DataStructure::RegularArray);
    }

    #[test]
    fn test_apply_sort_with_field_operation() {
        let data = vec![
            json!({"name": "Alice", "score": 85}),
            json!({"name": "Bob", "score": 92}),
            json!({"name": "Carol", "score": 78}),
        ];

        let result = apply_sort_with_field_operation(data, "sort(.score)").unwrap();

        // スコア順にソートされているか確認
        assert_eq!(result[0].get("score").unwrap(), &json!(78)); // Carol
        assert_eq!(result[1].get("score").unwrap(), &json!(85)); // Alice
        assert_eq!(result[2].get("score").unwrap(), &json!(92)); // Bob
    }

    #[test]
    fn test_apply_negative_index_slice() {
        let data = vec![json!("a"), json!("b"), json!("c"), json!("d"), json!("e")];

        // .[-1] - 最後の要素
        let result = apply_negative_index_slice(data.clone(), "-1").unwrap();
        assert_eq!(result.len(), 1);
        assert_eq!(result[0], json!("e"));

        // .[-3] - 後ろから3番目
        let result = apply_negative_index_slice(data.clone(), "-3").unwrap();
        assert_eq!(result.len(), 1);
        assert_eq!(result[0], json!("c"));

        // 範囲外
        let result = apply_negative_index_slice(data.clone(), "-10").unwrap();
        assert_eq!(result.len(), 0);
    }
}