/*
    * 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.rdfa;
  
  import org.apache.any23.configuration.DefaultConfiguration;
  import org.apache.any23.extractor.ExtractionContext;
  import org.apache.any23.extractor.ExtractionException;
  import org.apache.any23.extractor.ExtractionParameters;
  import org.apache.any23.extractor.ExtractionResult;
  import org.apache.any23.extractor.ExtractorDescription;
  import org.apache.any23.extractor.ExtractorFactory;
  import org.apache.any23.extractor.SimpleExtractorFactory;
  import org.apache.any23.extractor.rdf.RDFParserFactory;
  import org.apache.any23.extractor.Extractor.TagSoupDOMExtractor;
  import org.openrdf.rio.RDFHandlerException;
  import org.openrdf.rio.RDFParseException;
  import org.openrdf.rio.RDFParser;
  import org.w3c.dom.Document;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.StringReader;
  import java.io.StringWriter;
  import java.util.Arrays;
  
  /**
   * Extractor for RDFa in HTML, based on Fabien Gadon's XSLT transform, found
   * <a href="http://ns.inria.fr/grddl/rdfa/">here</a>. It works by first
   * parsing the HTML using a tagsoup parser, then applies the XSLT to the
   * DOM tree, then parses the resulting RDF/XML.
   *
   * @author Gabriele Renzi
   * @author Richard Cyganiak (richard@cyganiak.de)
   */
  public class RDFaExtractor implements TagSoupDOMExtractor {
  
      public final static String NAME = "html-rdfa";
  
      public final static String xsltFilename =
              DefaultConfiguration.singleton().getPropertyOrFail("any23.rdfa.extractor.xslt");
  
      private static XSLTStylesheet xslt = null;
  
      public final static ExtractorFactory<RDFaExtractor> factory =
          SimpleExtractorFactory.create(
                  NAME,
                  null,
                  Arrays.asList("text/html;q=0.3", "application/xhtml+xml;q=0.3"),
                  null,
                  RDFaExtractor.class
          );
  
      /**
       * Returns a {@link XSLTStylesheet} able to distill RDFa from
       * HTML pages.
       *
       * @return returns a not <code>null</code> XSLT instance.
       */
      public static synchronized XSLTStylesheet getXSLT() {
          // Lazily initialized static instance, so we don't parse
          // the XSLT unless really necessary, and only once
          if (xslt == null) {
              InputStream in = RDFaExtractor.class.getResourceAsStream(xsltFilename);
              if (in == null) {
                  throw new RuntimeException("Couldn't load '" + xsltFilename +
                          "', maybe the file is not bundled in the jar?");
              }
              xslt = new XSLTStylesheet(in);
          }
          return xslt;
      }
  
      private boolean verifyDataType;
  
      private boolean stopAtFirstError;
  
      /**
       * Constructor, allows to specify the validation and error handling policies.
       *
       * @param verifyDataType if <code>true</code> the data types will be verified,
       *         if <code>false</code> will be ignored.
       * @param stopAtFirstError if <code>true</code> the parser will stop at first parsing error,
       *        if <code>false</code> will ignore non blocking errors.
       */
     public RDFaExtractor(boolean verifyDataType, boolean stopAtFirstError) {
         this.verifyDataType   = verifyDataType;
         this.stopAtFirstError = stopAtFirstError;
     }
 
     /**
      * Default constructor, with no verification of data types and not stop at first error.
      */    
     public RDFaExtractor() {
         this(false, false);
     }
 
     public boolean isVerifyDataType() {
         return verifyDataType;
     }
 
     public void setVerifyDataType(boolean verifyDataType) {
         this.verifyDataType = verifyDataType;
     }
 
     public boolean isStopAtFirstError() {
         return stopAtFirstError;
     }
 
     public void setStopAtFirstError(boolean stopAtFirstError) {
         this.stopAtFirstError = stopAtFirstError;
     }
 
     public void run(
             ExtractionParameters extractionParameters,
             ExtractionContext extractionContext,
             Document in,
             ExtractionResult out
     ) throws IOException, ExtractionException {
 
         StringWriter buffer = new StringWriter();
         try {
             getXSLT().applyTo(in, buffer);
         } catch (XSLTStylesheetException xslte) {
             throw new ExtractionException("An error occurred during the XSLT application.", xslte);
         }
 
         try {
             RDFParser parser
                     = RDFParserFactory.getInstance().getRDFXMLParser(
                         verifyDataType, stopAtFirstError, extractionContext, out
                     );
             parser.parse(
                     new StringReader(buffer.getBuffer().toString()),
                     extractionContext.getDocumentURI().stringValue()
             );
         } catch (RDFHandlerException ex) {
             throw new IllegalStateException(
                     "Should not happen, RDFHandlerAdapter does not throw RDFHandlerException", ex
             );
         } catch (RDFParseException ex) {
             throw new ExtractionException(
                     "Invalid RDF/XML produced by RDFa transform.", ex, out
             );
         }
     }
 
     private String getDocType(Document in) {
         return in.getDoctype().getPublicId();
     }
 
     /**
      * @return the {@link org.apache.any23.extractor.ExtractorDescription} of this extractor
      */
     public ExtractorDescription getDescription() {
         return factory;
     }
 
 }