/*

  * 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;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.Set;

 import javax.faces.component.StateHolder;

 import javax.faces.context.FacesContext;

 import javax.faces.event.PreDestroyViewMapEvent;

 import org.apache.myfaces.spi.ViewScopeProvider;

 import org.apache.myfaces.spi.ViewScopeProviderFactory;

 /**

  * This wrapper has these objectives:

  * 

  * - Isolate the part that needs to be saved with the view (viewScopeId) from

  *   the part that should remain into session (bean map). This class will be

  *   serialized when UIViewRoot.saveState() is called.

  * - Decouple the way how the view scope map is stored. For example, in 

  *   CDI view scope a session scope bean is used, and in default view scope

  *   the same session map is used but using a prefix.

  *

  * @author Leonardo Uribe

  */

 public class ViewScopeProxyMap implements Map<String, Object>, StateHolder

 {

     private String _viewScopeId;

     private transient Map<String, Object> _delegate;

     public ViewScopeProxyMap()

     {

     }

     public String getViewScopeId()

     {

         return _viewScopeId;

     }

     public void forceCreateWrappedMap(FacesContext facesContext)

     {

         getWrapped();

     }

     public Map<String, Object> getWrapped()

     {

         if (_delegate == null)

         {

             FacesContext facesContext = FacesContext.getCurrentInstance();

             if (facesContext != null)

             {

                 ViewScopeProviderFactory factory = ViewScopeProviderFactory.getViewScopeHandlerFactory(

                     facesContext.getExternalContext());

                 ViewScopeProvider handler = factory.getViewScopeHandler(facesContext.getExternalContext());

                 if (_viewScopeId == null)

                 {

                     _viewScopeId = handler.generateViewScopeId(facesContext);

                     _delegate = handler.createViewScopeMap(facesContext, _viewScopeId);

                 }

                 else

                 {

                     _delegate = handler.restoreViewScopeMap(facesContext, _viewScopeId);

                 }

             }

             else

             {

                 // In junit test cases, where there is no facesContext instance, it is enough to

                 // just get a blank instance.

                 _delegate = new ViewScope();

             }

         }

         return _delegate;

     }

     public int size()

     {

         return getWrapped().size();

     }

     public boolean isEmpty()

     {

         return getWrapped().isEmpty();

     }

     public boolean containsKey(Object key)

     {

         return getWrapped().containsKey(key);

     }

     public boolean containsValue(Object value)

     {

         return getWrapped().containsValue(value);

     }

     public Object get(Object key)

     {

         return getWrapped().get(key);

     }

     public Object put(String key, Object value)

     {

         return getWrapped().put(key, value);

     }

     public Object remove(Object key)

     {

         return getWrapped().remove(key);

     }

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

     {

         getWrapped().putAll(m);

     }

     public void clear()

     {

         /*

          * The returned Map must be implemented such that calling clear() on the Map causes

          * Application.publishEvent(java.lang.Class, java.lang.Object) to be called, passing

          * ViewMapDestroyedEvent.class as the first argument and this UIViewRoot instance as the second argument.

          */

         FacesContext facesContext = FacesContext.getCurrentInstance();

         facesContext.getApplication().publishEvent(facesContext, 

                 PreDestroyViewMapEvent.class, facesContext.getViewRoot());

         getWrapped().clear();

     }

     public Set<String> keySet()

     {

         return getWrapped().keySet();

     }

     public Collection<Object> values()

     {

         return getWrapped().values();

     }

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

     {

         return getWrapped().entrySet();

     }

     public void restoreState(FacesContext context, Object state)

     {

         _viewScopeId = (String) state;

     }

     public Object saveState(FacesContext context)

     {

         return _viewScopeId;

     }

     public boolean isTransient()

     {

         return false;

     }

     public void setTransient(boolean newTransientValue)

     {

     }

     private static class ViewScope extends HashMap<String, Object>

     {

         private static final long serialVersionUID = -1088293802269478164L;

         @Override

         public void clear()

         {

             /*

              * The returned Map must be implemented such that calling clear() on the Map causes

              * Application.publishEvent(java.lang.Class, java.lang.Object) to be called, passing

              * ViewMapDestroyedEvent.class as the first argument and this UIViewRoot instance as the second argument.

              */

             FacesContext facesContext = FacesContext.getCurrentInstance();

             facesContext.getApplication().publishEvent(facesContext, 

                     PreDestroyViewMapEvent.class, facesContext.getViewRoot());

             super.clear();

         }

     }

 }