/*
    * Copyright Emmanouil Batsis
    * 
    * Licensed under the GNU General Public 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.gnu.org/licenses/gpl.txt
    * 
   * 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 com.geekologue.md4j.generators;
  
  import java.io.BufferedInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.parsers.SAXParserFactory;
  import javax.xml.transform.Source;
  import javax.xml.transform.TransformerException;
  import javax.xml.transform.URIResolver;
  import javax.xml.transform.sax.SAXSource;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.Task;
  import org.apache.tools.ant.types.XMLCatalog;
  import org.xml.sax.EntityResolver;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  import org.xml.sax.XMLReader;
  import com.geekologue.md4j.tools.ant.HibernateMappingProcessorTask;
  
  /***
   * EntityResolver and URIResolver implementation for Md4j Ant tasks. Used to
   * load XSLT files, XML entities etc from the MD4J jar. Used only within Ant
   * builds. Delegates non-MD4J resource resolution to the XML Catalogue used by
   * the task.
   * 
   * @author Emmanouil Batsis
   * 
   */
  public class ResourceResolver implements EntityResolver, URIResolver {
      private Task       task;
  
      private XMLCatalog xmlCatalogue;
  
      private ResourceResolver() {
          super();
      }
  
      /***
       * 
       * @param belongingTask
       *            the task object using this instance
       * @param catalogue
       *            the XMLCatalogue to delegate non-MD4J resource resolution
       */
      public ResourceResolver(HibernateMappingProcessorTask belongingTask) {
          this();
          // used to log properly
          this.task = belongingTask;
          // used to delegate lookups when requested resources are not
          // specific to MD4J
          this.xmlCatalogue = belongingTask.getXmlCatalog();
      }
  
      private void log(String msg, int level) {
          this.task.log(this.getClass().getName() + ": " + msg, level);
      }
  
      /***
       * Get a resource from the MD4J jar as an InputSource.
       * 
       * @param path
       * @return
       */
      private InputSource resolveInternalResource(String path) {
          InputSource inputSource;
          String s = path.startsWith(HibernateMappingProcessorTask.MD4J_BASE_URI) ? path
                  .substring(HibernateMappingProcessorTask.MD4J_BASE_URI.length())
                  : path;
          InputStream inputStream = ResourceResolver.class.getClassLoader()
                  .getResourceAsStream(s);
          inputSource = new InputSource(new BufferedInputStream(inputStream));
          inputSource.setSystemId(path);
          this.log("Loaded MD4J resource: " + path, Project.MSG_DEBUG);
          return inputSource;
      }
  
      /***
       * @throws IOException
       * @throws SAXException
       * @see org.xml.sax.EntityResolver#resolveEntity(java.lang.String,
      *      java.lang.String)
      */
     public InputSource resolveEntity(String publicId, String systemId)
             throws SAXException, IOException {
         InputSource inputSource = null;
         if (systemId != null
                 && systemId
                         .startsWith(HibernateMappingProcessorTask.MD4J_BASE_URI)) {
             inputSource = resolveInternalResource(systemId);
         } else {
             inputSource = this.xmlCatalogue.resolveEntity(publicId, systemId);
         }
         return inputSource;
     }
 
     /***
      * @param href
      * @param base
      * @see javax.xml.transform.URIResolver#resolve(java.lang.String,
      *      java.lang.String)
      */
     public Source resolve(String href, String base) throws TransformerException {
         Source source = null;
         try {
             if (base != null
                     && base
                             .startsWith(HibernateMappingProcessorTask.MD4J_BASE_URI)) {
                 URL resolved = new URL(new URL(base), href);
                 // i think i keep the SAX plumbing here to set
                 // the URIResolver for the Reader used, need to check
                 SAXParserFactory spFactory = SAXParserFactory.newInstance();
                 spFactory.setNamespaceAware(true);
                 spFactory.setValidating(false);
                 XMLReader reader = spFactory.newSAXParser().getXMLReader();
                 reader.setEntityResolver(this);
                 source = new SAXSource(reader, this
                         .resolveInternalResource(resolved.toString()));
                 source.setSystemId(resolved.toString());
             } else {
                 // i really tried, but simply cannot make simple FS lookups
                 // work; URI and File objects simply do not share a consistent
                 // view
                 // of the file: URI scheme and i haven't even tried my Linux or
                 // a Windowes box yet...
                 // Passing the responsibility to an XMLCatalogue object
                 source = this.xmlCatalogue.resolve(href, base);
             }
         } catch (SAXException e) {
             throw new TransformerException(e);
         } catch (ParserConfigurationException e) {
             throw new TransformerException(e);
         } catch (MalformedURLException e) {
             throw new TransformerException(e);
         }
         return source;
     }
 }