/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.rdf.rdf4j;

import java.util.Arrays;
import java.util.EnumSet;
import java.util.Objects;
import java.util.Set;
import java.util.UUID;

// To avoid confusion, avoid importing
// classes that are in both
// commons.rdf and openrdf.model (e.g. IRI, Literal)
import org.apache.commons.rdf.api.BlankNode;
import org.apache.commons.rdf.api.BlankNodeOrIRI;
import org.apache.commons.rdf.api.Dataset;
import org.apache.commons.rdf.api.Graph;
import org.apache.commons.rdf.api.Quad;
import org.apache.commons.rdf.api.RDFTerm;
import org.apache.commons.rdf.api.RDF;
import org.apache.commons.rdf.api.Triple;
import org.apache.commons.rdf.api.TripleLike;
import org.apache.commons.rdf.rdf4j.impl.InternalRDF4JFactory;
import org.eclipse.rdf4j.model.BNode;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Literal;
import org.eclipse.rdf4j.model.Model;
import org.eclipse.rdf4j.model.Resource;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.impl.LinkedHashModel;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.repository.Repository;
import org.eclipse.rdf4j.repository.RepositoryConnection;
import org.eclipse.rdf4j.repository.sail.SailRepository;
import org.eclipse.rdf4j.sail.Sail;
import org.eclipse.rdf4j.sail.memory.MemoryStore;

/**
 * RDF4J implementation of RDF.
 * <p>
 * The {@link #RDF4J()} constructor uses a {@link SimpleValueFactory} to create
 * corresponding RDF4J {@link Value} instances. Alternatively, this factory can
 * be constructed with a different {@link ValueFactory} using
 * {@link #RDF4J(ValueFactory)}.
 * <p>
 * {@link #asRDFTerm(Value)} can be used to convert any RDF4J {@link Value} to
 * an RDFTerm. Note that adapted {@link BNode}s are considered equal if they are
 * converted with the same {@link RDF4J} instance and have the same
 * {@link BNode#getID()}.
 * <p>
 * {@link #createGraph()} creates a new Graph backed by {@link LinkedHashModel}.
 * To use other models, see {@link #asGraph(Model)}.
 * <p>
 * To adapt a RDF4J {@link Repository} as a {@link Dataset} or {@link Graph},
 * use {@link #asDataset(Repository, Option...)} or
 * {@link #asGraph(Repository, Option...)}.
 * <p>
 * {@link #asTriple(Statement)} can be used to convert a RDF4J {@link Statement}
 * to a Commons RDF {@link Triple}, and equivalent {@link #asQuad(Statement)} to
 * convert a {@link Quad}.
 * <p>
 * To convert any {@link Triple} or {@link Quad} to to RDF4J {@link Statement},
 * use {@link #asStatement(TripleLike)}. This recognises previously converted
 * {@link RDF4JTriple}s and {@link RDF4JQuad}s without re-converting their
 * {@link RDF4JTripleLike#asStatement()}.
 * <p>
 * Likewise, {@link #asValue(RDFTerm)} can be used to convert any Commons RDF
 * {@link RDFTerm} to a corresponding RDF4J {@link Value}. This recognises
 * previously converted {@link RDF4JTerm}s without re-converting their
 * {@link RDF4JTerm#asValue()}.
 * <p>
 * For the purpose of {@link BlankNode} equivalence, this factory contains an
 * internal {@link UUID} salt that is used by adapter methods like
 * {@link #asQuad(Statement)}, {@link #asTriple(Statement)},
 * {@link #asRDFTerm(Value)} as well as {@link #createBlankNode(String)}. As
 * RDF4J {@link BNode} instances from multiple repositories or models may have
 * the same {@link BNode#getID()}, converting them with the above methods might
 * cause accidental {@link BlankNode} equivalence. Note that the {@link Graph}
 * and {@link Dataset} adapter methods like
 * {@link #asDataset(Repository, Option...)} and
 * {@link #asGraph(Repository, Option...)} therefore uses a unique {@link RDF4J}
 * internally.
 *
 * @see RDF
 *
 */
@SuppressWarnings("PMD.UnnecessaryFullyQualifiedName") // we use fully-qualified names for clarity
public final class RDF4J implements RDF {

    /**
     * InternalRDF4JFactory is deliberately abstract
     */
    private static final InternalRDF4JFactory RDF4J = new InternalRDF4JFactory() {
    };

    public enum Option {
        /**
         * The Graph/Dataset should include any inferred statements
         */
        includeInferred,
        /**
         * The graph/dataset should handle {@link Repository#initialize()} (if
         * needed) and {@link Repository#shutDown()} on {@link Graph#close()} /
         * {@link Dataset#close()}.
         */
        handleInitAndShutdown
    }

    private final UUID salt;

    private final ValueFactory valueFactory;

    /**
     * Construct an {@link RDF4J}.
     *
     */
    public RDF4J() {
        this(SimpleValueFactory.getInstance(), UUID.randomUUID());
    }

    /**
     * Construct an {@link RDF4J}.
     * <p>
     * This constructor is intended for use with the value factory from
     * {@link Repository#getValueFactory()} when using Repository-based graphs
     * and datasets.
     *
     * @param valueFactory
     *            The RDF4J {@link ValueFactory} to use
     */
    public RDF4J(final ValueFactory valueFactory) {
        this(valueFactory, UUID.randomUUID());
    }

    /**
     * Construct an {@link RDF4J}.
     * <p>
     * This constructor may be used if reproducible
     * {@link BlankNode#uniqueReference()} in {@link BlankNode} is desirable.
     *
     * @param salt
     *            An {@link UUID} salt to be used by any created
     *            {@link BlankNode}s for the purpose of
     *            {@link BlankNode#uniqueReference()}
     */
    public RDF4J(final UUID salt) {
        this(SimpleValueFactory.getInstance(), salt);
    }

    /**
     * Construct an {@link RDF4J}.
     * <p>
     * This constructor may be used if reproducible
     * {@link BlankNode#uniqueReference()} in {@link BlankNode} is desirable.
     *
     * @param valueFactory
     *            The RDF4J {@link ValueFactory} to use
     * @param salt
     *            An {@link UUID} salt to be used by any created
     *            {@link BlankNode}s for the purpose of
     *            {@link BlankNode#uniqueReference()}
     */
    public RDF4J(final ValueFactory valueFactory, final UUID salt) {
        this.valueFactory = valueFactory;
        this.salt = salt;
    }

    /**
     * Adapt a RDF4J {@link Statement} as a Commons RDF {@link Quad}.
     * <p>
     * For the purpose of {@link BlankNode} equivalence, this method will use an
     * internal salt UUID that is unique per instance of {@link RDF4J}.
     * <p>
     * <strong>NOTE:</strong> If combining RDF4J {@link Statement}s multiple
     * repositories or models, then their {@link BNode}s may have the same
     * {@link BNode#getID()}, which with this method would become equivalent
     * according to {@link BlankNode#equals(Object)} and
     * {@link BlankNode#uniqueReference()}, unless a separate {@link RDF4J}
     * instance is used per RDF4J repository/model.
     *
     * @param statement
     *            The statement to convert
     * @return A {@link RDF4JQuad} that is equivalent to the statement
     */
    public RDF4JQuad asQuad(final Statement statement) {
        return RDF4J.createQuadImpl(statement, salt);
    }

    /**
     *
     * Adapt a RDF4J {@link Value} as a Commons RDF {@link RDFTerm}.
     * <p>
     * The value will be of the same kind as the term, e.g. a
     * {@link org.eclipse.rdf4j.model.BNode} is converted to a
     * {@link org.apache.commons.rdf.api.BlankNode}, a
     * {@link org.eclipse.rdf4j.model.IRI} is converted to a
     * {@link org.apache.commons.rdf.api.IRI} and a
     * {@link org.eclipse.rdf4j.model.Literal}. is converted to a
     * {@link org.apache.commons.rdf.api.Literal}
     * <p>
     * For the purpose of {@link BlankNode} equivalence, this method will use an
     * internal salt UUID that is unique per instance of {@link RDF4J}.
     * <p>
     * <strong>NOTE:</strong> If combining RDF4J values from multiple
     * repositories or models, then their {@link BNode}s may have the same
     * {@link BNode#getID()}, which with this method would become equivalent
     * according to {@link BlankNode#equals(Object)} and
     * {@link BlankNode#uniqueReference()}, unless a separate {@link RDF4J}
     * instance is used per RDF4J repository/model.
     *
     * @param value
     *            The RDF4J {@link Value} to convert.
     * @return A {@link RDFTerm} that corresponds to the RDF4J value
     * @throws IllegalArgumentException
     *             if the value is not a BNode, Literal or IRI
     */
    public RDF4JTerm asRDFTerm(final Value value) {
        return asRDFTerm(value, salt);
    }

    /**
     *
     * Adapt a RDF4J
     * {@link org.eclipse.rdf4j.model.BNode} as a Commons RDF
     * {@link org.apache.commons.rdf.api.BlankNode}
     * <p>
     * For the purpose of {@link BlankNode} equivalence, this method will use an
     * internal salt UUID that is unique per instance of {@link RDF4J}.
     * <p>
     * <strong>NOTE:</strong> If combining RDF4J values from multiple
     * repositories or models, then their {@link BNode}s may have the same
     * {@link BNode#getID()}, which with this method would become equivalent
     * according to {@link BlankNode#equals(Object)} and
     * {@link BlankNode#uniqueReference()}, unless a separate {@link RDF4J}
     * instance is used per RDF4J repository/model.
     *
     * @param value
     *            The RDF4J {@link BNode} to convert.
     * @return A {@link RDF4JBlankNode} that corresponds to the RDF4J BNode
     */
    public RDF4JBlankNode asRDFTerm(final BNode value) {
        return RDF4J.createBlankNodeImpl(value, salt);
    }

    /**
     *
     * Adapt a RDF4J
     * {@link org.eclipse.rdf4j.model.Literal} as a Commons RDF
     * {@link org.apache.commons.rdf.api.Literal}
     * <p>
     * @param value
     *            The RDF4J {@link Literal} to convert.
     * @return A {@link RDF4JLiteral} that corresponds to the RDF4J literal
     */
    public RDF4JLiteral asRDFTerm(final Literal value) {
        return RDF4J.createLiteralImpl(value);
    }

    /**
     *
     * Adapt a RDF4J
     * {@link org.eclipse.rdf4j.model.IRI} as a Commons RDF
     * {@link org.apache.commons.rdf.api.IRI}
     * <p>
     * @param value
     *            The RDF4J {@link Value} to convert.
     * @return A {@link RDF4JIRI} that corresponds to the RDF4J IRI
     */
    public RDF4JIRI asRDFTerm(final org.eclipse.rdf4j.model.IRI value) {
        return RDF4J.createIRIImpl(value);
    }

    /**
     *
     * Adapt a RDF4J
     * {@link org.eclipse.rdf4j.model.Resource} as a Commons RDF
     * {@link org.apache.commons.rdf.api.BlankNodeOrIRI}
     * <p>
     * @param value
     *            The RDF4J {@link Value} to convert.
     * @return A {@link RDF4JBlankNodeOrIRI} that corresponds to the RDF4J Resource
     */
    public RDF4JBlankNodeOrIRI asRDFTerm(final org.eclipse.rdf4j.model.Resource value) {
        if(value instanceof IRI){
            return asRDFTerm((IRI)value);
        }
        if (value instanceof BNode){
            return asRDFTerm((BNode)value);
        }
        throw new IllegalArgumentException("Value is not a BNode or IRI: " + value.getClass());
    }

    /**
     * Adapt a RDF4J {@link Value} as a Commons RDF {@link RDFTerm}.
     * <p>
     * The value will be of the same kind as the term, e.g. a
     * {@link org.eclipse.rdf4j.model.BNode} is converted to a
     * {@link org.apache.commons.rdf.api.BlankNode}, a
     * {@link org.eclipse.rdf4j.model.IRI} is converted to a
     * {@link org.apache.commons.rdf.api.IRI} and a
     * {@link org.eclipse.rdf4j.model.Literal}. is converted to a
     * {@link org.apache.commons.rdf.api.Literal}
     *
     * @param value
     *            The RDF4J {@link Value} to convert.
     * @param salt
     *            A {@link UUID} salt to use for uniquely mapping any
     *            {@link BNode}s. The salt should typically be the same for
     *            multiple statements in the same {@link Repository} or
     *            {@link Model} to ensure {@link BlankNode#equals(Object)} and
     *            {@link BlankNode#uniqueReference()} works as intended.
     * @return A {@link RDFTerm} that corresponds to the RDF4J value
     * @throws IllegalArgumentException
     *             if the value is not a BNode, Literal or IRI
     */
    public static RDF4JTerm asRDFTerm(final Value value, final UUID salt) {
        if (value instanceof BNode) {
            return RDF4J.createBlankNodeImpl((BNode) value, salt);
        }
        if (value instanceof org.eclipse.rdf4j.model.Literal) {
            return RDF4J.createLiteralImpl((org.eclipse.rdf4j.model.Literal) value);
        }
        if (value instanceof org.eclipse.rdf4j.model.IRI) {
            return RDF4J.createIRIImpl((org.eclipse.rdf4j.model.IRI) value);
        }
        throw new IllegalArgumentException("Value is not a BNode, Literal or IRI: " + value.getClass());
    }

    /**
     * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Dataset}.
     * <p>
     * Changes to the dataset are reflected in the repository, and vice versa.
     * <p>
     * <strong>Note:</strong> Some operations on the {@link RDF4JDataset}
     * requires the use of try-with-resources to close underlying
     * {@link RepositoryConnection}s, including {@link RDF4JDataset#iterate()},
     * {@link RDF4JDataset#stream()} and {@link RDF4JDataset#getGraphNames()}.
     *
     * @param repository
     *            RDF4J {@link Repository} to connect to.
     * @param options
     *            Zero or more {@link Option}
     * @return A {@link Dataset} backed by the RDF4J repository.
     */
    public RDF4JDataset asDataset(final Repository repository, final Option... options) {
        final EnumSet<Option> opts = optionSet(options);
        return RDF4J.createRepositoryDatasetImpl(repository, opts.contains(Option.handleInitAndShutdown),
                opts.contains(Option.includeInferred));
    }

    /**
     * Adapt an RDF4J {@link Model} as a Commons RDF {@link Graph}.
     * <p>
     * Changes to the graph are reflected in the model, and vice versa.
     *
     * @param model
     *            RDF4J {@link Model} to adapt.
     * @return Adapted {@link Graph}.
     */
    public RDF4JGraph asGraph(final Model model) {
        return RDF4J.createModelGraphImpl(model, this);
    }

    /**
     * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
     * <p>
     * The graph will only include triples in the default graph (equivalent to
     * context <code>new Resource[0]{null})</code> in RDF4J).
     * <p>
     * Changes to the graph are reflected in the repository, and vice versa.
     * <p>
     * <strong>Note:</strong> Some operations on the {@link RDF4JGraph} requires
     * the use of try-with-resources to close underlying
     * {@link RepositoryConnection}s, including {@link RDF4JGraph#iterate()} and
     * {@link RDF4JGraph#stream()}.
     *
     * @param repository
     *            RDF4J {@link Repository} to connect to.
     * @param options
     *            Zero or more {@link Option}
     * @return A {@link Graph} backed by the RDF4J repository.
     */
    public RDF4JGraph asGraph(final Repository repository, final Option... options) {
        final EnumSet<Option> opts = optionSet(options);
        return RDF4J.createRepositoryGraphImpl(repository, opts.contains(Option.handleInitAndShutdown),
                opts.contains(Option.includeInferred), new Resource[] { null }); // default
                                                                                 // graph
    }

    /**
     * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
     * <p>
     * The graph will include triples in any contexts (e.g. the union graph).
     * <p>
     * Changes to the graph are reflected in the repository, and vice versa.
     *
     * @param repository
     *            RDF4J {@link Repository} to connect to.
     * @param options
     *            Zero or more {@link Option}
     * @return A union {@link Graph} backed by the RDF4J repository.
     */
    public RDF4JGraph asGraphUnion(final Repository repository, final Option... options) {
        final EnumSet<Option> opts = optionSet(options);
        return RDF4J.createRepositoryGraphImpl(repository, opts.contains(Option.handleInitAndShutdown),
                opts.contains(Option.includeInferred)); // union graph
    }

    /**
     * Adapt an RDF4J {@link Repository} as a Commons RDF {@link Graph}.
     * <p>
     * The graph will include triples in the specified contexts.
     * <p>
     * Changes to the graph are reflected in the repository, and vice versa.
     * Triples added/removed to the graph are reflected in all the specified
     * contexts.
     * <p>
     * <strong>Note:</strong> Some operations on the {@link RDF4JGraph} requires
     * the use of try-with-resources to close underlying
     * {@link RepositoryConnection}s, including {@link RDF4JGraph#iterate()} and
     * {@link RDF4JGraph#stream()}.
     *
     * @param repository
     *            RDF4J {@link Repository} to connect to.
     * @param contexts
     *            A {@link Set} of {@link BlankNodeOrIRI} specifying the graph
     *            names to use as a context. The set may include the value
     *            <code>null</code> to indicate the default graph. The empty set
     *            indicates any context, e.g. the <em>union graph</em>.
     * @param option
     *            Zero or more {@link Option}s
     * @return A {@link Graph} backed by the RDF4J repository.
     */
    public RDF4JGraph asGraph(final Repository repository, final Set<? extends BlankNodeOrIRI> contexts, final Option... option) {
        final EnumSet<Option> opts = optionSet(option);
        /** NOTE: asValue() deliberately CAN handle <code>null</code> */
        final Resource[] resources = contexts.stream().map(g -> (Resource) asValue(g)).toArray(Resource[]::new);
        return RDF4J.createRepositoryGraphImpl(Objects.requireNonNull(repository),
                opts.contains(Option.handleInitAndShutdown), opts.contains(Option.includeInferred), resources);
    }

    /**
     * Adapt a Commons RDF {@link Triple} or {@link Quad} as a RDF4J
     * {@link Statement}.
     * <p>
     * If the <code>tripleLike</code> argument is an {@link RDF4JTriple} or a
     * {@link RDF4JQuad}, then its {@link RDF4JTripleLike#asStatement()} is
     * returned as-is. Note that this means that a {@link RDF4JTriple} would
     * preserve its {@link Statement#getContext()}, and that any
     * {@link BlankNode}s would be deemed equivalent in RDF4J if they have the
     * same {@link BNode#getID()}.
     *
     * @param tripleLike
     *            A {@link Triple} or {@link Quad} to adapt
     * @return A corresponding {@link Statement}
     */
    public Statement asStatement(final TripleLike tripleLike) {
        if (tripleLike instanceof RDF4JTripleLike) {
            // Return original statement - this covers both RDF4JQuad and
            // RDF4JTriple
            return ((RDF4JTripleLike) tripleLike).asStatement();
        }

        final org.eclipse.rdf4j.model.Resource subject = (org.eclipse.rdf4j.model.Resource) asValue(tripleLike.getSubject());
        final org.eclipse.rdf4j.model.IRI predicate = (org.eclipse.rdf4j.model.IRI) asValue(tripleLike.getPredicate());
        final Value object = asValue(tripleLike.getObject());

        org.eclipse.rdf4j.model.Resource context = null;
        if (tripleLike instanceof Quad) {
            final Quad quad = (Quad) tripleLike;
            context = (org.eclipse.rdf4j.model.Resource) asValue(quad.getGraphName().orElse(null));
        }

        return getValueFactory().createStatement(subject, predicate, object, context);
    }

    /**
     * Adapt a RDF4J {@link Statement} as a Commons RDF {@link Triple}.
     * <p>
     * For the purpose of {@link BlankNode} equivalence, this method will use an
     * internal salt UUID that is unique per instance of {@link RDF4J}.
     * <p>
     * <strong>NOTE:</strong> If combining RDF4J statements from multiple
     * repositories or models, then their {@link BNode}s may have the same
     * {@link BNode#getID()}, which with this method would become equivalent
     * according to {@link BlankNode#equals(Object)} and
     * {@link BlankNode#uniqueReference()}, unless a separate {@link RDF4J}
     * instance is used per RDF4J repository/model.
     *
     * @param statement
     *            The RDF4J {@link Statement} to adapt.
     * @return A {@link RDF4JTriple} that is equivalent to the statement
     */
    public RDF4JTriple asTriple(final Statement statement) {
        return RDF4J.createTripleImpl(statement, salt);
    }

    /**
     * Adapt a Commons RDF {@link RDFTerm} as a RDF4J {@link Value}.
     * <p>
     * The value will be of the same kind as the term, e.g. a
     * {@link org.apache.commons.rdf.api.BlankNode} is converted to a
     * {@link org.eclipse.rdf4j.model.BNode}, a
     * {@link org.apache.commons.rdf.api.IRI} is converted to a
     * {@link org.eclipse.rdf4j.model.IRI} and a
     * {@link org.apache.commons.rdf.api.Literal} is converted to a
     * {@link org.eclipse.rdf4j.model.Literal}.
     * <p>
     * If the provided {@link RDFTerm} is <code>null</code>, then the returned
     * value is <code>null</code>.
     * <p>
     * If the provided term is an instance of {@link RDF4JTerm}, then the
     * {@link RDF4JTerm#asValue()} is returned without any conversion. Note that
     * this could mean that a {@link Value} from a different kind of
     * {@link ValueFactory} could be returned.
     *
     * @param term
     *            RDFTerm to adapt to RDF4J Value
     * @return Adapted RDF4J {@link Value}
     */
    public Value asValue(final RDFTerm term) {
        if (term == null) {
            return null;
        }
        if (term instanceof RDF4JTerm) {
            // One of our own - avoid converting again.
            // (This is crucial to avoid double-escaping in BlankNode)
            return ((RDF4JTerm) term).asValue();
        }
        if (term instanceof org.apache.commons.rdf.api.IRI) {
            final org.apache.commons.rdf.api.IRI iri = (org.apache.commons.rdf.api.IRI) term;
            return getValueFactory().createIRI(iri.getIRIString());
        }
        if (term instanceof org.apache.commons.rdf.api.Literal) {
            final org.apache.commons.rdf.api.Literal literal = (org.apache.commons.rdf.api.Literal) term;
            final String label = literal.getLexicalForm();
            if (literal.getLanguageTag().isPresent()) {
                final String lang = literal.getLanguageTag().get();
                return getValueFactory().createLiteral(label, lang);
            }
            final org.eclipse.rdf4j.model.IRI dataType = (org.eclipse.rdf4j.model.IRI) asValue(literal.getDatatype());
            return getValueFactory().createLiteral(label, dataType);
        }
        if (term instanceof BlankNode) {
            // This is where it gets tricky to support round trips!
            final BlankNode blankNode = (BlankNode) term;
            // FIXME: The uniqueReference might not be a valid BlankNode
            // identifier..
            // does it have to be in RDF4J?
            return getValueFactory().createBNode(blankNode.uniqueReference());
        }
        throw new IllegalArgumentException("RDFTerm was not an IRI, Literal or BlankNode: " + term.getClass());
    }

    @Override
    public RDF4JBlankNode createBlankNode() {
        final BNode bnode = getValueFactory().createBNode();
        return asRDFTerm(bnode);
    }

    @Override
    public RDF4JBlankNode createBlankNode(final String name) {
        final BNode bnode = getValueFactory().createBNode(name);
        return asRDFTerm(bnode);
    }

    /**
     * {@inheritDoc}
     * <p>
     * <strong>Note:</strong> Some operations on the {@link RDF4JDataset}
     * requires the use of try-with-resources to close underlying
     * {@link RepositoryConnection}s, including {@link RDF4JDataset#iterate()},
     * {@link RDF4JDataset#stream()} and {@link RDF4JDataset#getGraphNames()}.
     *
     */
    @Override
    public RDF4JDataset createDataset() {
        final Sail sail = new MemoryStore();
        final Repository repository = new SailRepository(sail);
        return RDF4J.createRepositoryDatasetImpl(repository, true, false);
    }

    @Override
    public RDF4JGraph createGraph() {
        return asGraph(new LinkedHashModel());
    }

    @Override
    public RDF4JIRI createIRI(final String iri) throws IllegalArgumentException {
        return asRDFTerm(getValueFactory().createIRI(iri));
    }

    @Override
    public RDF4JLiteral createLiteral(final String lexicalForm) throws IllegalArgumentException {
        final org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm);
        return asRDFTerm(lit);
    }

    @Override
    public org.apache.commons.rdf.api.Literal createLiteral(final String lexicalForm, final org.apache.commons.rdf.api.IRI dataType)
            throws IllegalArgumentException {
        final org.eclipse.rdf4j.model.IRI iri = getValueFactory().createIRI(dataType.getIRIString());
        final org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm, iri);
        return asRDFTerm(lit);
    }

    @Override
    public org.apache.commons.rdf.api.Literal createLiteral(final String lexicalForm, final String languageTag)
            throws IllegalArgumentException {
        final org.eclipse.rdf4j.model.Literal lit = getValueFactory().createLiteral(lexicalForm, languageTag);
        return asRDFTerm(lit);
    }

    @Override
    public RDF4JTriple createTriple(final BlankNodeOrIRI subject, final org.apache.commons.rdf.api.IRI predicate, final RDFTerm object)
            throws IllegalArgumentException {
        final Statement statement = getValueFactory().createStatement(
                (org.eclipse.rdf4j.model.Resource) asValue(subject), (org.eclipse.rdf4j.model.IRI) asValue(predicate),
                asValue(object));
        return asTriple(statement);
    }

    @Override
    public Quad createQuad(final BlankNodeOrIRI graphName, final BlankNodeOrIRI subject, final org.apache.commons.rdf.api.IRI predicate,
            final RDFTerm object) throws IllegalArgumentException {
        final Statement statement = getValueFactory().createStatement(
                (org.eclipse.rdf4j.model.Resource) asValue(subject), (org.eclipse.rdf4j.model.IRI) asValue(predicate),
                asValue(object), (org.eclipse.rdf4j.model.Resource) asValue(graphName));
        return asQuad(statement);
    }

    public ValueFactory getValueFactory() {
        return valueFactory;
    }

    private EnumSet<Option> optionSet(final Option... options) {
        final EnumSet<Option> opts = EnumSet.noneOf(Option.class);
        opts.addAll(Arrays.asList(options));
        return opts;
    }

}