#[macro_use]
extern crate json;

use json::{ parse, JsonValue, JsonError, Null };

#[test]
fn is_as_string() {
    let string = JsonValue::from("foo");

    assert!(string.is_string());
    assert_eq!(string.as_str().unwrap(), "foo");
}

#[test]
fn is_as_number() {
    let number = JsonValue::from(42);

    assert!(number.is_number());
    assert_eq!(number.as_f64().unwrap(), 42.0f64);
    assert_eq!(number.as_f32().unwrap(), 42.0f32);
    assert_eq!(number.as_u64().unwrap(), 42u64);
    assert_eq!(number.as_u32().unwrap(), 42u32);
    assert_eq!(number.as_u16().unwrap(), 42u16);
    assert_eq!(number.as_u8().unwrap(), 42u8);
    assert_eq!(number.as_usize().unwrap(), 42usize);
    assert_eq!(number.as_i64().unwrap(), 42i64);
    assert_eq!(number.as_i32().unwrap(), 42i32);
    assert_eq!(number.as_i16().unwrap(), 42i16);
    assert_eq!(number.as_i8().unwrap(), 42i8);
    assert_eq!(number.as_isize().unwrap(), 42isize);

    let number = JsonValue::from(-1);

    assert_eq!(number.as_u64(), None);
    assert_eq!(number.as_u32(), None);
    assert_eq!(number.as_u16(), None);
    assert_eq!(number.as_u8(), None);
    assert_eq!(number.as_usize(), None);
    assert_eq!(number.as_i64(), Some(-1));
    assert_eq!(number.as_i32(), Some(-1));
    assert_eq!(number.as_i16(), Some(-1));
    assert_eq!(number.as_i8(), Some(-1));
    assert_eq!(number.as_isize(), Some(-1));

    let number = JsonValue::from(40_000);

    assert_eq!(number.as_u8(), None);
    assert_eq!(number.as_u16(), Some(40_000));
    assert_eq!(number.as_i8(), None);
    assert_eq!(number.as_i16(), None);
    assert_eq!(number.as_i32(), Some(40_000));
}

#[test]
fn as_fixed_point() {
    let number = JsonValue::from(3.14);

    assert_eq!(number.as_fixed_point_u64(4).unwrap(), 31400_u64);
    assert_eq!(number.as_fixed_point_u64(2).unwrap(), 314_u64);
    assert_eq!(number.as_fixed_point_u64(0).unwrap(), 3_u64);

    assert_eq!(number.as_fixed_point_i64(4).unwrap(), 31400_i64);
    assert_eq!(number.as_fixed_point_i64(2).unwrap(), 314_i64);
    assert_eq!(number.as_fixed_point_i64(0).unwrap(), 3_i64);

    let number = JsonValue::from(-3.14);

    assert_eq!(number.as_fixed_point_u64(4), None);
    assert_eq!(number.as_fixed_point_u64(2), None);
    assert_eq!(number.as_fixed_point_u64(0), None);

    assert_eq!(number.as_fixed_point_i64(4).unwrap(), -31400_i64);
    assert_eq!(number.as_fixed_point_i64(2).unwrap(), -314_i64);
    assert_eq!(number.as_fixed_point_i64(0).unwrap(), -3_i64);
}

#[test]
fn is_as_boolean() {
    let boolean = JsonValue::Boolean(true);

    assert!(boolean.is_boolean());
    assert_eq!(boolean.as_bool().unwrap(), true);
}

#[test]
fn is_true() {
    let boolean = JsonValue::Boolean(true);

    assert_eq!(boolean, true);
}

#[test]
fn is_false() {
    let boolean = JsonValue::Boolean(false);

    assert_eq!(boolean, false);
}

#[test]
fn is_null() {
    let null = JsonValue::Null;

    assert!(null.is_null());
}

#[test]
fn is_empty() {
    assert!(Null.is_empty());
    assert!(json::from(0).is_empty());
    assert!(json::from("").is_empty());
    assert!(json::from(false).is_empty());
    assert!(array![].is_empty());
    assert!(object!{}.is_empty());

    assert!(!json::from(1).is_empty());
    assert!(!json::from("foo").is_empty());
    assert!(!json::from(true).is_empty());
    assert!(!array![0].is_empty());
    assert!(!object!{ "foo" => false }.is_empty());
}

#[test]
fn array_len() {
    let data = array![0, 1, 2, 3];

    assert_eq!(data.len(), 4);
}

#[test]
fn array_contains() {
    let data = array![true, Null, 3.14, "foo"];

    assert!(data.contains(true));
    assert!(data.contains(Null));
    assert!(data.contains(3.14));
    assert!(data.contains("foo"));

    assert!(!data.contains(false));
    assert!(!data.contains(42));
    assert!(!data.contains("bar"));
}

#[test]
fn array_push() {
    let mut data = array![1, 2];

    data.push(3).unwrap();

    assert_eq!(data, array![1, 2, 3]);
}

#[test]
fn array_pop() {
    let mut data = array![1, 2, 3];

    assert_eq!(data.pop(), 3);
    assert_eq!(data, array![1, 2]);
}

#[test]
fn array_remove() {
    let mut data = array![1, 2, 3];

    assert_eq!(data.array_remove(1), 2);
    assert_eq!(data, array![1, 3]);
    // Test with index out of bounds
    assert_eq!(data.array_remove(2), JsonValue::Null);
}

#[test]
fn array_members() {
    let data = array![1, "foo"];

    for member in data.members() {
        assert!(!member.is_null());
    }

    let mut members = data.members();

    assert_eq!(members.next().unwrap(), 1);
    assert_eq!(members.next().unwrap(), "foo");
    assert!(members.next().is_none());
}

#[test]
fn array_members_rev() {
    let data = array![1, "foo"];

    for member in data.members() {
        assert!(!member.is_null());
    }

    let mut members = data.members().rev();

    assert_eq!(members.next().unwrap(), "foo");
    assert_eq!(members.next().unwrap(), 1);
    assert!(members.next().is_none());
}

#[test]
fn array_members_mut() {
    let mut data = array![Null, Null];

    for member in data.members_mut() {
        assert!(member.is_null());
        *member = 100.into();
    }

    assert_eq!(data, array![100, 100]);
}

#[test]
fn array_members_mut_rev() {
    let mut data = array![Null, Null];
    let mut item = 100;

    for member in data.members_mut().rev() {
        assert!(member.is_null());
        *member = item.into();
        item += 1;
    }

    assert_eq!(data, array![item - 1, item - 2]);
}

#[test]
fn object_len() {
    let data = object!{
        "a" => true,
        "b" => false
    };

    assert_eq!(data.len(), 2);
}

#[test]
fn object_remove() {
    let mut data = object!{
        "foo" => "bar",
        "answer" => 42
    };

    assert_eq!(data.remove("foo"), "bar");
    assert_eq!(data, object!{ "answer" => 42 });
}

#[test]
fn object_entries() {
    let data = object!{
        "a" => 1,
        "b" => "foo"
    };

    for (_, value) in data.entries() {
        assert!(!value.is_null());
    }

    let mut entries = data.entries();

    let (key, value) = entries.next().unwrap();
    assert_eq!(key, "a");
    assert_eq!(value, 1);

    let (key, value) = entries.next().unwrap();
    assert_eq!(key, "b");
    assert_eq!(value, "foo");

    assert!(entries.next().is_none());
}

#[test]
fn object_entries_rev() {
    let data = object!{
        "a" => 1,
        "b" => "foo"
    };

    for (_, value) in data.entries().rev() {
        assert!(!value.is_null());
    }

    let mut entries = data.entries().rev();

    let (key, value) = entries.next().unwrap();
    assert_eq!(key, "b");
    assert_eq!(value, "foo");

    let (key, value) = entries.next().unwrap();
    assert_eq!(key, "a");
    assert_eq!(value, 1);

    assert!(entries.next().is_none());
}

#[test]
fn object_entries_mut() {
    let mut data = object!{
        "a" => Null,
        "b" => Null
    };

    for (_, value) in data.entries_mut() {
        assert!(value.is_null());
        *value = 100.into();
    }

    assert_eq!(data, object!{
        "a" => 100,
        "b" => 100
    });
}

#[test]
fn object_entries_mut_rev() {
    let mut data = object!{
        "a" => Null,
        "b" => Null
    };
    let mut item = 100;

    for (_, value) in data.entries_mut().rev() {
        assert!(value.is_null());
        *value = item.into();
        item += 1;
    }

    assert_eq!(data, object!{
        "a" => item - 1,
        "b" => item - 2
    });
}

#[test]
fn object_dump_minified() {
    let object = object!{
        "name" => "Maciej",
        "age" => 30
    };

    assert_eq!(object.dump(), "{\"name\":\"Maciej\",\"age\":30}");
}

#[test]
fn object_dump_pretty() {
    let object = object!{
        "name" => "Urlich",
        "age" => 50,
        "parents" => object!{
            "mother" => "Helga",
            "father" => "Brutus"
        },
        "cars" => array![ "Golf", "Mercedes", "Porsche" ]
    };

    assert_eq!(object.pretty(2),
               "{\n  \"name\": \"Urlich\",\n  \"age\": 50,\n  \"parents\": {\n    \"mother\": \"Helga\",\n    \"father\": \"Brutus\"\n  },\n  \"cars\": [\n    \"Golf\",\n    \"Mercedes\",\n    \"Porsche\"\n  ]\n}");
}

#[test]
fn null_len() {
    let data = json::Null;

    assert_eq!(data.len(), 0);
}

#[test]
fn index_by_str() {
    let data = object!{
        "foo" => "bar"
    };

    assert_eq!(data["foo"], "bar");
}

#[test]
fn index_by_string() {
    let data = object!{
        "foo" => "bar"
    };

    assert_eq!(data["foo".to_string()], "bar");
}

#[test]
fn index_by_string_ref() {
    let data = object!{
        "foo" => "bar"
    };

    let key = "foo".to_string();
    let ref key_ref = key;

    assert_eq!(data[key_ref], "bar");
}

#[test]
fn index_mut_by_str() {
    let mut data = object!{
        "foo" => Null
    };

    data["foo"] = "bar".into();

    assert_eq!(data["foo"], "bar");
}

#[test]
fn index_mut_by_string() {
    let mut data = object!{
        "foo" => Null
    };

    data["foo".to_string()] = "bar".into();

    assert_eq!(data["foo"], "bar");
}

#[test]
fn index_mut_by_string_ref() {
    let mut data = object!{
        "foo" => Null
    };

    let key = "foo".to_string();
    let ref key_ref = key;

    data[key_ref] = "bar".into();

    assert_eq!(data["foo"], "bar");
}

#[test]
fn object_index_by_str() {
    let val = object!{
        "foo" => "bar"
    };
    if let JsonValue::Object(data) = val {
        assert_eq!(data["foo"], "bar");
    }
}

#[test]
fn object_index_by_string() {
    let val = object!{
        "foo" => "bar"
    };

    if let JsonValue::Object(data) = val {
        assert_eq!(data["foo".to_string()], "bar");
    }
}

#[test]
fn object_index_by_string_ref() {
    let val = object!{
        "foo" => "bar"
    };

    let key = "foo".to_string();
    let ref key_ref = key;

    if let JsonValue::Object(data) = val {
        assert_eq!(data[key_ref], "bar");
    }
}

#[test]
fn object_index_mut_by_str() {
    let val = object!{
        "foo" => Null
    };

    if let JsonValue::Object(mut data) = val {
        data["foo"] = "bar".into();

        assert_eq!(data["foo"], "bar");
    }
}

#[test]
fn object_index_mut_by_string() {
    let val = object!{
        "foo" => Null
    };

    if let JsonValue::Object(mut data) = val {
        data["foo".to_string()] = "bar".into();

        assert_eq!(data["foo"], "bar");
    }
}

#[test]
fn object_index_mut_by_string_ref() {
    let val = object!{
        "foo" => Null
    };

    let key = "foo".to_string();
    let ref key_ref = key;

    if let JsonValue::Object(mut data) = val {
        data[key_ref] = "bar".into();

        assert_eq!(data["foo"], "bar");
    }
}

#[test]
fn fmt_string() {
    let data: JsonValue = "foobar".into();

    assert_eq!(format!("{}", data), "foobar");
    assert_eq!(format!("{:#}", data), r#""foobar""#);
}

#[test]
fn fmt_number() {
    let data: JsonValue = 42.into();

    assert_eq!(format!("{}", data), "42");
    assert_eq!(format!("{:#}", data), "42");
}

#[test]
fn fmt_boolean() {
    let data: JsonValue = true.into();

    assert_eq!(format!("{}", data), "true");
    assert_eq!(format!("{:#}", data), "true");
}

#[test]
fn fmt_null() {
    let data = Null;

    assert_eq!(format!("{}", data), "null");
    assert_eq!(format!("{:#}", data), "null");
}

#[test]
fn fmt_array() {
    let data = array![1, true, "three"];

    assert_eq!(format!("{}", data), r#"[1,true,"three"]"#);
    assert_eq!(format!("{:#}", data), "[\n    1,\n    true,\n    \"three\"\n]");
}

#[test]
fn fmt_object() {
    let data = object!{
        "foo" => "bar",
        "answer" => 42
    };

    assert_eq!(format!("{}", data), r#"{"foo":"bar","answer":42}"#);
    assert_eq!(format!("{:#}", data), "{\n    \"foo\": \"bar\",\n    \"answer\": 42\n}");
}

#[test]
fn error_unexpected_character() {
    let err = parse("\n\nnulX\n").unwrap_err();

    assert_eq!(err, JsonError::UnexpectedCharacter {
        ch: 'X',
        line: 3,
        column: 4,
    });

    assert_eq!(format!("{}", err), "Unexpected character: X at (3:4)");
}

#[test]
fn error_unexpected_unicode_character() {
    let err = parse("\n\nnul🦄\n").unwrap_err();

    assert_eq!(err, JsonError::UnexpectedCharacter {
        ch: '🦄',
        line: 3,
        column: 4,
    });

    assert_eq!(format!("{}", err), "Unexpected character: 🦄 at (3:4)");
}

#[test]
fn error_unexpected_token() {
    let err = parse("\n  [\n    null,\n  ]  \n").unwrap_err();

    assert_eq!(err, JsonError::UnexpectedCharacter {
        ch: ']',
        line: 4,
        column: 3,
    });

    assert_eq!(format!("{}", err), "Unexpected character: ] at (4:3)");
}

#[test]
fn writer_generator() {
    let data = object!{
        "foo" => array!["bar", 100, true]
    };

    let mut buf = Vec::new();

    data.write(&mut buf).expect("Can't fail with a Vec");

    assert_eq!(String::from_utf8(buf).unwrap(), r#"{"foo":["bar",100,true]}"#);
}

#[test]
fn pretty_writer_generator() {
    let data = object!{
        "foo" => array!["bar", 100, true]
    };

    let mut buf = Vec::new();

    data.write_pretty(&mut buf, 4).expect("Can't fail with a Vec");

    assert_eq!(String::from_utf8(buf).unwrap(), "{\n    \"foo\": [\n        \"bar\",\n        100,\n        true\n    ]\n}");
}

#[test]
fn equality() {
    let left = object!{
        "foo" => array!["bar", 100, true]
    };

    let left_copy = object!{
        "foo" => array!["bar", 100, true]
    };

    let left_string = object!{
        "foo" => array![JsonValue::String("bar".to_string()), 100, true]
    };

    let left_short = object!{
        "foo" => array![JsonValue::Short(unsafe { json::short::Short::from_slice("bar") }), 100, true]
    };

    let change_bool = object!{
        "foo" => array!["bar", 100, false]
    };

    let change_string = object!{
        "foo" => array![JsonValue::String("sna".to_string()), 100, true]
    };

    let change_short = object!{
        "foo" => array![JsonValue::Short(unsafe { json::short::Short::from_slice("sna") }), 100, true]
    };

    assert_eq!(left, left_copy);
    assert_eq!(left, left_string);
    assert_eq!(left, left_short);
    assert_ne!(left, change_bool);
    assert_ne!(left, change_string);
    assert_ne!(left, change_short);
}