/*

  * 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 java.beans.BeanDescriptor;

 import java.beans.PropertyDescriptor;

 import java.beans.SimpleBeanInfo;

 import java.io.Externalizable;

 import java.io.IOException;

 import java.io.ObjectInput;

 import java.io.ObjectOutput;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import javax.faces.view.AttachedObjectTarget;

 /**

  * Implementation of BeanInfo object used by composite components.

  * Instances of this class are found on component attribute map

  * using the key UIComponent.BEANINFO_KEY.

  * 

  * The points to take into account for implement this class are this:

  * 

  * - The following tags:

  * 

  *    composite:interface

  *    composite:attribute

  *    composite:facet

  *    composite:valueHolder

  *    composite:editableValueHolder

  *    composite:actionSource

  *    composite:extension

  *    

  *    must deal with this class, so it is expected methods that manipulate

  *    data here are called from their tag handlers.

  *    

  * - ViewDeclarationLanguage.retargetAttachedObjects and 

  *   ViewDeclarationLanguage.retargetMethodExpressions read information

  *   contained here

  * 

  * - This object goes on attribute map, so it is necessary that

  *   this instance should be Serializable. But note that BeanDescriptor

  *   is not, so the best way is implements Externalizable interface

  *   and implement its methods. The only information we need to be Serializable

  *   from this object is the related to BeanDescriptor, but note that

  *   serialize information used only in build view time ( like

  *   AttachedObjectTarget.ATTACHED_OBJECT_TARGETS_KEY list) is not required 

  *   and could cause serialization exceptions. 

  * 

  * @author Leonardo Uribe (latest modification by $Author$)

  * @version $Revision$ $Date$

  */

 public class CompositeComponentBeanInfo extends SimpleBeanInfo 

     implements Externalizable

 {

     public static final String PROPERTY_DESCRIPTOR_MAP_KEY = "oam.cc.beanInfo.PDM";

     /**

      * Most of the information here are filled on composite:interface tag.

      * It is also expected that AttachedObjectTarget.ATTACHED_OBJECT_TARGETS_KEY

      * key is used by other handlers inside the inner map for this BeanDescriptor.

      */

     private BeanDescriptor _descriptor;

     /**

      * ViewDeclarationLanguage.retargetMethodExpressions algorithm

      * suggest that every attribute should have a PropertyDescriptor

      * object defined for it. So, this list is expected to be filled

      * on composite:attribute tag. This list is used only when

      * retargetAttachedObjects and retargetAttachedMethodExpressions,

      * and this methods are called only on buildView time, so

      * we don't need to Serialize this list. 

      */

     private List<PropertyDescriptor> _propertyDescriptors;

     private static final PropertyDescriptor[] EMPTY_PROPERTY_DESCRIPTOR_ARRAY = new PropertyDescriptor[0];

     private PropertyDescriptor[] _propertyDescriptorsArray;

     private Map<String, PropertyDescriptor> _propertyDescriptorsMap;

     /**

      * Used for Serialization

      */

     public CompositeComponentBeanInfo()

     {

         super();

     }

     public CompositeComponentBeanInfo(BeanDescriptor descriptor)

     {

         super();

         _descriptor = descriptor;

         getBeanDescriptor().setValue(PROPERTY_DESCRIPTOR_MAP_KEY, new PropertyDescriptorMap());

     }

     @Override

     public BeanDescriptor getBeanDescriptor()

     {

         return _descriptor;

     }

     @Override

     public PropertyDescriptor[] getPropertyDescriptors()

     {

         if (_propertyDescriptors == null)

         {

             return EMPTY_PROPERTY_DESCRIPTOR_ARRAY;

         }

         else

         {

             if (_propertyDescriptorsArray == null)

             {

                 _propertyDescriptorsArray = _propertyDescriptors.toArray(

                         new PropertyDescriptor[_propertyDescriptors.size()]); 

             }

             else if (_propertyDescriptorsArray.length != _propertyDescriptors.size())

             {

                 _propertyDescriptorsArray = _propertyDescriptors.toArray(

                         new PropertyDescriptor[_propertyDescriptors.size()]);

             }

             return _propertyDescriptorsArray; 

         }

     }

     public List<PropertyDescriptor> getPropertyDescriptorsList()

     {

         if (_propertyDescriptors == null)

         {

             _propertyDescriptors = new ArrayList<PropertyDescriptor>();

         }

         return _propertyDescriptors;

     }

     public void setPropertyDescriptorsList(List<PropertyDescriptor> descriptors)

     {

         _propertyDescriptors = descriptors;

     }

     public void readExternal(ObjectInput in) throws IOException,

             ClassNotFoundException

     {

         Class beanClass = (Class) in.readObject();

         Class customizerClass = (Class) in.readObject();

         if (customizerClass == null)

         {

             _descriptor = new BeanDescriptor(beanClass);

         }

         else

         {

             _descriptor = new BeanDescriptor(beanClass, customizerClass);

         }

         _descriptor.setDisplayName((String) in.readObject());

         _descriptor.setExpert(in.readBoolean());

         _descriptor.setName((String) in.readObject());

         _descriptor.setPreferred(in.readBoolean());

         _descriptor.setShortDescription((String) in.readObject());

         _descriptor.setValue(PROPERTY_DESCRIPTOR_MAP_KEY, new PropertyDescriptorMap());

         Map<String,Object> map = (Map) in.readObject();

         for (Map.Entry<String, Object> entry : map.entrySet())

         {

             _descriptor.setValue(entry.getKey(), entry.getValue());

         }

         _propertyDescriptors = (List<PropertyDescriptor>) in.readObject();

     }

     public void writeExternal(ObjectOutput out) throws IOException

     {

         out.writeObject(_descriptor.getBeanClass());

         out.writeObject(_descriptor.getCustomizerClass());

         out.writeObject(_descriptor.getDisplayName());

         out.writeBoolean(_descriptor.isExpert());

         out.writeObject(_descriptor.getName());

         out.writeBoolean(_descriptor.isPreferred());

         out.writeObject(_descriptor.getShortDescription());

         Map<String,Object> map = new HashMap<String, Object>(4,1);

         for (Enumeration<String> e = _descriptor.attributeNames(); e.hasMoreElements();)

         {

             String name = e.nextElement();

             // It is not necessary to serialize AttachedObjectTarget list because

             // we only use it when VDL.retargetAttachedObjects() is called and this only

             // happen when the view is built. Also, try to serialize this instances could

             // cause unwanted exceptions.

             if (!AttachedObjectTarget.ATTACHED_OBJECT_TARGETS_KEY.equals(name) &&

                 !PROPERTY_DESCRIPTOR_MAP_KEY.equals(name))

             {

                 map.put(name, _descriptor.getValue(name));

             }

         }

         out.writeObject(map);

         out.writeObject(_propertyDescriptors);

     }

     public Map<String, PropertyDescriptor> getPropertyDescriptorsMap()

     {

         if (_propertyDescriptors == null)

         {

             return Collections.emptyMap();

         }

         else

         {

             if (_propertyDescriptors.isEmpty())

             {

                 return Collections.emptyMap();

             }

             else if (_propertyDescriptorsMap == null)

             {

                 int initCapacity = (_propertyDescriptors.size() * 4 + 3) / 3;

                 _propertyDescriptorsMap = new HashMap<String, PropertyDescriptor>(initCapacity);

                 for (PropertyDescriptor p : _propertyDescriptors)

                 {

                     if (!_propertyDescriptorsMap.containsKey(p.getName()))

                     {

                         _propertyDescriptorsMap.put(p.getName(), p);

                     }

                 }

             }

             else if (_propertyDescriptorsMap.size() != _propertyDescriptors.size())

             {

                 for (PropertyDescriptor p : _propertyDescriptors)

                 {

                     if (!_propertyDescriptorsMap.containsKey(p.getName()))

                     {

                         _propertyDescriptorsMap.put(p.getName(), p);

                     }

                 }

                 if (_propertyDescriptorsMap.size() != _propertyDescriptors.size())

                 {

                     // PropertyDescriptor was removed

                     _propertyDescriptorsMap.clear();

                     for (PropertyDescriptor p : _propertyDescriptors)

                     {

                         if (!_propertyDescriptorsMap.containsKey(p.getName()))

                         {

                             _propertyDescriptorsMap.put(p.getName(), p);

                         }

                     }

                 }

             }

             return _propertyDescriptorsMap;

         }

     }

     /**

      * Read only map for fast access. It works as an indirection over the real list.

      */

     public class PropertyDescriptorMap implements Map<String, PropertyDescriptor>

     {

         public int size()

         {

             return getPropertyDescriptorsMap().size();

         }

         public boolean isEmpty()

         {

             return getPropertyDescriptorsMap().isEmpty();

         }

         public boolean containsKey(Object key)

         {

             return getPropertyDescriptorsMap().containsKey(key);

         }

         public boolean containsValue(Object value)

         {

             return getPropertyDescriptorsMap().containsValue(value);

         }

         public PropertyDescriptor get(Object key)

         {

             return getPropertyDescriptorsMap().get(key);

         }

         public PropertyDescriptor put(String key, PropertyDescriptor value)

         {

             throw new UnsupportedOperationException();

         }

         public PropertyDescriptor remove(Object key)

         {

             throw new UnsupportedOperationException();

         }

         public void putAll(Map<? extends String, ? extends PropertyDescriptor> m)

         {

             throw new UnsupportedOperationException();

         }

         public void clear()

         {

             throw new UnsupportedOperationException();

         }

         public Set<String> keySet()

         {

             return getPropertyDescriptorsMap().keySet();

         }

         public Collection<PropertyDescriptor> values()

         {

             return getPropertyDescriptorsMap().values();

         }

         public Set<Entry<String, PropertyDescriptor>> entrySet()

         {

             return getPropertyDescriptorsMap().entrySet();

         }

     }

 }