/*
    * 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 org.apache.myfaces.shared.util.ArrayUtils;
  import org.apache.myfaces.shared.util.StringUtils;
  import org.apache.myfaces.shared.util.WebConfigParamUtils;
  import org.apache.myfaces.view.facelets.tag.AbstractTagLibrary;
  import org.apache.myfaces.view.facelets.tag.TagLibrary;
  import org.apache.myfaces.view.facelets.tag.composite.CompositeComponentResourceTagHandler;
  import org.apache.myfaces.view.facelets.tag.composite.CompositeResouceWrapper;
  import org.apache.myfaces.view.facelets.util.ParameterCheck;
  import org.apache.myfaces.view.facelets.util.ReflectionUtil;
  
  import javax.faces.FacesException;
  import javax.faces.application.Resource;
  import javax.faces.application.ResourceHandler;
  import javax.faces.application.ViewHandler;
  import javax.faces.context.ExternalContext;
  import javax.faces.context.FacesContext;
  import javax.faces.view.facelets.ComponentConfig;
  import javax.faces.view.facelets.FaceletHandler;
  import javax.faces.view.facelets.Tag;
  import javax.faces.view.facelets.TagConfig;
  import javax.faces.view.facelets.TagHandler;
  import java.lang.reflect.Method;
  import java.net.URL;
  import java.util.logging.Logger;
  import java.util.regex.Pattern;
  import org.apache.myfaces.config.element.facelets.FaceletBehaviorTag;
  import org.apache.myfaces.config.element.facelets.FaceletComponentTag;
  import org.apache.myfaces.config.element.facelets.FaceletConverterTag;
  import org.apache.myfaces.config.element.facelets.FaceletFunction;
  import org.apache.myfaces.config.element.facelets.FaceletHandlerTag;
  import org.apache.myfaces.config.element.facelets.FaceletSourceTag;
  import org.apache.myfaces.config.element.facelets.FaceletTag;
  import org.apache.myfaces.config.element.facelets.FaceletTagLibrary;
  import org.apache.myfaces.config.element.facelets.FaceletValidatorTag;
  
  /**
   * Handles creating a {@link org.apache.myfaces.view.facelets.tag.TagLibrary TagLibrary}
   * from a {@link java.net.URL URL} source.
   * 
   * @author Jacob Hookom
   * @version $Id$
   */
  public final class TagLibraryConfig
  {
  
      //private final static String SUFFIX = ".taglib.xml";
  
      //protected final static Logger log = Logger.getLogger("facelets.compiler");
      protected final static Logger log = Logger.getLogger(TagLibraryConfig.class.getName());
  
      private static class TagLibraryImpl extends AbstractTagLibrary
      {
          private String _compositeLibraryName;
          
          private final ResourceHandler _resourceHandler;
          private Pattern _acceptPatterns;
          private String _extension;
          private String[] _defaultSuffixesArray;
          
          public TagLibraryImpl(FacesContext facesContext, String namespace)
          {
              super(namespace);
              _compositeLibraryName = null;
              _resourceHandler = facesContext.getApplication().getResourceHandler();
              ExternalContext externalContext = facesContext.getExternalContext();
              
              _acceptPatterns = loadAcceptPattern(externalContext);
  
              _extension = loadFaceletExtension(externalContext);
              
              String defaultSuffixes = WebConfigParamUtils.getStringInitParameter(externalContext,
                      ViewHandler.DEFAULT_SUFFIX_PARAM_NAME, ViewHandler.DEFAULT_SUFFIX );
              
              _defaultSuffixesArray = StringUtils.splitShortString(defaultSuffixes, ' ');
              
              boolean faceletsExtensionFound = false;
              for (String ext : _defaultSuffixesArray)
              {
                  if (_extension.equals(ext))
                 {
                     faceletsExtensionFound = true;
                     break;
                 }
             }
             if (!faceletsExtensionFound)
             {
                 _defaultSuffixesArray = (String[]) ArrayUtils.concat(_defaultSuffixesArray, new String[]{_extension});
             }
         }
         
         /**
          * Load and compile a regular expression pattern built from the Facelet view mapping parameters.
          * 
          * @param context
          *            the application's external context
          * 
          * @return the compiled regular expression
          */
         private Pattern loadAcceptPattern(ExternalContext context)
         {
             assert context != null;
 
             String mappings = context.getInitParameter(ViewHandler.FACELETS_VIEW_MAPPINGS_PARAM_NAME);
             if (mappings == null)
             {
                 return null;
             }
 
             // Make sure the mappings contain something
             mappings = mappings.trim();
             if (mappings.length() == 0)
             {
                 return null;
             }
 
             return Pattern.compile(toRegex(mappings));
         }
 
         private String loadFaceletExtension(ExternalContext context)
         {
             assert context != null;
 
             String suffix = context.getInitParameter(ViewHandler.FACELETS_SUFFIX_PARAM_NAME);
             if (suffix == null)
             {
                 suffix = ViewHandler.DEFAULT_FACELETS_SUFFIX;
             }
             else
             {
                 suffix = suffix.trim();
                 if (suffix.length() == 0)
                 {
                     suffix = ViewHandler.DEFAULT_FACELETS_SUFFIX;
                 }
             }
 
             return suffix;
         }
         
         /**
          * Convert the specified mapping string to an equivalent regular expression.
          * 
          * @param mappings
          *            le mapping string
          * 
          * @return an uncompiled regular expression representing the mappings
          */
         private String toRegex(String mappings)
         {
             assert mappings != null;
 
             // Get rid of spaces
             mappings = mappings.replaceAll("\\s", "");
 
             // Escape '.'
             mappings = mappings.replaceAll("\\.", "\\\\.");
 
             // Change '*' to '.*' to represent any match
             mappings = mappings.replaceAll("\\*", ".*");
 
             // Split the mappings by changing ';' to '|'
             mappings = mappings.replaceAll(";", "|");
 
             return mappings;
         }
         
         public boolean handles(String resourceName)
         {
             if (resourceName == null)
             {
                 return false;
             }
             // Check extension first as it's faster than mappings
             if (resourceName.endsWith(_extension))
             {
                 // If the extension matches, it's a Facelet viewId.
                 return true;
             }
 
             // Otherwise, try to match the view identifier with the facelet mappings
             return _acceptPatterns != null && _acceptPatterns.matcher(resourceName).matches();
         }
         
         @Override
         public boolean containsTagHandler(String ns, String localName)
         {
             boolean result = super.containsTagHandler(ns, localName);
             
             if (!result && _compositeLibraryName != null && containsNamespace(ns))
             {
                 for (String defaultSuffix : _defaultSuffixesArray)
                 {
                     String resourceName = localName + defaultSuffix;
                     if (handles(resourceName))
                     {
                         Resource compositeComponentResource = _resourceHandler.createResource(
                                 resourceName, _compositeLibraryName);
                         
                         if (compositeComponentResource != null)
                         {
                             URL url = compositeComponentResource.getURL();
                             return (url != null);
                         }
                     }
                 }
             }
             return result;
         }
         
         @Override
         public TagHandler createTagHandler(String ns, String localName,
                 TagConfig tag) throws FacesException
         {
             TagHandler tagHandler = super.createTagHandler(ns, localName, tag);
             
             if (tagHandler == null && _compositeLibraryName != null && containsNamespace(ns))
             {
                 for (String defaultSuffix : _defaultSuffixesArray)
                 {
                     String resourceName = localName + defaultSuffix;
                     if (handles(resourceName))
                     {
                         // MYFACES-3308 If a composite component exists, it requires to 
                         // be always resolved. In other words, it should always exists a default.
                         // The call here for resourceHandler.createResource, just try to get
                         // the Resource and if it does not exists, it just returns null.
                         // The intention of this code is just create an instance and pass to
                         // CompositeComponentResourceTagHandler. Then, its values 
                         // (resourceName, libraryName) will be used to derive the real instance
                         // to use in a view, based on the locale used.
                         Resource compositeComponentResource = new CompositeResouceWrapper(
                             _resourceHandler.createResource(resourceName, _compositeLibraryName));
                         
                         if (compositeComponentResource != null)
                         {
                             ComponentConfig componentConfig = new ComponentConfigWrapper(tag,
                                     "javax.faces.NamingContainer", null);
                             
                             return new CompositeComponentResourceTagHandler(
                                     componentConfig, compositeComponentResource);
                         }
                     }
                 }
             }
             return tagHandler;
         }
 
         public void setCompositeLibrary(String compositeLibraryName)
         {
             _compositeLibraryName = compositeLibraryName;
         }
 
         public void putConverter(String name, String id)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("id", id);
             this.addConverter(name, id);
         }
 
         public void putConverter(String name, String id, Class<? extends TagHandler> handlerClass)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("id", id);
             ParameterCheck.notNull("handlerClass", handlerClass);
             this.addConverter(name, id, handlerClass);
         }
 
         public void putValidator(String name, String id)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("id", id);
             this.addValidator(name, id);
         }
 
         public void putValidator(String name, String id, Class<? extends TagHandler> handlerClass)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("id", id);
             ParameterCheck.notNull("handlerClass", handlerClass);
             this.addValidator(name, id, handlerClass);
         }
 
         public void putTagHandler(String name, Class<? extends TagHandler> type)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("type", type);
             this.addTagHandler(name, type);
         }
         
         public void putComponentFromResourceId(String name, String resourceId)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("resourceId", resourceId);
             this.addComponentFromResourceId(name, resourceId);
         }
 
         public void putComponent(String name, String componentType, String rendererType)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("componentType", componentType);
             this.addComponent(name, componentType, rendererType);
         }
 
         public void putComponent(String name, String componentType, String rendererType, 
                                  Class<? extends TagHandler> handlerClass)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("componentType", componentType);
             ParameterCheck.notNull("handlerClass", handlerClass);
             this.addComponent(name, componentType, rendererType, handlerClass);
         }
 
         public void putUserTag(String name, URL source)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("source", source);
             this.addUserTag(name, source);
         }
 
         public void putFunction(String name, Method method)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("method", method);
             this.addFunction(name, method);
         }
         
         public void putBehavior(String name, String id)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("id", id);
             this.addBehavior(name, id);
         }
         
         public void putBehavior(String name, String id, Class<? extends TagHandler> handlerClass)
         {
             ParameterCheck.notNull("name", name);
             ParameterCheck.notNull("id", id);
             ParameterCheck.notNull("handlerClass", handlerClass);
             this.addBehavior(name, id, handlerClass);
         }
     }
     
     private static class ComponentConfigWrapper implements ComponentConfig
     {
 
         protected final TagConfig parent;
 
         protected final String componentType;
 
         protected final String rendererType;
 
         public ComponentConfigWrapper(TagConfig parent, String componentType,
                 String rendererType)
         {
             this.parent = parent;
             this.componentType = componentType;
             this.rendererType = rendererType;
         }
 
         public String getComponentType()
         {
             return this.componentType;
         }
 
         public String getRendererType()
         {
             return this.rendererType;
         }
 
         public FaceletHandler getNextHandler()
         {
             return this.parent.getNextHandler();
         }
 
         public Tag getTag()
         {
             return this.parent.getTag();
         }
 
         public String getTagId()
         {
             return this.parent.getTagId();
         }
     }    
 
     public TagLibraryConfig()
     {
         super();
     }
     
     public static TagLibrary create(FacesContext facesContext, FaceletTagLibrary faceletTagLibrary)
     {
         if (isNotEmpty(faceletTagLibrary.getLibraryClass()))
         {
             TagLibrary t = null;
             Class<?> type;
             try
             {
                 type = createClass(TagLibrary.class, faceletTagLibrary.getLibraryClass());
                 t = (TagLibrary) type.newInstance();
             }
             catch (Exception ex)
             {
                 throw new FacesException("Cannot instantiate TagLibrary", ex);
             }
             // No further processing required.
             return t;
         }
         
         TagLibraryImpl impl = new TagLibraryImpl(facesContext, faceletTagLibrary.getNamespace());
         
         impl.setCompositeLibrary(faceletTagLibrary.getCompositeLibraryName());
         
         for (FaceletFunction ff : faceletTagLibrary.getFunctions())
         {
             try
             {
                 Class<?> functionClass = createClass(Object.class, ff.getFunctionClass());
                 impl.putFunction(ff.getFunctionName(), createMethod(functionClass, ff.getFunctionSignature()));
             }
             catch (Exception ex)
             {
                 throw new FacesException("Cannot instantiate Function Class", ex);
             }
         }
         
         for (FaceletTag ft : faceletTagLibrary.getTags())
         {
             try
             {
                 if (ft.isHandlerTag())
                 {
                     FaceletHandlerTag tag = (FaceletHandlerTag) ft.getTagDefinition();
                     if (tag.getHandlerClass() != null)
                     {
                         Class<? extends TagHandler> handlerClass = 
                             createClass(TagHandler.class, tag.getHandlerClass());
                         impl.putTagHandler(ft.getName(), handlerClass);
                     }
                 }
                 else if (ft.isComponentTag())
                 {
                     FaceletComponentTag tag = (FaceletComponentTag) ft.getTagDefinition();
                     if (tag.getHandlerClass() != null)
                     {
                         Class<? extends TagHandler> handlerClass = 
                             createClass(TagHandler.class, tag.getHandlerClass());
                         impl.putComponent(ft.getName(), tag.getComponentType(), tag.getRendererType(), handlerClass);
                     }
                     else if (tag.getResourceId() != null)
                     {
                         impl.putComponentFromResourceId(ft.getName(), tag.getResourceId());
                     }
                     else 
                     {
                         impl.putComponent(ft.getName(), tag.getComponentType(), tag.getRendererType());
                     }
                 }
                 else if (ft.isSourceTag())
                 {
                     FaceletSourceTag tag = (FaceletSourceTag) ft.getTagDefinition();
                     impl.putUserTag(ft.getName(), new URL(tag.getSource()));
                 }
                 else if (ft.isConverterTag())
                 {
                     FaceletConverterTag tag = (FaceletConverterTag) ft.getTagDefinition();
                     if (tag.getHandlerClass() != null)
                     {
                         Class<? extends TagHandler> handlerClass = 
                             createClass(TagHandler.class, tag.getHandlerClass());
                         impl.putConverter(ft.getName(), tag.getConverterId(), handlerClass);
                     }
                     else
                     {
                         impl.putConverter(ft.getName(), tag.getConverterId());
                     }
                 }
                 else if (ft.isValidatorTag())
                 {
                     FaceletValidatorTag tag = (FaceletValidatorTag) ft.getTagDefinition();
                     if (tag.getHandlerClass() != null)
                     {
                         Class<? extends TagHandler> handlerClass = 
                             createClass(TagHandler.class, tag.getHandlerClass());
                         impl.putValidator(ft.getName(), tag.getValidatorId(), handlerClass);
                     }
                     else
                     {
                         impl.putValidator(ft.getName(), tag.getValidatorId());
                     }
                 }
                 else if (ft.isBehaviorTag())
                 {
                     FaceletBehaviorTag tag = (FaceletBehaviorTag) ft.getTagDefinition();
                     if (tag.getHandlerClass() != null)
                     {
                         Class<? extends TagHandler> handlerClass = 
                             createClass(TagHandler.class, tag.getHandlerClass());
                         impl.putBehavior(ft.getName(), tag.getBehaviorId(), handlerClass);
                     }
                     else
                     {
                         impl.putBehavior(ft.getName(), tag.getBehaviorId());
                     }
                 }
             }
             catch (Exception ex)
             {
                 throw new FacesException("Cannot instantiate Tag "+ft.getName()+" from namespace "+
                     faceletTagLibrary.getNamespace(), ex);
             }
         }
         return impl;
     }
     
     @SuppressWarnings("unchecked")
     private static <T> Class<? extends T> createClass(Class<T> type, String name) throws Exception
     {
         Class<? extends T> factory = (Class<? extends T>)ReflectionUtil.forName(name);
         if (!type.isAssignableFrom(factory))
         {
             throw new Exception(name + " must be an instance of " + type.getName());
         }
         return factory;
     }
 
     private static Method createMethod(Class<?> type, String s) throws Exception
     {
         int pos = s.indexOf(' ');
         if (pos == -1)
         {
             throw new Exception("Must Provide Return Type: " + s);
         }
         else
         {
             int pos2 = s.indexOf('(', pos + 1);
             if (pos2 == -1)
             {
                 throw new Exception("Must provide a method name, followed by '(': " + s);
             }
             else
             {
                 String mn = s.substring(pos + 1, pos2).trim();
                 pos = s.indexOf(')', pos2 + 1);
                 if (pos == -1)
                 {
                     throw new Exception("Must close parentheses, ')' missing: " + s);
                 }
                 else
                 {
                     String[] ps = s.substring(pos2 + 1, pos).trim().split(",");
                     Class<?>[] pc;
                     if (ps.length == 1 && "".equals(ps[0]))
                     {
                         pc = new Class[0];
                     }
                     else
                     {
                         pc = new Class[ps.length];
                         for (int i = 0; i < pc.length; i++)
                         {
                             pc[i] = ReflectionUtil.forName(ps[i].trim());
                         }
                     }
                     try
                     {
                         return type.getMethod(mn, pc);
                     }
                     catch (NoSuchMethodException e)
                     {
                         throw new Exception("No Function Found on type: " + type.getName() + " with signature: "
                                 + s);
                     }
 
                 }
 
             }
         }
     }
 
     private static boolean isNotEmpty(String value)
     {
         return value != null && value.length() > 0;
     }
 
 }