/*

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

 import java.io.IOException;

 import java.net.URL;

 import java.net.URLConnection;

 import java.util.Collections;

 import java.util.HashSet;

 import java.util.Map;

 import java.util.Set;

 import java.util.concurrent.ConcurrentHashMap;

 import javax.faces.view.facelets.FaceletContext;

 import javax.faces.view.facelets.FaceletException;

 import org.apache.myfaces.shared.resource.ResourceLoaderUtils;

 import org.apache.myfaces.view.facelets.AbstractFaceletCache;

 import org.apache.myfaces.view.facelets.AbstractFaceletContext;

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

 /**

  * Extended MyFaces specific FaceletCache implementation that recompile

  * facelet instance when a template context param is found.

  * 

  * @author Leonardo Uribe

  * @since 2.1.0

  *

  */

 class CacheELFaceletCacheImpl extends AbstractFaceletCache<DefaultFacelet>

 {

     private static final long INFINITE_DELAY = -1;

     private static final long NO_CACHE_DELAY = 0;

     /**

      * FaceletNode is necessary only here, because view metadata and 

      * composite component metadata are special and does not allow use nested

      * template tags. View metadata facelet trims everything outside f:metadata

      * and composite component metadata only takes into account composite:xxx tags,

      * ignoring ui:xxx tags.

      */

     private Map<String, FaceletNode> _facelets;

     private Map<String, DefaultFacelet> _viewMetadataFacelets;

     private Map<String, DefaultFacelet> _compositeComponentMetadataFacelets;

     private long _refreshPeriod;

     CacheELFaceletCacheImpl(long refreshPeriod)

     {

         _refreshPeriod = refreshPeriod < 0 ? INFINITE_DELAY : refreshPeriod * 1000;

         _facelets = new ConcurrentHashMap<String, FaceletNode>();

         _viewMetadataFacelets = new ConcurrentHashMap<String, DefaultFacelet>();

         _compositeComponentMetadataFacelets = new ConcurrentHashMap<String, DefaultFacelet>();

     }

     @Override

     public DefaultFacelet getFacelet(URL url) throws IOException

     {

         ParameterCheck.notNull("url", url);

         String key = url.toString();

         FaceletNode node = _facelets.get(key);

         DefaultFacelet f = node != null ? node.getFacelet() : null;

         if (f == null || this.needsToBeRefreshed(f))

         {

             //f = this._createFacelet(url);

             Set<String> paramsSet = null;

             if (node != null)

             {

                 paramsSet = node.getParams();

             }

             f = getMemberFactory().newInstance(url);

             if (_refreshPeriod != NO_CACHE_DELAY)

             {

                 //Map<String, FaceletNode> newLoc = new HashMap<String, FaceletNode>(_facelets);

                 //newLoc.put(key, (paramsSet != null && !paramsSet.isEmpty()) ? 

                 //        new FaceletNode(f, paramsSet) : new FaceletNode(f) );

                 //_facelets = newLoc;

                 _facelets.put(key, (paramsSet != null && !paramsSet.isEmpty()) ? 

                         new FaceletNode(f, paramsSet) : new FaceletNode(f) );

             }

         }

         return f;

     }

     @Override

     public DefaultFacelet getFacelet(FaceletContext ctx, URL url) throws IOException

     {

         String key = url.toString();

         //1. Check that the current parameters on the template are known

         //   for the template.

         //2. If all current parameters are known return the template

         //2. If some current parameter is not known, add the param(s) to the

         //   template, register the known params in the template context and

         //   recompile the facelet, to clean up al EL expressions at once.

         FaceletNode node = _facelets.get(key);

         DefaultFacelet f = (node != null) ? node.getFacelet() : null;

         Set<String> paramsSet = Collections.emptySet();

         paramsSet = (node != null) ? node.getParams() : paramsSet;

         AbstractFaceletContext actx = (AbstractFaceletContext) ctx;

         Set<String> knownParameters = actx.getTemplateContext().isKnownParametersEmpty() ?

             (Set) Collections.emptySet() : actx.getTemplateContext().getKnownParameters();

         boolean create = false;

         for (String paramKey : knownParameters)

         {

             if (!paramsSet.contains(paramKey))

             {

                 create = true;

                 break;

             }

         }

         if (f == null || this.needsToBeRefreshed(f) || create)

         {

             //f = this._createFacelet(url);

             f = getMemberFactory().newInstance(url);

             if (_refreshPeriod != NO_CACHE_DELAY)

             {

                 //Map<String, FaceletNode> newLoc = new HashMap<String, FaceletNode>(_facelets);

                 if (!paramsSet.isEmpty()|| !knownParameters.isEmpty() )

                 {

                     paramsSet = new HashSet(paramsSet);

                     paramsSet.addAll(knownParameters);

                     //newLoc.put(key, new FaceletNode(f, paramsSet));

                     _facelets.put(key, new FaceletNode(f, paramsSet));

                 }

                 else

                 {

                     //newLoc.put(key, new FaceletNode(f));

                     _facelets.put(key, new FaceletNode(f));

                 }

                 //_facelets = newLoc;

             }

         }

         if (!paramsSet.isEmpty())

         {

             //actx.getTemplateContext().getKnownParameters().addAll(paramsSet);

             for (String param : paramsSet)

             {

                 if (!actx.getTemplateContext().containsKnownParameter(param))

                 {

                     actx.getTemplateContext().addKnownParameters(param);

                 }

             }

         }

         return f;

     }

     @Override

     public boolean isFaceletCached(URL url)

     {

         return _facelets.containsKey(url.toString());

     }

     @Override

     public DefaultFacelet getViewMetadataFacelet(URL url) throws IOException

     {

         ParameterCheck.notNull("url", url);

         String key = url.toString();

         DefaultFacelet f = _viewMetadataFacelets.get(key);

         if (f == null || this.needsToBeRefreshed(f))

         {

             //f = this._createViewMetadataFacelet(url);

             f = getMetadataMemberFactory().newInstance(url);

             if (_refreshPeriod != NO_CACHE_DELAY)

             {

                 //Map<String, DefaultFacelet> newLoc = new HashMap<String, DefaultFacelet>(_viewMetadataFacelets);

                 //newLoc.put(key, f);

                 //_viewMetadataFacelets = newLoc;

                 _viewMetadataFacelets.put(key, f);

             }

         }

         return f;

     }

     @Override

     public boolean isViewMetadataFaceletCached(URL url)

     {

         return _viewMetadataFacelets.containsKey(url.toString());

     }

     /**

      * Template method for determining if the Facelet needs to be refreshed.

      * 

      * @param facelet

      *            Facelet that could have expired

      * @return true if it needs to be refreshed

      */

     protected boolean needsToBeRefreshed(DefaultFacelet facelet)

     {

         // if set to 0, constantly reload-- nocache

         if (_refreshPeriod == NO_CACHE_DELAY)

         {

             return true;

         }

         // if set to -1, never reload

         if (_refreshPeriod == INFINITE_DELAY)

         {

             return false;

         }

         long target = facelet.getCreateTime() + _refreshPeriod;

         if (System.currentTimeMillis() > target)

         {

             // Should check for file modification

             try

             {

                 URLConnection conn = facelet.getSource().openConnection();

                 long lastModified = ResourceLoaderUtils.getResourceLastModified(conn);

                 return lastModified == 0 || lastModified > target;

             }

             catch (IOException e)

             {

                 throw new FaceletException("Error Checking Last Modified for " + facelet.getAlias(), e);

             }

         }

         return false;

     }

     @Override

     public DefaultFacelet getCompositeComponentMetadataFacelet(URL url) throws IOException

     {

         ParameterCheck.notNull("url", url);

         String key = url.toString();

         DefaultFacelet f = _compositeComponentMetadataFacelets.get(key);

         if (f == null || this.needsToBeRefreshed(f))

         {

             f = getCompositeComponentMetadataMemberFactory().newInstance(url);

             if (_refreshPeriod != NO_CACHE_DELAY)

             {

                 //Map<String, DefaultFacelet> newLoc

                 //        = new HashMap<String, DefaultFacelet>(_compositeComponentMetadataFacelets);

                 //newLoc.put(key, f);

                 //_compositeComponentMetadataFacelets = newLoc;

                 _compositeComponentMetadataFacelets.put(key, f);

             }

         }

         return f;

     }

     @Override

     public boolean isCompositeComponentMetadataFaceletCached(URL url)

     {

         return _compositeComponentMetadataFacelets.containsKey(url.toString());

     }

     private static class FaceletNode

     {

         private DefaultFacelet facelet;

         private Set<String> params;

         public FaceletNode(DefaultFacelet facelet)

         {

             this.facelet = facelet;

             this.params = Collections.emptySet();

         }

         public FaceletNode(DefaultFacelet facelet, Set<String> params)

         {

             this.facelet = facelet;

             this.params = params;

         }

         /**

          * @return the facelet

          */

         public DefaultFacelet getFacelet()

         {

             return facelet;

         }

         /**

          * @param facelet the facelet to set

          */

         public void setFacelet(DefaultFacelet facelet)

         {

             this.facelet = facelet;

         }

         /**

          * @return the params

          */

         public Set<String> getParams()

         {

             return params;

         }

         /**

          * @param params the params to set

          */

         public void setParams(Set<String> params)

         {

             this.params = params;

         }

     }

 }