/*
    * 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.any23.extractor.yaml;
  
  import java.util.List;
  import java.util.function.Function;
  import java.util.stream.Collectors;
  import org.apache.any23.extractor.ExtractorFactory;
  import org.apache.any23.extractor.html.AbstractExtractorTestCase;
  import org.apache.any23.rdf.RDFUtils;
  import org.apache.any23.vocab.YAML;
  import org.junit.Assert;
  import org.junit.Test;
  import org.eclipse.rdf4j.common.iteration.Iterations;
  import org.eclipse.rdf4j.model.Statement;
  import org.eclipse.rdf4j.model.vocabulary.RDF;
  import org.eclipse.rdf4j.model.vocabulary.RDFS;
  import org.eclipse.rdf4j.query.BindingSet;
  import org.eclipse.rdf4j.query.TupleQueryResult;
  import org.eclipse.rdf4j.repository.RepositoryConnection;
  import org.eclipse.rdf4j.repository.RepositoryResult;
  import org.junit.ComparisonFailure;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Test {@link YAMLExtractor}.
   *
   * @author Jacek Grzebyta (jgrzebyta [at] apache [dot] org)
   */
  public class YAMLExtractorTest extends AbstractExtractorTestCase {
  
      public static final Logger log = LoggerFactory.getLogger(YAMLExtractorTest.class);
      public static final String ns = "http://bob.example.com/";
      private static final YAML vocab = YAML.getInstance();
  
      @Override
      protected ExtractorFactory<?> getExtractorFactory() {
          return new YAMLExtractorFactory();
      }
  
      /**
       * Test to validate simple yaml file for ANY23-312
       * 
       * @throws Exception
       *             if there is an error asserting the test data.
       */
      @Test
      public void simpleTest312() throws Exception {
          assertExtract("/org/apache/any23/extractor/yaml/simple-312.yml");
          log.debug(dumpModelToTurtle());
          assertModelNotEmpty();
      }
  
      @Test
      public void simpleFileLoading() throws Exception {
          assertExtract("/org/apache/any23/extractor/yaml/simple-load.yml");
          log.debug("\n{}", dumpModelToTurtle());
          assertModelNotEmpty();
  
      }
  
      @Test
      public void integersTest() throws Exception {
          assertExtract("/org/apache/any23/extractor/yaml/different-integers.yml");
          log.debug(dumpModelToTurtle());
          assertModelNotEmpty();
          assertContains(null, RDFS.LABEL, RDFUtils.literal("hexadecimal"));
          assertContains(null, RDFS.LABEL, RDFUtils.literal("octal"));
      }
  
      @Test
      public void floatsTest() throws Exception {
          assertExtract("/org/apache/any23/extractor/yaml/different-float.yml");
          log.debug(dumpModelToTurtle());
          assertModelNotEmpty();
      }
  
      @Test
      public void multiTest() throws Exception {
          assertExtract("/org/apache/any23/extractor/yaml/multi-test.yml");
          log.debug(dumpModelToTurtle());
          assertModelNotEmpty();
          RepositoryResult<Statement> docs = getStatements(null, RDF.TYPE, vocab.document);
          Assert.assertTrue(Iterations.asList(docs).size() > 1);
     }
 
     @Test
     public void nullTest() throws Exception {
         assertExtract("/org/apache/any23/extractor/yaml/test-null.yml");
         log.debug(dumpModelToTurtle());
         assertModelNotEmpty();
         int statements = dumpAsListOfStatements().size();
         Assert.assertTrue("Found " + statements + " statements", statements == 26);
     }
 
     @Test
     public void treeTest() throws Exception {
         assertExtract("/org/apache/any23/extractor/yaml/tree.yml");
         log.debug("\n{}", dumpModelToTurtle());
         assertModelNotEmpty();
         // validate part of the tree structure
         assertContainsModel(
                 new Statement[] { RDFUtils.triple(RDFUtils.bnode(), RDFUtils.iri(ns, "value3"), RDFUtils.bnode("10")),
                         RDFUtils.triple(RDFUtils.bnode("10"), RDF.FIRST, RDFUtils.bnode("11")),
                         RDFUtils.triple(RDFUtils.bnode("11"), RDFUtils.iri(ns, "key3.1"), RDFUtils.bnode("12")),
                         RDFUtils.triple(RDFUtils.bnode("12"), RDF.FIRST, RDFUtils.literal("value3.1.1")) });
 
         // validate occurence of <urn:value1> resource
         assertContains(RDFUtils.triple(RDFUtils.bnode(), RDF.FIRST, RDFUtils.iri("urn:value1")));
     }
 
     @Test
     public void treeTest2() throws Exception {
         assertExtract("/org/apache/any23/extractor/yaml/tree.yml");
         String sparql = "select ?nodes where "
                 + "{ [] <http://bob.example.com/key3.1> [ rdf:rest*/rdf:first ?nodes ;]}";
 
         RepositoryConnection connection = getConnection();
         TupleQueryResult res = connection.prepareTupleQuery(sparql).evaluate();
         List<BindingSet> resList = Iterations.asList(res);
         try {
             Assert.assertEquals("value3.1.1", resList.get(0).getValue("nodes").stringValue());
         } catch (ComparisonFailure e) {
             if ("value3.1.1".equals(resList.get(0).getValue("nodes").stringValue())) {
                 throw new RuntimeException("there should be no error");
             }
         }
         List<String> resString = resList.stream().map((Function<? super BindingSet, String>) (b) -> {
             return b.getValue("nodes").stringValue();
         }).collect(Collectors.toList());
 
         log.debug("List output: {}", resString);
     }
 
     /**
      * This test covers a typical situation when a document is a map.
      * 
      * <br>
      * <b>NB:</b> Following yaml standard those 2 cases are parsed to different graphs: <br>
      * Case 1:
      * 
      * <pre>
      * ---
      * key1: value1
      * key2: value2
      * key3: Some text  value, maybe description
      * </pre>
      * 
      * Case 2:
      * 
      * <pre>
      * ---
      * - key1: value1
      * - key2: value2
      * - key3: Some text  value, maybe description
      * </pre>
      * 
      * @throws Exception
      *             if there is an error asserting the test data.
      * 
      * @see #treeTest()
      */
     @Test
     public void tree2Test() throws Exception {
         assertExtract("/org/apache/any23/extractor/yaml/tree2.yml");
         log.debug("\n{}", dumpModelToTurtle());
         assertModelNotEmpty();
 
         // check if document is type of mapping.
         assertContainsModel(new Statement[] { RDFUtils.triple(RDFUtils.bnode("10"), RDF.TYPE, vocab.document),
                 RDFUtils.triple(RDFUtils.bnode("10"), RDF.TYPE, vocab.mapping) });
     }
 }