#[derive(PartialEq, Eq, PartialOrd, Ord)]

pub(crate) fn read_index(index_ttl: &index_path::IndexPath) -> Result<Vec<IndexEntry>, MyError> {

    println!("{}", index_ttl.as_ref().display());

    let rdf = std::fs::read_to_string(index_ttl)

        .map_err(|e| MyError::io_error(index_ttl.to_path_buf(), e))?;

    let base: Iri<String> = Iri::new("http://example.com/".to_string())?;

    let parser = TurtleParser { base: Some(base) };

    let mut source = parser.parse_str(&rdf);

    let mut entries = Vec::new();

    let ldp = Namespace::new("http://www.w3.org/ns/ldp#")?;

    let ldp_contains = ldp.get("contains")?;

    source

        .for_each_triple(|t| {

            let p = t.p();

            if ldp_contains.eq(&p) {

                entries.push(IndexEntry {

                    name: t.s().to_string(),

                    base_uri: None,

                });

            }

        })

        .map_err(MyError::format_error)?;

    Ok(entries)

}

pub fn write_index(path: &Path, entries: &[IndexEntry]) -> Result<(), Box<dyn Error>> {

    let index_path = IndexPath::try_from(path)?;

    let mut graph = LightGraph::new();

    let local = Namespace::new("")?;

    let ldp = Namespace::new("http://www.w3.org/ns/ldp#")?;

    let ldp_container = ldp.get("Container")?;

    let ldpc = local.get("")?;

    let ldp_contains = ldp.get("contains")?;

    graph.insert(ldpc, type_, ldp_container)?;

    for entry in entries {

        graph.insert(ldpc, ldp_contains, local.get(&entry.name)?)?;

    let mut stringifier = TurtleSerializer::new_stringifier();

    let rdf = stringifier.serialize_graph(&graph)?.as_str();

    std::fs::write(index_path.as_ref(), rdf)?;

    println!("wrote {}", index_path.as_ref().display());

    Ok(())

}

pub fn read_entries(path: &Path) -> Result<Vec<IndexEntry>, Box<dyn Error>> {

    let index_path = IndexPath::try_from(path)?;

    let mut names = Vec::new();

    for name in index_path.files()? {

        names.push(IndexEntry {

            name,

            base_uri: None,

        });

    }

    Ok(names)

}

pub fn check_index(path: &Path) -> Result<(), Box<dyn Error>> {

    let index_path = IndexPath::try_from(path)?;

    read_index(&index_path)?;

    Ok(())

}