/*

  * 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.tag.composite;

 import org.apache.myfaces.view.facelets.tag.BeanPropertyTagRule;

 import org.apache.myfaces.view.facelets.tag.MetadataImpl;

 import org.apache.myfaces.view.facelets.tag.MetadataTargetImpl;

 import org.apache.myfaces.view.facelets.util.ParameterCheck;

 import javax.faces.context.FacesContext;

 import javax.faces.view.facelets.FaceletContext;

 import javax.faces.view.facelets.MetaRule;

 import javax.faces.view.facelets.MetaRuleset;

 import javax.faces.view.facelets.Metadata;

 import javax.faces.view.facelets.MetadataTarget;

 import javax.faces.view.facelets.Tag;

 import javax.faces.view.facelets.TagAttribute;

 import javax.faces.view.facelets.TagException;

 import java.beans.BeanInfo;

 import java.beans.IntrospectionException;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 public class CompositeMetaRulesetImpl extends MetaRuleset

 {

     private final static Metadata NONE = new NullMetadata();

     //private final static Logger log = Logger.getLogger("facelets.tag.meta");

     private final static Logger log = Logger.getLogger(CompositeMetadataTargetImpl.class.getName());

     private static final String METADATA_KEY

             = "org.apache.myfaces.view.facelets.tag.composite.CompositeMetaRulesetImpl.METADATA";

     private static Map<String, MetadataTarget> getMetaData()

     {

         FacesContext facesContext = FacesContext.getCurrentInstance();

         Map<String, Object> applicationMap = facesContext

                 .getExternalContext().getApplicationMap();

         Map<String, MetadataTarget> metadata =

                 (Map<String, MetadataTarget>) applicationMap.get(METADATA_KEY);

         if (metadata == null)

         {

             metadata = new HashMap<String, MetadataTarget>();

             applicationMap.put(METADATA_KEY, metadata);

         }

         return metadata;

     }

     private final Map<String, TagAttribute> _attributes;

     private final List<Metadata> _mappers;

     private final List<MetaRule> _rules;

     private final Tag _tag;

     private final Class<?> _type;

     private final MetadataTarget _meta;

     public CompositeMetaRulesetImpl(Tag tag, Class<?> type, BeanInfo beanInfo)

     {

         _tag = tag;

         _type = type;

         _attributes = new HashMap<String, TagAttribute>();

         _mappers = new ArrayList<Metadata>();

         _rules = new ArrayList<MetaRule>();

         // setup attributes

         for (TagAttribute attribute : _tag.getAttributes().getAll())

         {

             _attributes.put(attribute.getLocalName(), attribute);

         }

         // add default rules

         _rules.add(BeanPropertyTagRule.INSTANCE);

         try

         {

             _meta = new CompositeMetadataTargetImpl(_getBaseMetadataTarget(), beanInfo);            

         }

         catch (IntrospectionException e)

         {

             throw new TagException(_tag, "Error Creating TargetMetadata", e);

         }

     }

     public MetaRuleset add(Metadata mapper)

     {

         ParameterCheck.notNull("mapper", mapper);

         if (!_mappers.contains(mapper))

         {

             _mappers.add(mapper);

         }

         return this;

     }

     public MetaRuleset addRule(MetaRule rule)

     {

         ParameterCheck.notNull("rule", rule);

         _rules.add(rule);

         return this;

     }

     public MetaRuleset alias(String attribute, String property)

     {

         ParameterCheck.notNull("attribute", attribute);

         ParameterCheck.notNull("property", property);

         TagAttribute attr = (TagAttribute) _attributes.remove(attribute);

         if (attr != null)

         {

             _attributes.put(property, attr);

         }

         return this;

     }

     public Metadata finish()

     {

         assert !_rules.isEmpty();

         if (!_attributes.isEmpty())

         {

             MetadataTarget target = this._getMetadataTarget();

             int ruleEnd = _rules.size() - 1;

             // now iterate over attributes

             for (Map.Entry<String, TagAttribute> entry : _attributes.entrySet())

             {

                 Metadata data = null;

                 int i = ruleEnd;

                 // First loop is always safe

                 do

                 {

                     MetaRule rule = _rules.get(i);

                     data = rule.applyRule(entry.getKey(), entry.getValue(), target);

                     i--;

                 } while (data == null && i >= 0);

                 if (data == null)

                 {

                     if (log.isLoggable(Level.SEVERE))

                     {

                         log.severe(entry.getValue() + " Unhandled by MetaTagHandler for type " + _type.getName());

                     }

                 }

                 else

                 {

                     _mappers.add(data);

                 }

             }

         }

         if (_mappers.isEmpty())

         {

             return NONE;

         }

         else

         {

             return new MetadataImpl(_mappers.toArray(new Metadata[_mappers.size()]));

         }

     }

     public MetaRuleset ignore(String attribute)

     {

         ParameterCheck.notNull("attribute", attribute);

         _attributes.remove(attribute);

         return this;

     }

     public MetaRuleset ignoreAll()

     {

         _attributes.clear();

         return this;

     }

     private final MetadataTarget _getMetadataTarget()

     {

         return _meta;

     }

     private final MetadataTarget _getBaseMetadataTarget()

     {

         Map<String, MetadataTarget> metadata = getMetaData();

         String key = _type.getName();

         MetadataTarget meta = metadata.get(key);

         if (meta == null)

         {

             try

             {

                 meta = new MetadataTargetImpl(_type);

             }

             catch (IntrospectionException e)

             {

                 throw new TagException(_tag, "Error Creating TargetMetadata", e);

             }

             metadata.put(key, meta);

         }

         return meta;

     }    

     private static class NullMetadata extends Metadata

     {

         /**

          * {@inheritDoc}

          */

         @Override

         public void applyMetadata(FaceletContext ctx, Object instance)

         {

             // do nothing

         }

     }

 }