use uson::{parse, apply_builtin_types, Value, Number};
use serde_json;

fn parse_and_apply_types(input: &str) -> Vec<Value> {
    let values = parse(input).expect("Parse should succeed");
    values.into_iter().map(apply_builtin_types).collect()
}

fn to_array_mode(values: &[Value]) -> serde_json::Value {
    serde_json::to_value(values).unwrap()
}

fn to_object_mode(values: &[Value]) -> serde_json::Value {
    let mut result = serde_json::Map::new();
    let mut non_object_index = 0;
    
    for value in values.iter() {
        match value {
            Value::Object(obj) => {
                for (key, val) in obj {
                    result.insert(key.clone(), serde_json::to_value(val).unwrap());
                }
            }
            _ => {
                result.insert(non_object_index.to_string(), serde_json::to_value(value).unwrap());
                non_object_index += 1;
            }
        }
    }
    
    serde_json::Value::Object(result)
}

// BASIC TESTS

#[test]
fn test_empty_input() {
    let values = parse_and_apply_types("");
    assert_eq!(to_array_mode(&values), serde_json::json!([]));
    assert_eq!(to_object_mode(&values), serde_json::json!({}));
}

#[test]
fn test_empty_whitespace() {
    let values = parse_and_apply_types("   ");
    assert_eq!(to_array_mode(&values), serde_json::json!([]));
    assert_eq!(to_object_mode(&values), serde_json::json!({}));
}

#[test]
fn test_empty_newlines() {
    let values = parse_and_apply_types("\n          ");
    assert_eq!(to_array_mode(&values), serde_json::json!([]));
    assert_eq!(to_object_mode(&values), serde_json::json!({}));
}

#[test]
fn test_simple_values() {
    let values = parse_and_apply_types("a b c");
    assert_eq!(to_array_mode(&values), serde_json::json!(["a", "b", "c"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "a", "1": "b", "2": "c"}));
}

#[test]
fn test_nested_array_single() {
    let values = parse_and_apply_types("[a]");
    assert_eq!(to_array_mode(&values), serde_json::json!([["a"]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": ["a"]}));
}

#[test]
fn test_nested_array_multiple() {
    let values = parse_and_apply_types("[a b c]");
    assert_eq!(to_array_mode(&values), serde_json::json!([["a", "b", "c"]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": ["a", "b", "c"]}));
}

#[test]
fn test_nested_array_deep() {
    let values = parse_and_apply_types("[a [[b]] c]");
    assert_eq!(to_array_mode(&values), serde_json::json!([["a", [["b"]], "c"]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": ["a", [["b"]], "c"]}));
}

#[test]
fn test_simple_objects() {
    let values = parse_and_apply_types("a:1 b:2 c:3");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}, {"b": 2}, {"c": 3}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1, "b": 2, "c": 3}));
}

#[test]
fn test_simple_objects_in_array() {
    let values = parse_and_apply_types("[a:1 b:2 c:3]");
    assert_eq!(to_array_mode(&values), serde_json::json!([[{"a": 1}, {"b": 2}, {"c": 3}]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [{"a": 1}, {"b": 2}, {"c": 3}]}));
}

#[test]
fn test_type_str() {
    let values = parse_and_apply_types("str!42");
    assert_eq!(to_array_mode(&values), serde_json::json!(["42"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "42"}));
}

#[test]
fn test_type_nested() {
    let values = parse_and_apply_types("int!str!42");
    assert_eq!(to_array_mode(&values), serde_json::json!([42]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42}));
}

#[test]
fn test_type_triple_nested() {
    let values = parse_and_apply_types("str!int!str!42");
    assert_eq!(to_array_mode(&values), serde_json::json!(["42"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "42"}));
}

#[test]
fn test_type_in_object() {
    let values = parse_and_apply_types("x:{test:str!42 multi:bool!str!true}");
    assert_eq!(
        to_array_mode(&values),
        serde_json::json!([{"x": {"test": "42", "multi": true}}])
    );
    assert_eq!(
        to_object_mode(&values),
        serde_json::json!({"x": {"test": "42", "multi": true}})
    );
}

#[test]
fn test_type_str_array() {
    let values = parse_and_apply_types("str![1 2 3]");
    assert_eq!(to_array_mode(&values), serde_json::json!(["1,2,3"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "1,2,3"}));
}

#[test]
fn test_type_nonexistent() {
    let values = parse_and_apply_types("nonexists!42");
    assert_eq!(to_array_mode(&values), serde_json::json!([42]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42}));
}

#[test]
fn test_type_custom_name() {
    let values = parse_and_apply_types("A_b3-!42");
    assert_eq!(to_array_mode(&values), serde_json::json!([42]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42}));
}

#[test]
fn test_advanced_example() {
    let values = parse_and_apply_types(
        r#"number:12.05 text:Banana quotedText:"John Devilseed" empty:null good:true"#
    );
    assert_eq!(
        to_array_mode(&values),
        serde_json::json!([
            {"number": 12.05},
            {"text": "Banana"},
            {"quotedText": "John Devilseed"},
            {"empty": null},
            {"good": true}
        ])
    );
    assert_eq!(
        to_object_mode(&values),
        serde_json::json!({
            "number": 12.05,
            "text": "Banana",
            "quotedText": "John Devilseed",
            "empty": null,
            "good": true
        })
    );
}

// TYPE TESTS

#[test]
fn test_number_integer() {
    let values = parse_and_apply_types("1");
    assert_eq!(to_array_mode(&values), serde_json::json!([1]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 1}));
}

#[test]
fn test_number_float() {
    let values = parse_and_apply_types("42.42");
    assert_eq!(to_array_mode(&values), serde_json::json!([42.42]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42.42}));
}

#[test]
fn test_number_negative() {
    let values = parse_and_apply_types("-50.43");
    assert_eq!(to_array_mode(&values), serde_json::json!([-50.43]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": -50.43}));
}

#[test]
fn test_number_large() {
    let values = parse_and_apply_types("1000000.0001");
    assert_eq!(to_array_mode(&values), serde_json::json!([1000000.0001]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 1000000.0001}));
}

#[test]
fn test_number_scientific() {
    let values = parse_and_apply_types("10e5");
    assert_eq!(to_array_mode(&values), serde_json::json!([10e5]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 10e5}));
}

#[test]
fn test_float_type_cast() {
    let values = parse_and_apply_types(r#"float!"42.42""#);
    assert_eq!(to_array_mode(&values), serde_json::json!([42.42]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42.42}));
}

#[test]
fn test_string_simple() {
    let values = parse_and_apply_types("abc");
    assert_eq!(to_array_mode(&values), serde_json::json!(["abc"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc"}));
}

#[test]
fn test_string_starts_with_digit() {
    let values = parse_and_apply_types("1ab");
    assert_eq!(to_array_mode(&values), serde_json::json!(["1ab"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "1ab"}));
}

#[test]
fn test_string_multiple() {
    let values = parse_and_apply_types("abc def");
    assert_eq!(to_array_mode(&values), serde_json::json!(["abc", "def"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc", "1": "def"}));
}

#[test]
fn test_string_double_quoted() {
    let values = parse_and_apply_types(r#""abc""#);
    assert_eq!(to_array_mode(&values), serde_json::json!(["abc"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc"}));
}

#[test]
fn test_string_double_quoted_with_space() {
    let values = parse_and_apply_types(r#""abc def""#);
    assert_eq!(to_array_mode(&values), serde_json::json!(["abc def"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc def"}));
}

#[test]
fn test_string_double_quoted_escaped() {
    let values = parse_and_apply_types(r#""abc \"ok def""#);
    assert_eq!(to_array_mode(&values), serde_json::json!([r#"abc "ok def"#]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": r#"abc "ok def"#}));
}

#[test]
fn test_string_single_quoted() {
    let values = parse_and_apply_types("'abc'");
    assert_eq!(to_array_mode(&values), serde_json::json!(["abc"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc"}));
}

#[test]
fn test_string_single_quoted_with_space() {
    let values = parse_and_apply_types("'abc def'");
    assert_eq!(to_array_mode(&values), serde_json::json!(["abc def"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc def"}));
}

#[test]
fn test_string_single_quoted_escaped() {
    let values = parse_and_apply_types(r#"'abc \'42 def'"#);
    assert_eq!(to_array_mode(&values), serde_json::json!(["abc '42 def"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc '42 def"}));
}

#[test]
fn test_null_value() {
    let values = parse_and_apply_types("null");
    assert_eq!(to_array_mode(&values), serde_json::json!([null]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": null}));
}

#[test]
fn test_null_typed() {
    let values = parse_and_apply_types("x:null!xx");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"x": null}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"x": null}));
}

#[test]
fn test_true_value() {
    let values = parse_and_apply_types("true");
    assert_eq!(to_array_mode(&values), serde_json::json!([true]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": true}));
}

#[test]
fn test_bool_true_typed() {
    let values = parse_and_apply_types(r#"bool!"true""#);
    assert_eq!(to_array_mode(&values), serde_json::json!([true]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": true}));
}

#[test]
fn test_false_value() {
    let values = parse_and_apply_types("false");
    assert_eq!(to_array_mode(&values), serde_json::json!([false]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": false}));
}

#[test]
fn test_bool_false_typed() {
    let values = parse_and_apply_types(r#"bool!"false""#);
    assert_eq!(to_array_mode(&values), serde_json::json!([false]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": false}));
}

#[test]
fn test_array_single() {
    let values = parse_and_apply_types("[a]");
    assert_eq!(to_array_mode(&values), serde_json::json!([["a"]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": ["a"]}));
}

#[test]
fn test_array_numbers_no_comma() {
    let values = parse_and_apply_types("[1 2 3]");
    assert_eq!(to_array_mode(&values), serde_json::json!([[1, 2, 3]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [1, 2, 3]}));
}

#[test]
fn test_array_numbers_with_commas() {
    let values = parse_and_apply_types("[1, 2, 3]");
    assert_eq!(to_array_mode(&values), serde_json::json!([[1, 2, 3]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [1, 2, 3]}));
}

#[test]
fn test_array_numbers_mixed_commas() {
    let values = parse_and_apply_types("[1 2,3 ]");
    assert_eq!(to_array_mode(&values), serde_json::json!([[1, 2, 3]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [1, 2, 3]}));
}

#[test]
fn test_array_typed() {
    let values = parse_and_apply_types(r#"arr!"1,2,3""#);
    assert_eq!(to_array_mode(&values), serde_json::json!([[1, 2, 3]]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [1, 2, 3]}));
}

#[test]
fn test_object_single() {
    let values = parse_and_apply_types("{a:1}");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
}

#[test]
fn test_object_multiple_no_comma() {
    let values = parse_and_apply_types("{a:1 b:two c:3}");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1, "b": "two", "c": 3}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1, "b": "two", "c": 3}));
}

#[test]
fn test_object_multiple_with_commas() {
    let values = parse_and_apply_types("{a:1,b:two,c:3}");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1, "b": "two", "c": 3}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1, "b": "two", "c": 3}));
}

#[test]
fn test_object_typed() {
    let values = parse_and_apply_types(r#"obj!'"a":1'"#);
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
}

#[test]
fn test_object_nested() {
    let values = parse_and_apply_types("x:{a:1 b:coffee}");
    assert_eq!(
        to_array_mode(&values),
        serde_json::json!([{"x": {"a": 1, "b": "coffee"}}])
    );
    assert_eq!(
        to_object_mode(&values),
        serde_json::json!({"x": {"a": 1, "b": "coffee"}})
    );
}

#[test]
fn test_assign_simple() {
    let values = parse_and_apply_types("a:1");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
}

#[test]
fn test_assign_multiple() {
    let values = parse_and_apply_types("a:1 b:2 c:3");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}, {"b": 2}, {"c": 3}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1, "b": 2, "c": 3}));
}

#[test]
fn test_assign_single_quoted_key() {
    let values = parse_and_apply_types("'a':1");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
}

#[test]
fn test_assign_double_quoted_key() {
    let values = parse_and_apply_types(r#""a":1"#);
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
}

#[test]
fn test_assign_special_chars() {
    let values = parse_and_apply_types("~@$%^&*()-:1");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"~@$%^&*()-": 1}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"~@$%^&*()-": 1}));
}

#[test]
fn test_comment_empty() {
    let values = parse_and_apply_types("#");
    assert_eq!(to_array_mode(&values), serde_json::json!([]));
    assert_eq!(to_object_mode(&values), serde_json::json!({}));
}

#[test]
fn test_comment_escaped_hash() {
    let values = parse_and_apply_types(r"a:\#");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": "#"}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": "#"}));
}

#[test]
fn test_comment_in_quotes() {
    let values = parse_and_apply_types(r"a:'\#1'");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": "#1"}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": "#1"}));
}

#[test]
fn test_comment_after_value() {
    let values = parse_and_apply_types("a:1 # a");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
}

#[test]
fn test_comment_with_spaces() {
    let values = parse_and_apply_types("  # a");
    assert_eq!(to_array_mode(&values), serde_json::json!([]));
    assert_eq!(to_object_mode(&values), serde_json::json!({}));
}

#[test]
fn test_comment_line_start() {
    let values = parse_and_apply_types("#a");
    assert_eq!(to_array_mode(&values), serde_json::json!([]));
    assert_eq!(to_object_mode(&values), serde_json::json!({}));
}

#[test]
fn test_comment_in_array() {
    let values = parse_and_apply_types("x: [a # b c]\n# good\n tone ]");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"x": ["a", "tone"]}]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"x": ["a", "tone"]}));
}

#[test]
fn test_comment_complex() {
    let values = parse_and_apply_types("{x: [#y ]\n] #n\n} 42 #^\n@");
    assert_eq!(to_array_mode(&values), serde_json::json!([{"x": []}, 42, "@"]));
    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42, "1": "@", "x": []}));
}