tool-parser 1.9.0

use openai_protocol::common::{Function, Tool};

use super::*;
use crate::{
    parsers::{JsonParser, QwenXmlParser},
    partial_json::PartialJson,
    traits::ToolParser,
};

#[tokio::test]
async fn test_tool_parser_factory() {
    let factory = ParserFactory::new();

    // Test that we can get a pooled parser
    let pooled_parser = factory.get_pooled("gpt-4");
    let parser = pooled_parser.lock().await;
    assert!(parser.has_tool_markers(r#"{"name": "test", "arguments": {}}"#));
}

#[tokio::test]
async fn test_tool_parser_factory_model_mapping() {
    let factory = ParserFactory::new();

    // Test model mapping
    factory.registry().map_model("test-model", "json");

    // Get parser for the test model
    let pooled_parser = factory.get_pooled("test-model");
    let parser = pooled_parser.lock().await;
    assert!(parser.has_tool_markers(r#"{"name": "test", "arguments": {}}"#));
}

#[test]
fn test_tool_call_serialization() {
    let tool_call = ToolCall {
        function: FunctionCall {
            name: "search".to_string(),
            arguments: r#"{"query": "rust programming"}"#.to_string(),
        },
    };

    let json = serde_json::to_string(&tool_call).unwrap();
    assert!(json.contains("search"));
    assert!(json.contains("rust programming"));

    let parsed: ToolCall = serde_json::from_str(&json).unwrap();
    assert_eq!(parsed.function.name, "search");
    assert_eq!(
        parsed.function.arguments,
        r#"{"query": "rust programming"}"#
    );
}

#[test]
fn test_partial_json_parser() {
    let parser = PartialJson::default();

    let input = r#"{"name": "test", "value": 42}"#;
    let (value, consumed) = parser.parse_value(input, true).unwrap();
    assert_eq!(value["name"], "test");
    assert_eq!(value["value"], 42);
    assert_eq!(consumed, input.len());

    let input = r#"{"name": "test", "value": "#;
    let (value, _consumed) = parser.parse_value(input, true).unwrap();
    assert_eq!(value["name"], "test");
    assert!(value["value"].is_null());

    let input = r#"{"name": "tes"#;
    let (value, _consumed) = parser.parse_value(input, true).unwrap();
    assert_eq!(value["name"], "tes");

    let input = r"[1, 2, ";
    let (value, _consumed) = parser.parse_value(input, true).unwrap();
    assert!(value.is_array());
    assert_eq!(value[0], 1);
    assert_eq!(value[1], 2);
}

#[test]
fn test_partial_json_consumed_is_byte_offset() {
    let parser = PartialJson::default();

    // Complete object with a multibyte value: consumed must be the byte length
    // and must land on a UTF-8 char boundary so input[..consumed] is sliceable.
    let input = r#"{"k":"é"}"#;
    let (value, consumed) = parser.parse_value(input, true).unwrap();
    assert_eq!(value["k"], "é");
    assert_eq!(consumed, input.len());
    assert!(input.is_char_boundary(consumed));
    let _ = &input[..consumed];

    // Partial object whose multibyte char is the last consumed content.
    let input = "{\"k\":\"é";
    let (value, consumed) = parser.parse_value(input, true).unwrap();
    assert_eq!(value["k"], "é");
    assert!(input.is_char_boundary(consumed));
    let _ = &input[..consumed];

    // Emoji (4-byte) value also yields a byte offset on a char boundary.
    let input = r#"{"k":"🌍"}"#;
    let (_value, consumed) = parser.parse_value(input, true).unwrap();
    assert_eq!(consumed, input.len());
    assert!(input.is_char_boundary(consumed));
}

#[test]
fn test_partial_json_depth_limit() {
    // max_depth of 3 allows nesting up to 3 levels
    // Set allow_incomplete to false to get errors instead of partial results
    let parser = PartialJson::new(3, false);

    // This should work (simple object)
    let input = r#"{"a": 1}"#;
    let result = parser.parse_value(input, true);
    assert!(result.is_ok());

    // This should work (nested to depth 3)
    let input = r#"{"a": {"b": {"c": 1}}}"#;
    let result = parser.parse_value(input, true);
    assert!(result.is_ok());

    // This should fail (nested to depth 4, exceeds limit)
    let input = r#"{"a": {"b": {"c": {"d": 1}}}}"#;
    let result = parser.parse_value(input, true);
    assert!(result.is_err());
}

// NOTE: test_stream_result_variants removed - StreamResult enum replaced by StreamingParseResult

#[tokio::test]
async fn test_json_parser_complete_single() {
    let parser = JsonParser::new();

    let input = r#"{"name": "get_weather", "arguments": {"location": "San Francisco", "units": "celsius"}}"#;
    let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();

    assert_eq!(tools.len(), 1);
    assert_eq!(tools[0].function.name, "get_weather");
    assert!(tools[0].function.arguments.contains("San Francisco"));
    assert!(tools[0].function.arguments.contains("celsius"));
}

#[tokio::test]
async fn test_json_parser_complete_array() {
    let parser = JsonParser::new();

    let input = r#"[
        {"name": "get_weather", "arguments": {"location": "SF"}},
        {"name": "get_news", "arguments": {"query": "technology"}}
    ]"#;

    let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();

    assert_eq!(tools.len(), 2);
    assert_eq!(tools[0].function.name, "get_weather");
    assert_eq!(tools[1].function.name, "get_news");
}

#[tokio::test]
async fn test_json_parser_with_parameters() {
    let parser = JsonParser::new();

    let input = r#"{"name": "calculate", "parameters": {"x": 10, "y": 20, "operation": "add"}}"#;
    let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();

    assert_eq!(tools.len(), 1);
    assert_eq!(tools[0].function.name, "calculate");
    assert!(tools[0].function.arguments.contains("10"));
    assert!(tools[0].function.arguments.contains("20"));
    assert!(tools[0].function.arguments.contains("add"));
}

// Tests removed - TokenConfig no longer supported in JsonParser

#[tokio::test]
async fn test_multiline_json_array() {
    let parser = JsonParser::new();

    let input = r#"[
    {
        "name": "function1",
        "arguments": {
            "param1": "value1",
            "param2": 42
        }
    },
    {
        "name": "function2",
        "parameters": {
            "data": [1, 2, 3],
            "flag": false
        }
    }
]"#;

    let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
    assert_eq!(tools.len(), 2);
    assert_eq!(tools[0].function.name, "function1");
    assert_eq!(tools[1].function.name, "function2");
    assert!(tools[0].function.arguments.contains("value1"));
    assert!(tools[1].function.arguments.contains("[1,2,3]"));
}

#[test]
fn test_json_parser_format_detection() {
    let parser = JsonParser::new();

    // Should detect valid tool call formats
    assert!(parser.has_tool_markers(r#"{"name": "test", "arguments": {}}"#));
    assert!(parser.has_tool_markers(r#"{"name": "test", "parameters": {"x": 1}}"#));
    assert!(parser.has_tool_markers(r#"[{"name": "test"}]"#));

    // Should not detect non-tool formats
    assert!(!parser.has_tool_markers("plain text"));
}

#[tokio::test]
async fn test_factory_with_json_parser() {
    let factory = ParserFactory::new();

    // Should get JSON parser for OpenAI models
    let pooled_parser = factory.get_pooled("gpt-4-turbo");
    let parser = pooled_parser.lock().await;

    let input = r#"{"name": "test", "arguments": {"x": 1}}"#;
    let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
    assert_eq!(tools.len(), 1);
    assert_eq!(tools[0].function.name, "test");
}

#[tokio::test]
async fn test_json_parser_invalid_input() {
    let parser = JsonParser::new();

    // Invalid JSON should return empty results
    assert_eq!(parser.parse_complete("not json").await.unwrap().1.len(), 0);
    assert_eq!(parser.parse_complete("{invalid}").await.unwrap().1.len(), 0);
    assert_eq!(parser.parse_complete("").await.unwrap().1.len(), 0);
}

#[tokio::test]
async fn test_json_parser_empty_arguments() {
    let parser = JsonParser::new();

    // Tool call with no arguments
    let input = r#"{"name": "get_time"}"#;
    let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();

    assert_eq!(tools.len(), 1);
    assert_eq!(tools[0].function.name, "get_time");
    assert_eq!(tools[0].function.arguments, "{}");
}

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

    #[tokio::test]
    async fn test_malformed_tool_missing_name() {
        let parser = JsonParser::new();

        // Missing name field
        let input = r#"{"arguments": {"x": 1}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 0, "Should return empty for tool without name");

        // Empty name
        let input = r#"{"name": "", "arguments": {"x": 1}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1, "Should accept empty name string");
        assert_eq!(tools[0].function.name, "");
    }

    #[tokio::test]
    async fn test_invalid_arguments_json() {
        let parser = JsonParser::new();

        // Arguments is a string instead of object
        let input = r#"{"name": "test", "arguments": "not an object"}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        // Should serialize the string as JSON
        assert!(tools[0].function.arguments.contains("not an object"));

        // Arguments is a number
        let input = r#"{"name": "test", "arguments": 42}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].function.arguments, "42");

        // Arguments is null
        let input = r#"{"name": "test", "arguments": null}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].function.arguments, "null");
    }

    // Test removed - wrapper token functionality moved to specific parsers

    #[tokio::test]
    async fn test_invalid_json_structures() {
        let parser = JsonParser::new();

        // Trailing comma
        let input = r#"{"name": "test", "arguments": {"x": 1,}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 0, "Should reject JSON with trailing comma");

        // Missing quotes on keys
        let input = r#"{name: "test", arguments: {}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 0, "Should reject invalid JSON syntax");

        // Unclosed object
        let input = r#"{"name": "test", "arguments": {"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 0, "Should reject incomplete JSON");
    }
}

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

    #[tokio::test]
    async fn test_unicode_in_names_and_arguments() {
        let parser = JsonParser::new();

        // Unicode in function name
        let input = r#"{"name": "获取天气", "arguments": {"location": "北京"}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].function.name, "获取天气");
        assert!(tools[0].function.arguments.contains("北京"));

        // Emoji in arguments
        let input = r#"{"name": "send_message", "arguments": {"text": "Hello 👋 World 🌍"}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("👋"));
        assert!(tools[0].function.arguments.contains("🌍"));
    }

    #[tokio::test]
    async fn test_escaped_characters() {
        let parser = JsonParser::new();

        // Escaped quotes in arguments
        let input = r#"{"name": "echo", "arguments": {"text": "He said \"hello\""}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains(r#"\"hello\""#));

        // Escaped backslashes
        let input = r#"{"name": "path", "arguments": {"dir": "C:\\Users\\test"}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("\\\\"));

        // Newlines and tabs
        let input = r#"{"name": "format", "arguments": {"text": "line1\nline2\ttabbed"}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("\\n"));
        assert!(tools[0].function.arguments.contains("\\t"));
    }

    #[tokio::test]
    async fn test_very_large_payloads() {
        let parser = JsonParser::new();

        // Large arguments object
        let mut large_args = r#"{"name": "process", "arguments": {"#.to_string();
        for i in 0..1000 {
            large_args.push_str(&format!(r#""field_{i}": "value_{i}","#));
        }
        large_args.push_str(r#""final": "value"}}"#);

        let (_normal_text, tools) = parser.parse_complete(&large_args).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].function.name, "process");
        assert!(tools[0].function.arguments.contains("field_999"));

        // Large array of tool calls
        let mut large_array = "[".to_string();
        for i in 0..100 {
            if i > 0 {
                large_array.push(',');
            }
            large_array.push_str(&format!(r#"{{"name": "func_{i}", "arguments": {{}}}}"#));
        }
        large_array.push(']');

        let (_normal_text, tools) = parser.parse_complete(&large_array).await.unwrap();
        assert_eq!(tools.len(), 100);
        assert_eq!(tools[99].function.name, "func_99");
    }

    #[tokio::test]
    async fn test_mixed_array_tools_and_non_tools() {
        let parser = JsonParser::new();

        // Array with both tool calls and non-tool objects
        let input = r#"[
            {"name": "tool1", "arguments": {}},
            {"not_a_tool": "just_data"},
            {"name": "tool2", "parameters": {"x": 1}},
            {"key": "value", "another": "field"}
        ]"#;

        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 2, "Should only parse valid tool calls");
        assert_eq!(tools[0].function.name, "tool1");
        assert_eq!(tools[1].function.name, "tool2");
    }

    #[tokio::test]
    async fn test_duplicate_keys_in_json() {
        let parser = JsonParser::new();

        // JSON with duplicate keys (last one wins in most parsers)
        let input = r#"{"name": "first", "name": "second", "arguments": {"x": 1, "x": 2}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(
            tools[0].function.name, "second",
            "Last duplicate key should win"
        );
        assert!(
            tools[0].function.arguments.contains("2"),
            "Last duplicate value should win"
        );
    }

    #[tokio::test]
    async fn test_null_values_in_arguments() {
        let parser = JsonParser::new();

        // Null values in arguments
        let input = r#"{"name": "test", "arguments": {"required": "value", "optional": null}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("null"));

        // Array with null
        let input = r#"{"name": "test", "arguments": {"items": [1, null, "three"]}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("null"));
    }

    #[tokio::test]
    async fn test_special_json_values() {
        let parser = JsonParser::new();

        // Boolean values
        let input = r#"{"name": "toggle", "arguments": {"enabled": true, "disabled": false}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("true"));
        assert!(tools[0].function.arguments.contains("false"));

        // Numbers (including float and negative)
        let input = r#"{"name": "calc", "arguments": {"int": 42, "float": 3.14, "negative": -17}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("42"));
        assert!(tools[0].function.arguments.contains("3.14"));
        assert!(tools[0].function.arguments.contains("-17"));

        // Empty arrays and objects
        let input = r#"{"name": "test", "arguments": {"empty_arr": [], "empty_obj": {}}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("[]"));
        assert!(tools[0].function.arguments.contains("{}"));
    }

    #[tokio::test]
    async fn test_function_field_alternative() {
        let parser = JsonParser::new();

        // Using "function" instead of "name"
        let input = r#"{"function": "test_func", "arguments": {"x": 1}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].function.name, "test_func");

        // Both "name" and "function" present (name should take precedence)
        let input = r#"{"name": "primary", "function": "secondary", "arguments": {}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].function.name, "primary");
    }

    #[tokio::test]
    async fn test_whitespace_handling() {
        let parser = JsonParser::new();

        // Extra whitespace everywhere
        let input = r#"  {
            "name"   :   "test"  ,
            "arguments"   :   {
                "key"   :   "value"
            }
        }  "#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].function.name, "test");

        // Minified JSON (no whitespace)
        let input = r#"{"name":"compact","arguments":{"a":1,"b":2}}"#;
        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].function.name, "compact");
    }
}

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

    #[tokio::test]
    async fn test_deeply_nested_arguments() {
        let parser = JsonParser::new();

        // Deeply nested structure
        let input = r#"{
            "name": "nested",
            "arguments": {
                "level1": {
                    "level2": {
                        "level3": {
                            "level4": {
                                "level5": {
                                    "value": "deep"
                                }
                            }
                        }
                    }
                }
            }
        }"#;

        let (_normal_text, tools) = parser.parse_complete(input).await.unwrap();
        assert_eq!(tools.len(), 1);
        assert!(tools[0].function.arguments.contains("deep"));
    }

    #[tokio::test]
    #[expect(
        clippy::disallowed_methods,
        reason = "tokio::spawn is fine in unit tests"
    )]
    async fn test_concurrent_parser_usage() {
        let parser = std::sync::Arc::new(JsonParser::new());

        let mut handles = vec![];

        for i in 0..10 {
            let parser_clone = parser.clone();
            let handle = tokio::spawn(async move {
                let input = format!(r#"{{"name": "func_{i}", "arguments": {{}}}}"#);
                let (_normal_text, tools) = parser_clone.parse_complete(&input).await.unwrap();
                assert_eq!(tools.len(), 1);
                assert_eq!(tools[0].function.name, format!("func_{i}"));
            });
            handles.push(handle);
        }

        for handle in handles {
            handle.await.unwrap();
        }
    }
}

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

    fn create_test_tools() -> Vec<Tool> {
        vec![Tool {
            tool_type: "function".to_string(),
            function: Function {
                name: "get_weather".to_string(),
                description: Some("Get weather information".to_string()),
                parameters: serde_json::json!({
                    "type": "object",
                    "properties": {
                        "city": {"type": "string"},
                        "units": {"type": "string"}
                    }
                }),
                strict: None,
            },
        }]
    }

    #[tokio::test]
    async fn test_qwen_xml_incremental_parameter_streaming() {
        let mut parser = QwenXmlParser::new();
        let tools = create_test_tools();

        let chunks = [
            "<tool_call>",
            r"<function=get_weather>",
            r"<parameter=city>Paris</parameter>",
            r"<parameter=units>metric</parameter>",
            "</function></tool_call>",
        ];

        let mut all_calls = Vec::new();

        // Process each chunk
        for chunk in &chunks {
            let result = parser.parse_incremental(chunk, &tools).await.unwrap();

            for call in &result.calls {
                all_calls.push(call.clone());
            }
        }

        // Verify the final result
        // We should have:
        // 1. Tool name call (from chunk 2)
        // 2. First parameter call: {"city": "Paris"}
        // 3. Second parameter call: , "units": "metric"
        // Final result should be: {"city": "Paris", "units": "metric"}

        assert!(!all_calls.is_empty(), "Should have at least one call");

        // Check that we have the tool name
        let name_call = all_calls.iter().find(|c| c.name.is_some());
        assert!(name_call.is_some(), "Should have tool name call");
        assert_eq!(name_call.unwrap().name.as_ref().unwrap(), "get_weather");

        // Check parameter calls
        let param_calls: Vec<_> = all_calls.iter().filter(|c| c.name.is_none()).collect();
        assert!(!param_calls.is_empty(), "Should have parameter calls");

        // Verify final arguments format by concatenating all parameter fragments
        let params_str: String = param_calls.iter().map(|c| c.parameters.as_str()).collect();

        // Should contain both city and units parameters
        assert!(params_str.contains("city"), "Should contain city parameter");
        assert!(params_str.contains("Paris"), "Should contain Paris value");
        assert!(
            params_str.contains("units"),
            "Should contain units parameter"
        );
        assert!(params_str.contains("metric"), "Should contain metric value");
    }

    #[tokio::test]
    async fn test_qwen_xml_incremental_parameter_streaming_with_partial_values() {
        let mut parser = QwenXmlParser::new();
        let tools = create_test_tools();

        // Test with parameter values that arrive in multiple chunks
        // This tests the buffering logic for partial XML tags
        let chunks = [
            "<tool_call><function=get_weather>",
            r"<parameter=city>Paris</parameter>",
            r"<parameter=units>metric</parameter>",
            "</function></tool_call>",
        ];

        let mut all_calls = Vec::new();

        // Process each chunk
        for chunk in &chunks {
            let result = parser.parse_incremental(chunk, &tools).await.unwrap();

            for call in &result.calls {
                all_calls.push(call.clone());
            }
        }

        // Verify we got the tool name
        let name_call = all_calls.iter().find(|c| c.name.is_some());
        assert!(name_call.is_some(), "Should have tool name call");
        assert_eq!(name_call.unwrap().name.as_ref().unwrap(), "get_weather");

        // Verify we got parameter calls
        let param_calls: Vec<_> = all_calls.iter().filter(|c| c.name.is_none()).collect();
        assert!(!param_calls.is_empty(), "Should have parameter calls");

        // Verify final arguments by concatenating all parameter fragments
        let params_str: String = param_calls.iter().map(|c| c.parameters.as_str()).collect();
        assert!(params_str.contains("city"), "Should contain city parameter");
        assert!(params_str.contains("Paris"), "Should contain Paris value");
    }

    #[tokio::test]
    async fn test_qwen_xml_nested_json_parameter() {
        let mut parser = QwenXmlParser::new();
        let tools = vec![Tool {
            tool_type: "function".to_string(),
            function: Function {
                name: "test_function".to_string(),
                description: None,
                parameters: serde_json::json!({
                    "type": "object",
                    "properties": {
                        "nested": {"type": "object"}
                    }
                }),
                strict: None,
            },
        }];

        let chunks = vec![
            "<tool_call>",
            r"<function=test_function>",
            r#"<parameter=nested>{"key": "value"}</parameter>"#,
            "</function></tool_call>",
        ];

        let mut all_calls = Vec::new();
        for chunk in chunks {
            let result = parser.parse_incremental(chunk, &tools).await.unwrap();
            for call in result.calls {
                all_calls.push(call);
            }
        }

        // Verify nested JSON is parsed correctly via collected calls
        let param_calls: Vec<_> = all_calls.iter().filter(|c| c.name.is_none()).collect();
        assert!(!param_calls.is_empty(), "Should have parameter calls");

        // The first parameter call should contain the nested JSON
        let params_str: String = param_calls.iter().map(|c| c.parameters.as_str()).collect();
        assert!(
            params_str.contains("nested"),
            "Should contain nested parameter"
        );
    }
}

#[cfg(test)]
mod qwen_mapping_tests {
    use crate::factory::ParserFactory;

    #[test]
    fn test_qwen_xml_model_mappings() {
        let factory = ParserFactory::new();
        let registry = factory.registry();

        for model in [
            "Qwen3.5-32B",
            "Qwen/Qwen3.5-4B",
            "qwen3.5-72b",
            "qwen/qwen3.5-32b",
            "Qwen3-Coder-480B",
            "Qwen/Qwen3-Coder-480B-A35B-Instruct",
            "qwen3-coder-7b",
            "qwen/qwen3-coder-32b",
        ] {
            assert_eq!(
                registry.resolve_model_to_parser(model),
                Some("qwen_xml".to_string()),
                "{model} should resolve to qwen_xml"
            );
        }
    }

    #[test]
    fn test_qwen_json_model_mappings() {
        let factory = ParserFactory::new();
        let registry = factory.registry();

        for model in [
            "Qwen2.5-72B-Instruct",
            "Qwen2.5-Coder-32B-Instruct",
            "qwen2.5-coder-7b",
            "Qwen3-32B",
            "Qwen/Qwen3-235B-A22B",
            "qwen3-8b",
        ] {
            assert_eq!(
                registry.resolve_model_to_parser(model),
                Some("qwen".to_string()),
                "{model} should resolve to qwen"
            );
        }
    }
}

#[cfg(test)]
mod minimax_mapping_tests {
    use crate::factory::ParserFactory;

    #[test]
    fn test_minimax_m3_model_mappings() {
        let factory = ParserFactory::new();
        let registry = factory.registry();

        for model in [
            "MiniMaxAI/MiniMax-M3",
            "nvidia/MiniMax-M3-NVFP4",
            "minimax-m3",
            "mm-m3-chat",
        ] {
            assert_eq!(
                registry.resolve_model_to_parser(model),
                Some("minimax_m3".to_string()),
                "{model} should resolve to minimax_m3"
            );
        }

        for model in ["MiniMaxAI/MiniMax-M2", "MiniMax-M2", "minimax-text-01"] {
            assert_eq!(
                registry.resolve_model_to_parser(model),
                Some("minimax_m2".to_string()),
                "{model} should resolve to minimax_m2"
            );
        }
    }
}