/**
    * 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.jena;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertTrue;
  
  import java.io.IOException;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.StandardCopyOption;
  
  import org.apache.commons.rdf.api.BlankNode;
  import org.apache.commons.rdf.api.BlankNodeOrIRI;
  import org.apache.commons.rdf.api.Graph;
  import org.apache.commons.rdf.api.RDFTerm;
  import org.apache.commons.rdf.api.Triple;
  import org.apache.commons.rdf.simple.Types;
  import org.apache.jena.riot.Lang;
  import org.apache.jena.riot.RDFDataMgr;
  import org.apache.jena.sparql.graph.GraphFactory;
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  
  /** Adapt a Jena Graph after parsing data into it */
  public class TestJenaGraphToCommonsRDFGraph {
      private static final boolean DEBUG = false;
      private Path turtleFile;
  
      @Before
      public void preparePath() throws IOException {
          turtleFile = Files.createTempFile("commonsrdf", "test.ttl");
          Files.copy(getClass().getResourceAsStream("/D.ttl"), turtleFile, StandardCopyOption.REPLACE_EXISTING);
      }
  
      @After
      public void deletePath() throws IOException {
          if (turtleFile != null) {
              Files.deleteIfExists(turtleFile);
          }
      }
  
      @Test
      public void jenaToCommonsRDF() throws Exception {
          final org.apache.jena.graph.Graph jGraph = GraphFactory.createGraphMem();
          RDFDataMgr.read(jGraph, turtleFile.toUri().toString());
  
          final JenaRDF factory = new JenaRDF();
  
          // "graph" is a CommonsRDF graph
          try (final Graph graph = factory.asGraph(jGraph)) {
  
              // The below check expected statements from D.ttl
  
              final JenaIRI p = factory.createIRI("http://example.com/p");
              final JenaIRI s = factory.createIRI("http://example.com/s");
              final JenaLiteral literal123 = factory.createLiteral("123", Types.XSD_INTEGER);
              assertTrue(graph.contains(s, p, literal123));
  
              final JenaIRI p1 = factory.createIRI("http://example.com/p1");
              // Let's look up the BlankNode
              final BlankNodeOrIRI bnode1 = graph.stream(null, p1, null).findFirst().map(Triple::getSubject).get();
              assertTrue(bnode1 instanceof BlankNode);
  
              // Verify we can use BlankNode in query again
              final RDFTerm obj = graph.stream(bnode1, p1, null).findFirst().map(Triple::getObject).get();
  
              // Let's look up also that nested blank node
              assertTrue(obj instanceof BlankNode);
              final BlankNode bnode2 = (BlankNode) obj;
  
              final JenaIRI q = factory.createIRI("http://example.com/q");
              final JenaLiteral literalR = factory.createLiteral("r", "en");
              assertTrue(graph.contains(bnode2, q, literalR));
  
              // Can we add the same triple again as s/p/o
              // without affecting graph size?
              // Just to be evil we add a blanknode-iri-blanknode statement
              assertEquals(3, graph.size());
              graph.add(bnode1, p1, bnode2);
              assertEquals(3, graph.size());
  
             // Add the same Triple again
             graph.stream(bnode2, null, null).findFirst().ifPresent(graph::add);
             assertEquals(3, graph.size());
 
             // Add to CommonsRDF Graph
             final JenaIRI s2 = factory.createIRI("http://example/s2");
             final JenaIRI p2 = factory.createIRI("http://example/p2");
             final JenaLiteral foo = factory.createLiteral("foo");
             graph.add(s2, p2, foo);
             assertEquals(4, graph.size());
             assertTrue(graph.contains(s2, p2, foo));
 
             // Verify the corresponding Jena Nodes are in Jena graph
             assertTrue(jGraph.contains(s2.asJenaNode(), p2.asJenaNode(), foo.asJenaNode()));
 
             if (DEBUG) {
                 System.out.println("==== Write CommonsRDF graph\n");
                 graph.stream().forEach(System.out::println);
                 // And its in the Jena graph
                 System.out.println("\n==== Write Jena graph directly\n");
                 RDFDataMgr.write(System.out, jGraph, Lang.TTL);
             }
         }
     }
 }