use parser_combinator::primitives::literal;
use parser_combinator::testutil::{
    json_array, json_bool, json_null, json_number, json_object, json_string, JsonValue,
};
use parser_combinator::{Parser, Representation};

use proptest::prelude::*;

use rstest::*;

proptest! {
    #[test]
    fn doesnt_crash(s in "\\PC*") {
        let _output = json_object().parse(&s);
    }

    #[test]
    fn parse_string(s in r#"[^"]+"#) {
        let input = format!("\"{}\"", s);
        let output = json_string().parse(&input).unwrap();
        match output {
            (JsonValue::Str(output_s), "") if output_s == s => (),
            _ => panic!(),
        }
    }
}

#[test]
fn test_parsing() {
    let output = literal("a").parse("a yolo");
    assert_eq!(output.unwrap(), ("a", " yolo"));
}

#[test]
fn parse_json_primitives() {
    assert_eq!(
        json_string().parse(r#""yolo swagg""#).unwrap(),
        (JsonValue::Str("yolo swagg".into()), "")
    );

    assert_eq!(
        json_number().parse("-383").unwrap().0,
        JsonValue::Num(-383f64)
    );
    assert_eq!(
        json_number().parse("-.383").unwrap().0,
        JsonValue::Num(-0.383)
    );
    assert_eq!(
        json_number().parse(".383").unwrap().0,
        JsonValue::Num(0.383)
    );
    assert_eq!(
        json_number().parse("-1.383").unwrap().0,
        JsonValue::Num(-1.383)
    );
}

#[rstest]
#[case(r#"[ 4, 9, "ara",]"#)]
fn parse_json_array_err(#[case] input: &str) {
    assert!(json_array().parse(input).is_err());
}

#[rstest]
#[case("[[],[]]", (JsonValue::Array(vec![JsonValue::Array(vec![]), JsonValue::Array(vec![])]), ""))]
#[case(r#"[  4,   9,   "foo"   ]"#, (
            JsonValue::Array(vec![
                JsonValue::Num(4.),
                JsonValue::Num(9.0),
                JsonValue::Str("foo".to_string())
            ]),
            ""
        ))]
#[case(r#"[8,null,[],5],{}"#,
        (
            JsonValue::Array(vec![
                JsonValue::Num(8.),
                JsonValue::Null,
                JsonValue::Array(vec![]),
                JsonValue::Num(5.),
            ]),
            ",{}"
        ))]
fn parse_json_array(#[case] input: &str, #[case] expected: (JsonValue, &str)) {
    assert_eq!(json_array().parse(input).unwrap(), expected);
}

#[test]
fn parse_json_object() {
    assert_eq!(
        json_object().parse(r#"{ "a": 23}"#).unwrap().0,
        JsonValue::Object(vec![("a".into(), JsonValue::Num(23.))])
    );
    assert_eq!(
        json_object().parse(r#"{}"#).unwrap().0,
        JsonValue::Object(vec![])
    );
}

#[test]
fn parse_json_document() {
    let test_json = include_str!("joplin-cfg.json");
    let parsed_json = json_object().parse(test_json);
    assert!(parsed_json.is_ok());
}

#[rstest]
#[case(json_null().representation(), Representation::new("null"))]
#[case(json_bool().representation(), Representation::new("true | false"))]
#[case(json_number().representation(), Representation::new("- | ε (1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | )+ . (1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | )+ | ε | . (1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | )+"))]
fn representations_test(
    #[case] parser_representation: Representation,
    #[case] expected: Representation,
) {
    assert_eq!(parser_representation, expected);
}