/*

  * 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.el.unified.resolver;

 import org.apache.myfaces.context.servlet.StartupServletExternalContextImpl;

 import javax.el.ELContext;

 import javax.el.ELException;

 import javax.el.ELResolver;

 import javax.el.PropertyNotFoundException;

 import javax.el.PropertyNotWritableException;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import java.beans.FeatureDescriptor;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 /**

  * See JSF 1.2 spec section 5.6.2.7

  * 

  * @author Stan Silvert

  */

 public class ScopedAttributeResolver extends ELResolver

 {

     /**

      * Creates a new instance of ScopedAttributeResolver

      */

     public ScopedAttributeResolver()

     {

     }

     @Override

     public void setValue(final ELContext context, final Object base, final Object property, final Object value)

         throws NullPointerException, PropertyNotFoundException, PropertyNotWritableException, ELException

     {

         if (base != null)

         {

             return;

         }

         if (property == null)

         {

             throw new PropertyNotFoundException();

         }

         final Map<String, Object> scopedMap = findScopedMap(facesContext(context), property);

         if (scopedMap != null)

         {

             scopedMap.put((String)property, value);

         }

         else

         {

             externalContext(context).getRequestMap().put((String)property, value);

         }

         context.setPropertyResolved(true);

     }

     @Override

     public boolean isReadOnly(final ELContext context, final Object base, final Object property)

         throws NullPointerException, PropertyNotFoundException, ELException

     {

         if (base == null)

         {

             context.setPropertyResolved(true);

         }

         return false;

     }

     @Override

     public Object getValue(final ELContext context, final Object base, final Object property)

         throws NullPointerException, PropertyNotFoundException, ELException

     {

         if (base != null)

         {

             return null;

         }

         if (property == null)

         {

             throw new PropertyNotFoundException();

         }

         context.setPropertyResolved(true);

         final Map<String, Object> scopedMap = findScopedMap(facesContext(context), property);

         if (scopedMap != null)

         {

             return scopedMap.get(property);

         }

         return null;

     }

     @Override

     public Class<?> getType(final ELContext context, final Object base, final Object property)

         throws NullPointerException, PropertyNotFoundException, ELException

     {

         if (base != null)

         {

             return null;

         }

         if (property == null)

         {

             throw new PropertyNotFoundException();

         }

         context.setPropertyResolved(true);

         return Object.class;

     }

     @Override

     public Iterator<FeatureDescriptor> getFeatureDescriptors(final ELContext context, final Object base)

     {

         if (base != null)

         {

             return null;

         }

         final List<FeatureDescriptor> descriptorList = new ArrayList<FeatureDescriptor>();

         final ExternalContext extContext = externalContext(context);

         addDescriptorsToList(descriptorList, extContext.getRequestMap());

         addDescriptorsToList(descriptorList, extContext.getSessionMap());

         addDescriptorsToList(descriptorList, extContext.getApplicationMap());

         return descriptorList.iterator();

     }

     @Override

     public Class<?> getCommonPropertyType(final ELContext context, final Object base)

     {

         if (base != null)

         {

             return null;

         }

         return String.class;

     }

     // side effect: modifies the list

     private static void addDescriptorsToList(final List<FeatureDescriptor> descriptorList,

                                              final Map<String, Object> scopeMap)

     {

         for (Object name : scopeMap.keySet())

         {

             String strName = (String)name;

             Class<?> runtimeType = scopeMap.get(strName).getClass();

             descriptorList.add(makeDescriptor(strName, runtimeType));

         }

     }

     private static FeatureDescriptor makeDescriptor(final String name, final Class<?> runtimeType)

     {

         FeatureDescriptor fd = new FeatureDescriptor();

         fd.setValue(ELResolver.RESOLVABLE_AT_DESIGN_TIME, Boolean.TRUE);

         fd.setValue(ELResolver.TYPE, runtimeType);

         fd.setName(name);

         fd.setDisplayName(name);

         fd.setShortDescription(name);

         fd.setExpert(false);

         fd.setHidden(false);

         fd.setPreferred(true);

         return fd;

     }

     // returns null if not found

     private static Map<String, Object> findScopedMap(final FacesContext facesContext, final Object property)

     {

         if (facesContext == null)

         {

             return null;

         }

         final ExternalContext extContext = facesContext.getExternalContext();

         if (extContext == null)

         {

             return null;

         }

         final boolean startup = (extContext instanceof StartupServletExternalContextImpl);

         Map<String, Object> scopedMap;

         // request scope (not available at startup)

         if (!startup)

         {

             scopedMap = extContext.getRequestMap();

             if (scopedMap.containsKey(property))

             {

                 return scopedMap;

             }

         }

         // jsf 2.0 view scope

         UIViewRoot root = facesContext.getViewRoot();

         if (root != null)

         {

             scopedMap = root.getViewMap(false);

             if (scopedMap != null && scopedMap.containsKey(property))

             {

                 return scopedMap;

             }

         }

         // session scope (not available at startup)

         if (!startup)

         {

             scopedMap = extContext.getSessionMap();

             if (scopedMap.containsKey(property))

             {

                 return scopedMap;

             }

         }

         // application scope

         scopedMap = extContext.getApplicationMap();

         if (scopedMap.containsKey(property))

         {

             return scopedMap;

         }

         // not found

         return null;

     }

     // get the FacesContext from the ELContext

     private static FacesContext facesContext(final ELContext context)

     {

         return (FacesContext)context.getContext(FacesContext.class);

     }

     private static ExternalContext externalContext(final ELContext context)

     {

         FacesContext facesContext = facesContext(context);

         if (facesContext != null)

         {

             return facesContext(context).getExternalContext();

         }

         return null;

     }

 }