/*

  * 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.cdi.view;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import javax.enterprise.inject.spi.BeanManager;

 import javax.faces.context.FacesContext;

 import org.apache.myfaces.cdi.util.CDIUtils;

 import org.apache.myfaces.cdi.util.ContextualInstanceInfo;

 /**

  *

  * @author Leonardo Uribe

  */

 public class ViewScopeCDIMap implements Map<String, Object>

 {

     private String _viewScopeId;

     private ViewScopeContextualStorage storage;

     public ViewScopeCDIMap(FacesContext facesContext)

     {

         BeanManager beanManager = CDIUtils.

             getBeanManager(facesContext.getExternalContext());

         ViewScopeBeanHolder bean = CDIUtils.lookup(

             beanManager, ViewScopeBeanHolder.class);

         // 1. get a new view scope id

         _viewScopeId = bean.generateUniqueViewScopeId();

         storage = bean.

             getContextualStorage(beanManager, _viewScopeId);

     }

     public ViewScopeCDIMap(FacesContext facesContext, String viewScopeId)

     {

         BeanManager beanManager = CDIUtils.

             getBeanManager(facesContext.getExternalContext());

         ViewScopeBeanHolder bean = CDIUtils.lookup(

             beanManager, ViewScopeBeanHolder.class);

         // 1. get a new view scope id

         _viewScopeId = viewScopeId;

         storage = bean.

             getContextualStorage(beanManager, _viewScopeId);

     }

     private ViewScopeContextualStorage getStorage()

     {

         if (storage != null && !storage.isActive())

         {

             storage = null;

         }

         if (storage == null)

         {

             FacesContext facesContext = FacesContext.getCurrentInstance();

             BeanManager beanManager = CDIUtils.

                 getBeanManager(facesContext.getExternalContext());

             ViewScopeBeanHolder bean = CDIUtils.lookup(

                 beanManager, ViewScopeBeanHolder.class);

             storage = bean.

                 getContextualStorage(beanManager, _viewScopeId);

         }

         return storage;

     }

     private Map<String, Object> getNameBeanKeyMap()

     {

         return getStorage().getNameBeanKeyMap();

     }

     private Map<Object, ContextualInstanceInfo<?>> getCreationalContextInstances()

     {

         return getStorage().getStorage();

     }

     public String getViewScopeId()

     {

         return _viewScopeId;

     }

     public int size()

     {

         return this.getNameBeanKeyMap().size();

     }

     public boolean isEmpty()

     {

         return this.getNameBeanKeyMap().isEmpty();

     }

     public boolean containsKey(Object key)

     {

         return this.getNameBeanKeyMap().containsKey(key);

     }

     public boolean containsValue(Object value)

     {

         if (value != null)

         {

             for (Map.Entry<Object, ContextualInstanceInfo<?>> entry : 

                 getCreationalContextInstances().entrySet())

             {

                 if (entry.getValue() != null &&

                     value.equals(entry.getValue().getContextualInstance()))

                 {

                     return true;

                 }

             }

         }

         return false;

     }

     public Object get(Object key)

     {

         Object beanKey = this.getNameBeanKeyMap().get(key);

         if (beanKey != null)

         {

             ContextualInstanceInfo<?> info = this.getCreationalContextInstances().get(beanKey);

             return info == null ? null : info.getContextualInstance();

         }

         return null;

     }

     public Object put(String key, Object value)

     {

         Object beanKey = new _ContextualKey(key);

         this.getNameBeanKeyMap().put(key, beanKey);

         ContextualInstanceInfo info = new ContextualInstanceInfo();

         info.setContextualInstance(value);

         return this.getCreationalContextInstances().put(beanKey, info);

     }

     public Object remove(Object key)

     {

         Object beanKey = this.getNameBeanKeyMap().remove(key);

         ContextualInstanceInfo info = this.getCreationalContextInstances().remove(beanKey);

         return info == null ? null : info.getContextualInstance();

     }

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

     {

         for (Map.Entry<? extends String, ? extends Object> entry : m.entrySet())

         {

             put(entry.getKey(), entry.getValue());

         }

     }

     public void clear()

     {

         boolean destroyed = false;

         // If the scope was already destroyed through an invalidateSession(), the storage instance

         // that is holding this map could be obsolete, so we need to grab the right instance from

         // the bean holder.

         FacesContext facesContext = FacesContext.getCurrentInstance();

         if (facesContext != null)

         {

             BeanManager beanManager = CDIUtils.

                 getBeanManager(facesContext.getExternalContext());

             if (beanManager != null)

             {

                 ViewScopeBeanHolder bean = CDIUtils.lookup(

                     beanManager, ViewScopeBeanHolder.class);

                 if (bean != null)

                 {

                     ViewScopeContextualStorage st = bean.

                         getContextualStorage(beanManager, _viewScopeId);

                     if (st != null)

                     {

                         ViewScopeContextImpl.destroyAllActive(st);

                         storage = null;

                         destroyed = true;

                     }

                 }

             }

         }

         if (!destroyed)

         {

             ViewScopeContextImpl.destroyAllActive(storage);

         }

     }

     public Set<String> keySet()

     {

         return this.getNameBeanKeyMap().keySet();

     }

     public Collection<Object> values()

     {

         List<Object> values = new ArrayList<Object>(this.getNameBeanKeyMap().size());

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

                 this.getNameBeanKeyMap().entrySet())

         {

             if (entry.getValue() != null)

             {

                 ContextualInstanceInfo info = 

                     this.getCreationalContextInstances().get(entry.getValue());

                 if (info != null)

                 {

                     values.add(info.getContextualInstance());

                 }

             }

         }

         return values;

     }

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

     {

         Set<Entry<String, Object>> values = new HashSet<Entry<String, Object>>();

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

                 this.getNameBeanKeyMap().entrySet())

         {

             if (entry.getValue() != null)

             {

                 ContextualInstanceInfo info = 

                     this.getCreationalContextInstances().get(entry.getValue());

                 if (info != null)

                 {

                     values.add(new EntryWrapper(entry));

                 }

             }

         }

         return values;

     }

     private class EntryWrapper<String, Object> implements Entry<String, Object>

     {

         private Map.Entry<String, Object> entry;

         public EntryWrapper(Map.Entry<String, Object> entry)

         {

             this.entry = entry;

         }

         public String getKey()

         {

             return entry.getKey();

         }

         public Object getValue()

         {

             ContextualInstanceInfo<?> info = getCreationalContextInstances().get(entry.getValue());

             return (Object) (info == null ? null : info.getContextualInstance());

         }

         public Object setValue(Object value)

         {

             ContextualInstanceInfo info = getCreationalContextInstances().get(entry.getValue());

             Object oldValue = null;

             if (info != null)

             {

                 info.setContextualInstance(value);

             }

             else

             {

                 info = new ContextualInstanceInfo();

                 info.setContextualInstance(value);

                 getCreationalContextInstances().put(entry.getValue(), info);

             }

             return oldValue;

         }

     }

 }