use rio_api::formatter::{QuadsFormatter, TriplesFormatter};
use rio_api::model::*;
use rio_api::parser::*;
use rio_turtle::*;
use std::io::Cursor;

#[test]
fn ntriples_roundtrip() -> Result<(), TurtleError> {
    let graph = example_graph(true);

    let mut formatter = NTriplesFormatter::new(Vec::default());
    for t in &graph {
        formatter.format(t)?;
    }
    let nt = formatter.finish()?;

    let mut count = 0;
    NTriplesParser::new(Cursor::new(&nt)).parse_all(&mut |_| {
        count += 1;
        Ok(()) as Result<(), TurtleError>
    })?;

    assert_eq!(count, graph.len());

    Ok(())
}

#[test]
fn nquads_roundtrip() -> Result<(), TurtleError> {
    let dataset = example_dataset(true);

    let mut formatter = NQuadsFormatter::new(Vec::default());
    for q in &dataset {
        formatter.format(q)?;
    }
    let nt = formatter.finish()?;

    let mut count = 0;
    NQuadsParser::new(Cursor::new(&nt)).parse_all(&mut |_| {
        count += 1;
        Ok(()) as Result<(), TurtleError>
    })?;

    assert_eq!(count, dataset.len());

    Ok(())
}

#[test]
fn turtle_roundtrip() -> Result<(), TurtleError> {
    let graph = example_graph(true);

    let mut formatter = TurtleFormatter::new(Vec::default());
    for t in &graph {
        formatter.format(t)?;
    }
    let turtle = formatter.finish()?;

    let mut count = 0;
    TurtleParser::new(Cursor::new(&turtle), None).parse_all(&mut |_| {
        count += 1;
        Ok(()) as Result<(), TurtleError>
    })?;

    assert_eq!(count, graph.len());

    Ok(())
}

#[test]
fn trig_roundtrip() -> Result<(), TurtleError> {
    let dataset = example_dataset(true);

    let mut formatter = TriGFormatter::new(Vec::default());
    for q in &dataset {
        formatter.format(q)?;
    }
    let trig = formatter.finish()?;

    let mut count = 0;
    TriGParser::new(Cursor::new(&trig), None).parse_all(&mut |_| {
        count += 1;
        Ok(()) as Result<(), TurtleError>
    })?;

    assert_eq!(count, dataset.len());

    Ok(())
}

#[cfg(feature = "generalized")]
#[test]
fn gtrig_roundtrip() -> Result<(), TurtleError> {
    let dataset = example_dataset(false);

    let mut formatter = TriGFormatter::new(Vec::default());
    for q in &dataset {
        formatter.format(q)?;
    }
    let trig = formatter.finish()?;

    let mut count = 0;
    GTriGParser::new(Cursor::new(&trig), None).parse_all(&mut |_| {
        count += 1;
        Ok(()) as Result<(), TurtleError>
    })?;

    assert_eq!(count, dataset.len());

    Ok(())
}

const TRIPLE: Triple<'static> = Triple {
    subject: Subject::NamedNode(NamedNode {
        iri: "http://example.com/s",
    }),
    predicate: NamedNode {
        iri: "http://example.com/p",
    },
    object: Term::NamedNode(NamedNode {
        iri: "http://example.com/o",
    }),
};

fn example_graph(rdf_star: bool) -> Vec<Triple<'static>> {
    let foo_node = NamedNode {
        iri: "http://example.com/foo",
    };
    let bar_node = NamedNode {
        iri: "http://example.com/bar",
    };
    let bnode = BlankNode { id: "foobar" };
    let simple = Literal::Simple { value: "simp\"le" };
    let language = Literal::LanguageTaggedString {
        value: "sim\"le",
        language: "en",
    };
    let datatype = Literal::Typed {
        value: "sim\"le",
        datatype: NamedNode {
            iri: "http://example.com/dt",
        },
    };
    let mut triples = vec![
        Triple {
            subject: foo_node.into(),
            predicate: bar_node,
            object: bar_node.into(),
        },
        Triple {
            subject: foo_node.into(),
            predicate: bar_node,
            object: bnode.into(),
        },
        Triple {
            subject: foo_node.into(),
            predicate: bar_node,
            object: simple.into(),
        },
        Triple {
            subject: foo_node.into(),
            predicate: bar_node,
            object: language.into(),
        },
        Triple {
            subject: foo_node.into(),
            predicate: foo_node,
            object: datatype.into(),
        },
        Triple {
            subject: bar_node.into(),
            predicate: bar_node,
            object: bar_node.into(),
        },
    ];
    if rdf_star {
        triples.push(Triple {
            subject: (&TRIPLE).into(),
            predicate: bar_node,
            object: simple.into(),
        });
        triples.push(Triple {
            subject: foo_node.into(),
            predicate: bar_node,
            object: (&TRIPLE).into(),
        });
    }
    triples
}

fn example_dataset(rdf_star: bool) -> Vec<Quad<'static>> {
    example_graph(rdf_star)
        .into_iter()
        .flat_map(|t| {
            vec![
                Quad {
                    subject: t.subject,
                    predicate: t.predicate,
                    object: t.object,
                    graph_name: None,
                },
                Quad {
                    subject: t.subject,
                    predicate: t.predicate,
                    object: t.object,
                    graph_name: Some(
                        NamedNode {
                            iri: "http://example/",
                        }
                        .into(),
                    ),
                },
            ]
            .into_iter()
        })
        .collect()
}