/*
    * 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.myfaces.view.facelets.compiler;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.URL;
  import java.net.URLConnection;
  import javax.faces.context.ExternalContext;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.parsers.SAXParser;
  import javax.xml.parsers.SAXParserFactory;
  import org.apache.myfaces.config.ConfigFilesXmlValidationUtils;
  import org.apache.myfaces.config.element.facelets.FaceletTagLibrary;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletBehaviorTagImpl;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletComponentTagImpl;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletConverterTagImpl;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletFunctionImpl;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletHandlerTagImpl;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletSourceTagImpl;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletTagImpl;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletTagLibraryImpl;
  import org.apache.myfaces.config.impl.digester.elements.facelets.FaceletValidatorTagImpl;
  import org.apache.myfaces.shared.config.MyfacesConfig;
  import org.apache.myfaces.shared.util.ClassUtils;
  import org.xml.sax.Attributes;
  import org.xml.sax.InputSource;
  import org.xml.sax.Locator;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXParseException;
  import org.xml.sax.XMLReader;
  import org.xml.sax.helpers.DefaultHandler;
  
  /**
   *
   */
  public class TagLibraryConfigUnmarshallerImpl
  {
      
      public static FaceletTagLibrary create(ExternalContext externalContext, URL url) throws IOException
      {
          InputStream is = null;
          FaceletTagLibrary t = null;
          URLConnection conn = null;
          try
          {
              boolean schemaValidating = false;
  
              // validate XML
              if (MyfacesConfig.getCurrentInstance(externalContext).isValidateXML())
              {
                  String version = ConfigFilesXmlValidationUtils.getFaceletTagLibVersion(url);
                  schemaValidating = "2.0".equals(version);
                  if (schemaValidating)
                  {
                      ConfigFilesXmlValidationUtils.validateFaceletTagLibFile(url, externalContext, version);
                  }
              }
              
              // parse file
              LibraryHandler handler = new LibraryHandler(url);
              SAXParser parser = createSAXParser(handler, externalContext, schemaValidating);
              conn = url.openConnection();
              conn.setUseCaches(false);
              is = conn.getInputStream();
              parser.parse(is, handler);
              t = handler.getLibrary();
          }
          catch (SAXException e)
          {
              IOException ioe = new IOException("Error parsing [" + url + "]: ");
              ioe.initCause(e);
              throw ioe;
          }
          catch (ParserConfigurationException e)
          {
              IOException ioe = new IOException("Error parsing [" + url + "]: ");
              ioe.initCause(e);
              throw ioe;
          }
          finally
          {
              if (is != null)
             {
                 is.close();
             }
         }
         return t;
     }    
     
     private static final SAXParser createSAXParser(LibraryHandler handler, ExternalContext externalContext,
                                                    boolean schemaValidating)
             throws SAXException, ParserConfigurationException
     {
         SAXParserFactory factory = SAXParserFactory.newInstance();
 
         if (MyfacesConfig.getCurrentInstance(externalContext).isValidateXML() && !schemaValidating)
         {
             // DTD validating
             factory.setNamespaceAware(false);
             factory.setFeature("http://xml.org/sax/features/validation", true);
             factory.setValidating(true);
         }
         else
         {
             //Just parse it and do not validate, because it is not necessary.
             factory.setNamespaceAware(true);
             factory.setFeature("http://xml.org/sax/features/validation", false);
             factory.setValidating(false);
         }
 
         SAXParser parser = factory.newSAXParser();
         XMLReader reader = parser.getXMLReader();
         reader.setErrorHandler(handler);
         reader.setEntityResolver(handler);
         return parser;
     }
 
     private static class LibraryHandler extends DefaultHandler
     {
         private final URL source;
         
         private FaceletTagLibraryImpl library;
 
         private final StringBuffer buffer;
 
         private Locator locator;
 
         private String tagName;
 
         private String converterId;
 
         private String validatorId;
         
         private String behaviorId;
 
         private String componentType;
 
         private String rendererType;
 
         private String functionName;
 
         //private Class<? extends TagHandler> handlerClass;
         private String handlerClass;
 
         //private Class<?> functionClass;
         private String functionClass;
 
         private String functionSignature;
         
         private String resourceId;
        
         public LibraryHandler(URL source)
         {
             this.source = source;
             this.buffer = new StringBuffer(64);
         }
 
         public FaceletTagLibrary getLibrary()
         {
             return this.library;
         }
         
         private FaceletTagLibraryImpl getLibraryImpl()
         {
             if (this.library == null)
             {
                 this.library = new FaceletTagLibraryImpl();
             }
             return this.library;
         }
 
         public void endElement(String uri, String localName, String qName) throws SAXException
         {
             try
             {
                 if ("facelet-taglib".equals(qName))
                 {
                     // Nothing to do
                 }                
                 else if ("library-class".equals(qName))
                 {
                     getLibraryImpl().setLibraryClass(this.captureBuffer());
                 }
                 else if ("short-name".equals(qName))
                 {
                     getLibraryImpl().setShortName(this.captureBuffer());
                 }
                 else if ("namespace".equals(qName))
                 {
                     getLibraryImpl().setNamespace(this.captureBuffer());
                 }
                 else if ("composite-library-name".equals(qName))
                 {
                     getLibraryImpl().setCompositeLibraryName(this.captureBuffer());
                 }
                 else if ("component-type".equals(qName))
                 {
                     this.componentType = this.captureBuffer();
                 }
                 else if ("renderer-type".equals(qName))
                 {
                     this.rendererType = this.captureBufferEmptyNull();
                 }
                 else if ("tag-name".equals(qName))
                 {
                     this.tagName = this.captureBuffer();
                 }
                 else if ("function-name".equals(qName))
                 {
                     this.functionName = this.captureBuffer();
                 }
                 else if ("function-class".equals(qName))
                 {
                     //String className = this.captureBuffer();
                     //this.functionClass = createClass(Object.class, className);
                     this.functionClass = this.captureBuffer();
                 }
                 else if ("description".equals(qName))
                 {
                     //Not used
                 }
                 else if ("display-name".equals(qName))
                 {
                     //Not used
                 }
                 else if ("icon".equals(qName))
                 {
                     //Not used
                 }                
                 else if ("resource-id".equals(qName))
                 {
                     this.resourceId = this.captureBuffer();
                 }
                 else
                 {
                     // Make sure there we've seen a namespace element
                     // before trying any of the following elements to avoid
                     // obscure NPEs
                     if (this.library == null)
                     {
                         throw new IllegalStateException("No <namespace> element");
                     }
                     else if (this.library.getNamespace() == null)
                     {
                         throw new IllegalStateException("No <namespace> element");
                     }
 
                     //TagLibraryImpl impl = (TagLibraryImpl) this.library;
 
                     if ("tag".equals(qName))
                     {
                         if (this.handlerClass != null)
                         {
                             //impl.putTagHandler(this.tagName, this.handlerClass);
                             getLibraryImpl().addTag(
                                 new FaceletTagImpl(this.tagName, 
                                     new FaceletHandlerTagImpl(this.handlerClass)) );
                             this.handlerClass = null;
                         }
                     }
                     else if ("handler-class".equals(qName))
                     {
                         //String cName = this.captureBuffer();
                         //this.handlerClass = createClass(TagHandler.class, cName);
                         this.handlerClass = this.captureBufferEmptyNull();
                     }
                     else if ("component".equals(qName))
                     {
                         if (this.handlerClass != null)
                         {
                             //impl.putComponent(this.tagName, this.componentType, this.rendererType, this.handlerClass);
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletComponentTagImpl(this.componentType, this.rendererType, 
                                     this.handlerClass, null)));
                             this.handlerClass = null;
                         }
                         else if (this.resourceId != null)
                         {
                             //impl.putComponentFromResourceId(this.tagName, this.resourceId);
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletComponentTagImpl(null, null, null, this.resourceId)));
                             this.resourceId = null;
                             this.handlerClass = null;
                         }
                         else
                         {
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletComponentTagImpl(this.componentType, this.rendererType, null, null)));
                             this.handlerClass = null;
                             //impl.putComponent(this.tagName, this.componentType, this.rendererType);
                         }
                     }
                     else if ("converter-id".equals(qName))
                     {
                         this.converterId = this.captureBuffer();
                     }
                     else if ("converter".equals(qName))
                     {
                         if (this.handlerClass != null)
                         {
                             //impl.putConverter(this.tagName, this.converterId, handlerClass);
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletConverterTagImpl(this.converterId, this.handlerClass)));
                             this.handlerClass = null;
                         }
                         else
                         {
                             //impl.putConverter(this.tagName, this.converterId);
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletConverterTagImpl(this.converterId)));
                         }
                         this.converterId = null;
                     }
                     else if ("validator-id".equals(qName))
                     {
                         this.validatorId = this.captureBuffer();
                     }
                     else if ("validator".equals(qName))
                     {
                         if (this.handlerClass != null)
                         {
                             //impl.putValidator(this.tagName, this.validatorId, handlerClass);
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletValidatorTagImpl(this.validatorId, this.handlerClass)));
                             this.handlerClass = null;
                         }
                         else
                         {
                             //impl.putValidator(this.tagName, this.validatorId);
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletValidatorTagImpl(this.validatorId)));
                         }
                         this.validatorId = null;
                     }
                     else if ("behavior-id".equals(qName))
                     {
                         this.behaviorId = this.captureBuffer();
                     }
                     else if ("behavior".equals(qName))
                     {
                         if (this.handlerClass != null)
                         {
                             //impl.putBehavior(this.tagName, this.behaviorId, handlerClass);
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletBehaviorTagImpl(this.behaviorId, this.handlerClass)));
                             this.handlerClass = null;
                         }
                         else
                         {
                             //impl.putBehavior(this.tagName, this.behaviorId);
                             getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                                 new FaceletBehaviorTagImpl(this.behaviorId)));
                         }
                         this.behaviorId = null;
                     }
                     else if ("source".equals(qName))
                     {
                         String path = this.captureBuffer();
                         URL url = new URL(this.source, path);
                         //impl.putUserTag(this.tagName, url);
                         getLibraryImpl().addTag(new FaceletTagImpl(this.tagName,
                             new FaceletSourceTagImpl(url.toString())));
                     }
                     else if ("function-signature".equals(qName))
                     {
                         this.functionSignature = this.captureBuffer();
                         getLibraryImpl().addFunction(
                             new FaceletFunctionImpl(this.functionName, this.functionClass, functionSignature));
                         //Method m = createMethod(this.functionClass, this.functionSignature);
                         //impl.putFunction(this.functionName, m);
                     }
                 }
             }
             catch (Exception e)
             {
                 throw new SAXParseException("Error Handling [" + this.source + "@" + this.locator.getLineNumber()
                         + "," + this.locator.getColumnNumber() + "] <" + qName + ">", locator, e);
             }
         }
 
         private String captureBuffer() throws Exception
         {
             String s = this.buffer.toString().trim();
             if (s.length() == 0)
             {
                 throw new Exception("Value Cannot be Empty");
             }
             this.buffer.setLength(0);
             return s;
         }
         
         private String captureBufferEmptyNull() throws Exception
         {
             String s = this.buffer.toString().trim();
             if (s.length() == 0)
             {
                 //if is "" just set null instead
                 s = null;
             }
             this.buffer.setLength(0);
             return s;
         }        
 
         public InputSource resolveEntity(String publicId, String systemId) throws SAXException
         {
             if ("-//Sun Microsystems, Inc.//DTD Facelet Taglib 1.0//EN".equals(publicId))
             {
                 URL url = ClassUtils.getResource("org/apache/myfaces/resource/facelet-taglib_1_0.dtd");
                 return new InputSource(url.toExternalForm());
             }
             return null;
         }
 
         public void characters(char[] ch, int start, int length) throws SAXException
         {
             this.buffer.append(ch, start, length);
         }
 
         public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException
         {
             this.buffer.setLength(0);
             if ("tag".equals(qName))
             {
                 this.handlerClass = null;
                 this.componentType = null;
                 this.rendererType = null;
                 this.tagName = null;
             }
             else if ("function".equals(qName))
             {
                 this.functionName = null;
                 this.functionClass = null;
                 this.functionSignature = null;
             }
         }
 
         public void error(SAXParseException e) throws SAXException
         {
             throw new SAXException(
                     "Error Handling [" + this.source + "@" + e.getLineNumber() + "," + e.getColumnNumber() + "]", e);
         }
 
         public void setDocumentLocator(Locator locator)
         {
             this.locator = locator;
         }
 
         public void fatalError(SAXParseException e) throws SAXException
         {
             throw e;
         }
 
         public void warning(SAXParseException e) throws SAXException
         {
             throw e;
         }
     }
 
 }