use parser_combinator::choice::choice;
use parser_combinator::combinators::repeated;
use parser_combinator::primitives::{any_char, literal, literal_char, one_of, pred};
use parser_combinator::sequence::seq;
use parser_combinator::Parser;

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

/*
    * JSON BNF
    * <JSON>     ::= <value>
<value>    ::= <object> | <array> | <boolean> | <string> | <number> | <null>
<array>    ::= "[" [<value>] {"," <value>}* "]"
<object>   ::= "{" [<property>] {"," <property>}* "}"
<property> ::= <string> ":" <value>
*/
#[derive(Debug, Clone, PartialEq)]
enum JsonValue {
    Null,
    Bool(bool),
    Str(String),
    Num(f64),
    Array(Vec<JsonValue>),
    Object(Vec<(String, JsonValue)>),
}

trait JsonParser<'a, T>: Parser<&'a str, T, &'a str> {}
impl<'a, T, P> JsonParser<'a, T> for P where P: Parser<&'a str, T, &'a str> {}

fn json_null<'a>() -> impl JsonParser<'a, JsonValue> {
    literal("null").to(JsonValue::Null)
}
fn json_bool<'a>() -> impl JsonParser<'a, JsonValue> {
    choice((
        literal("true").to(JsonValue::Bool(true)),
        literal("false").to(JsonValue::Bool(false)),
    ))
}

fn json_number() -> impl JsonParser<'static, JsonValue> {
    let digit = || one_of("1234567890");
    let digits = || repeated(digit()).at_least(1);

    let json_number_inner = choice((
        seq((digits(), literal(".").ignore_then(digits()).optional())).map(
            |(mut digits, maybe_decimal)| {
                if let Some(decimal_digits) = maybe_decimal {
                    digits.push(".");
                    digits.extend(decimal_digits.into_iter());
                }
                digits.into_iter().collect::<String>()
            },
        ),
        literal(".").ignore_then(digits()).map(|decimal_digits| {
            let mut d = vec!["."];
            d.extend(decimal_digits.into_iter());
            d.into_iter().collect::<String>()
        }),
    ))
    .map(|digits| digits.parse::<f64>().unwrap());

    literal("-")
        .optional()
        .then(json_number_inner)
        .map(|(maybe_sign, mut val)| {
            if maybe_sign.is_some() {
                val *= -1.0;
            }
            JsonValue::Num(val)
        })
}

fn json_string_raw() -> impl JsonParser<'static, String> {
    seq((
        literal_char('"'),
        repeated(pred(any_char, |ch| *ch != '"')),
        literal_char('"'),
    ))
    .map(|(_, s, _)| s.iter().cloned().collect::<String>())
}

fn json_string() -> impl JsonParser<'static, JsonValue> {
    json_string_raw().map(JsonValue::Str)
}

fn whitespace() -> impl JsonParser<'static, ()> {
    repeated(choice((
        literal_char('\t'),
        literal_char('\n'),
        literal_char(' '),
    )))
    .to(())
}

fn json_array() -> impl JsonParser<'static, JsonValue> {
    move |input| {
        let val = json_value().surrounded_by(whitespace());

        repeated(val)
            .separated_by(literal(","), false)
            .delimited(literal_char('['), literal_char(']'))
            .map(JsonValue::Array)
            .parse(input)
    }
}

fn json_object() -> impl JsonParser<'static, JsonValue> {
    move |input| {
        let kv = json_string_raw()
            .surrounded_by(whitespace())
            .then_ignore(literal_char(':'))
            .then(json_value().surrounded_by(whitespace()));

        repeated(kv)
            .separated_by(literal_char(','), false)
            .delimited(literal_char('{'), literal_char('}'))
            .map(JsonValue::Object)
            .parse(input)
    }
}

fn json_value() -> impl JsonParser<'static, JsonValue> {
    choice((
        json_null(),
        json_bool(),
        json_number(),
        json_string(),
        json_array(),
        json_object(),
    ))
}

#[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)
    );
}

#[test]
fn parse_json_array() {
    assert!(json_array().parse(r#"[ 4, 9, "ara",]"#).is_err());
    assert_eq!(
        json_array().parse("[[],[]]").unwrap().0,
        JsonValue::Array(vec![JsonValue::Array(vec![]), JsonValue::Array(vec![])])
    );
    assert_eq!(
        json_array().parse(r#"[  4,   9,   "foo"   ]"#).unwrap(),
        (
            JsonValue::Array(vec![
                JsonValue::Num(4.),
                JsonValue::Num(9.0),
                JsonValue::Str("foo".to_string())
            ]),
            ""
        )
    );
    assert_eq!(
        json_array().parse(r#"[8,null,[],5],{}"#).unwrap(),
        (
            JsonValue::Array(vec![
                JsonValue::Num(8.),
                JsonValue::Null,
                JsonValue::Array(vec![]),
                JsonValue::Num(5.),
            ]),
            ",{}"
        )
    );
    assert_eq!(json_value().parse("true"), Ok((JsonValue::Bool(true), "")));
}

#[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() {
    let test_json = include_str!("joplin-cfg.json");
    let parsed_json = json_object().parse(test_json);
    assert!(parsed_json.is_ok());
}