/*

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

 import java.io.IOException;

 import java.io.ObjectInput;

 import java.io.ObjectOutput;

 import java.net.URL;

 import java.text.DateFormat;

 import java.text.SimpleDateFormat;

 import java.util.Collections;

 import java.util.Collection;

 import java.util.Date;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.WeakHashMap;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.el.ELException;

 import javax.el.ExpressionFactory;

 import javax.faces.FacesException;

 import javax.faces.application.Resource;

 import javax.faces.application.ViewResource;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UIViewRoot;

 import javax.faces.component.UniqueIdVendor;

 import javax.faces.context.FacesContext;

 import javax.faces.view.facelets.FaceletContext;

 import javax.faces.view.facelets.FaceletException;

 import javax.faces.view.facelets.FaceletHandler;

 import org.apache.myfaces.shared.config.MyfacesConfig;

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

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

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

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

 import org.apache.myfaces.view.facelets.compiler.EncodingHandler;

 import org.apache.myfaces.view.facelets.tag.jsf.ComponentSupport;

 /**

  * Default Facelet implementation.

  * 

  * @author Jacob Hookom

  * @version $Id$

  */

 final class DefaultFacelet extends AbstractFacelet

 {

     //private static final Logger log = Logger.getLogger("facelets.facelet");

     private static final Logger log = Logger.getLogger(DefaultFacelet.class.getName());

     private final static String APPLIED_KEY = "org.apache.myfaces.view.facelets.APPLIED";

     private final String _alias;

     private final String _faceletId;

     private final ExpressionFactory _elFactory;

     private final DefaultFaceletFactory _factory;

     private final long _createTime;

     private final long _refreshPeriod;

     private final Map<String, URL> _relativePaths;

     private final FaceletHandler _root;

     private final URL _src;

     private final boolean _isBuildingCompositeComponentMetadata; 

     private final boolean _encodingHandler;

     public DefaultFacelet(DefaultFaceletFactory factory, ExpressionFactory el, URL src, String alias,

                           String faceletId, FaceletHandler root)

     {

         _factory = factory;

         _elFactory = el;

         _src = src;

         _root = root;

         _alias = alias;

         _faceletId = faceletId;

         _createTime = System.currentTimeMillis();

         _refreshPeriod = _factory.getRefreshPeriod();

         _relativePaths = Collections.synchronizedMap(new WeakHashMap());

         _isBuildingCompositeComponentMetadata = false;

         _encodingHandler = (root instanceof EncodingHandler);

     }

     public DefaultFacelet(DefaultFaceletFactory factory, ExpressionFactory el, URL src, String alias,

             String faceletId, FaceletHandler root, boolean isBuildingCompositeComponentMetadata)

     {

         _factory = factory;

         _elFactory = el;

         _src = src;

         _root = root;

         _alias = alias;

         _faceletId = faceletId;

         _createTime = System.currentTimeMillis();

         _refreshPeriod = _factory.getRefreshPeriod();

         _relativePaths = Collections.synchronizedMap(new WeakHashMap());

         _isBuildingCompositeComponentMetadata = isBuildingCompositeComponentMetadata;

         _encodingHandler = (root instanceof EncodingHandler);

     }    

     /**

      * @see org.apache.myfaces.view.facelets.Facelet#apply(javax.faces.context.FacesContext,

      *      javax.faces.component.UIComponent)

      */

     public void apply(FacesContext facesContext, UIComponent parent) throws IOException, FacesException,

             FaceletException, ELException

     {

         FaceletCompositionContext myFaceletContext = null;

         boolean faceletCompositionContextInitialized = false;

         boolean recordUniqueIds = false;

         myFaceletContext = FaceletCompositionContext.getCurrentInstance(facesContext);

         if (myFaceletContext == null)

         {

             myFaceletContext = new FaceletCompositionContextImpl(_factory, facesContext);

             myFaceletContext.init(facesContext);

             faceletCompositionContextInitialized = true;

             if (_encodingHandler && !myFaceletContext.isBuildingViewMetadata()

                     && MyfacesConfig.getCurrentInstance(

                     facesContext.getExternalContext()).isViewUniqueIdsCacheEnabled() && 

                     _refreshPeriod <= 0)

             {

                 List<String> uniqueIdList = ((EncodingHandler)_root).getUniqueIdList();

                 if (uniqueIdList == null)

                 {

                     myFaceletContext.initUniqueIdRecording();

                     recordUniqueIds = true;

                 }

                 else

                 {

                     myFaceletContext.setUniqueIdsIterator(uniqueIdList.iterator());

                 }

             }

             if (parent instanceof UIViewRoot)

             {

                 myFaceletContext.setViewRoot((UIViewRoot)parent);

                 ComponentSupport.setCachedFacesContext((UIViewRoot)parent, facesContext);

             }

         }

         DefaultFaceletContext ctx = new DefaultFaceletContext(facesContext, this, myFaceletContext);

         //Set FACELET_CONTEXT_KEY on FacesContext attribute map, to 

         //reflect the current facelet context instance

         FaceletContext oldCtx = (FaceletContext) 

                 facesContext.getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctx);

         ctx.pushPageContext(new PageContextImpl());

         try

         {

             // push the parent as a UniqueIdVendor to the stack here,

             // if there is no UniqueIdVendor on the stack yet

             boolean pushedUniqueIdVendor = false;

             if (parent instanceof UniqueIdVendor

                 && ctx.getFaceletCompositionContext().getUniqueIdVendorFromStack() == null)

             {

                 ctx.getFaceletCompositionContext().pushUniqueIdVendorToStack((UniqueIdVendor) parent);

                 pushedUniqueIdVendor = true;

             }

             this.refresh(parent);

             myFaceletContext.markForDeletion(parent);

             _root.apply(ctx, parent);

             if (faceletCompositionContextInitialized &&

                 parent instanceof UIViewRoot)

             {

                 UIComponent metadataFacet = parent.getFacet(UIViewRoot.METADATA_FACET_NAME);

                 if (metadataFacet != null)

                 {

                     // Ensure metadata facet is removed from deletion, so if by some reason

                     // is not refreshed, its content will not be removed from the component tree.

                     // This behavior is preferred, even if the spec suggest to include it using

                     // a trick with the template client.

                     myFaceletContext.removeComponentForDeletion(metadataFacet);

                 }

                 if (myFaceletContext.isRefreshingTransientBuild())

                 {

                     myFaceletContext.finalizeRelocatableResourcesForDeletion((UIViewRoot) parent);

                 }

             }

             myFaceletContext.finalizeForDeletion(parent);

             this.markApplied(parent);

             // remove the UniqueIdVendor from the stack again

             if (pushedUniqueIdVendor)

             {

                 ctx.getFaceletCompositionContext().popUniqueIdVendorToStack();

             }

         }

         finally

         {

             ctx.popPageContext();

             if (faceletCompositionContextInitialized)

             {

                 if (parent instanceof UIViewRoot)

                 {

                     ComponentSupport.setCachedFacesContext((UIViewRoot)parent, null);

                 }

                 myFaceletContext.release(facesContext);

                 List<String> uniqueIdList = ((EncodingHandler)_root).getUniqueIdList();

                 if (recordUniqueIds &&  uniqueIdList == null)

                 {

                     uniqueIdList = Collections.unmodifiableList(

                             myFaceletContext.getUniqueIdList());

                     ((EncodingHandler)_root).setUniqueIdList(uniqueIdList);

                 }

             }

             if (oldCtx != null)

             {

                 facesContext.getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, oldCtx);

             }

         }

     }

     public void applyDynamicComponentHandler(FacesContext facesContext, 

             UIComponent parent, String baseKey)

          throws IOException, FacesException, FaceletException, ELException

     {

         FaceletCompositionContext fcctx = null;

         boolean faceletCompositionContextInitialized = false;

         fcctx = FaceletCompositionContext.getCurrentInstance(facesContext);

         boolean pushDynCompSection = false;

         if (fcctx == null)

         {

             fcctx = new FaceletCompositionContextImpl(_factory, facesContext, 

                 baseKey);

             fcctx.init(facesContext);

             faceletCompositionContextInitialized = true;

         }

         else

         {

             pushDynCompSection = true;

             fcctx.pushDynamicComponentSection(baseKey);

         }

         // Disable dynamic component top level if the parent is a

         // dynamic wrapper, to allow the content to be reorganized properly under

         // a refresh.

         if (parent.getAttributes().containsKey("oam.vf.DYN_WRAPPER"))

         {

             fcctx.setDynamicComponentTopLevel(false);

         }

         FaceletContext oldCtx = (FaceletContext) facesContext.getAttributes().get(

             FaceletContext.FACELET_CONTEXT_KEY);

         DefaultFaceletContext ctx = new DefaultFaceletContext(facesContext, this, fcctx);

         //Set FACELET_CONTEXT_KEY on FacesContext attribute map, to 

         //reflect the current facelet context instance

         facesContext.getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctx);

         ctx.pushPageContext(new PageContextImpl());

         try

         {

             // push the parent as a UniqueIdVendor to the stack here,

             // if there is no UniqueIdVendor on the stack yet

             boolean pushedUniqueIdVendor = false;

             if (parent instanceof UniqueIdVendor

                 && ctx.getFaceletCompositionContext().getUniqueIdVendorFromStack() == null)

             {

                 ctx.getFaceletCompositionContext().pushUniqueIdVendorToStack((UniqueIdVendor) parent);

                 pushedUniqueIdVendor = true;

             }

             //this.refresh(parent);

             //myFaceletContext.markForDeletion(parent);

             _root.apply(ctx, parent);

             //myFaceletContext.finalizeForDeletion(parent);

             //this.markApplied(parent);

             // remove the UniqueIdVendor from the stack again

             if (pushedUniqueIdVendor)

             {

                 ctx.getFaceletCompositionContext().popUniqueIdVendorToStack();

             }

         }

         finally

         {

             ctx.popPageContext();

             facesContext.getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, oldCtx);

             if (pushDynCompSection)

             {

                 fcctx.popDynamicComponentSection();

             }

             if (faceletCompositionContextInitialized)

             {

                 fcctx.release(facesContext);

             }

         }

     }    

     private void refresh(UIComponent c)

     {

         if (_refreshPeriod > 0)

         {

             // finally remove any children marked as deleted

             int sz = c.getChildCount();

             if (sz > 0)

             {

                 UIComponent cc = null;

                 List<UIComponent> cl = c.getChildren();

                 ApplyToken token;

                 while (--sz >= 0)

                 {

                     cc = cl.get(sz);

                     if (!cc.isTransient())

                     {

                         token = (ApplyToken) cc.getAttributes().get(APPLIED_KEY);

                         if (token != null && token._time < _createTime && token._alias.equals(_alias))

                         {

                             if (log.isLoggable(Level.INFO))

                             {

                                 DateFormat df = SimpleDateFormat.getTimeInstance();

                                 log.info("Facelet[" + _alias + "] was modified @ "

                                         + df.format(new Date(_createTime)) + ", flushing component applied @ "

                                         + df.format(new Date(token._time)));

                             }

                             cl.remove(sz);

                         }

                     }

                 }

             }

             // remove any facets marked as deleted

             if (c.getFacetCount() > 0)

             {

                 Collection<UIComponent> col = c.getFacets().values();

                 UIComponent fc;

                 ApplyToken token;

                 for (Iterator<UIComponent> itr = col.iterator(); itr.hasNext();)

                 {

                     fc = itr.next();

                     if (!fc.isTransient())

                     {

                         token = (ApplyToken) fc.getAttributes().get(APPLIED_KEY);

                         if (token != null && token._time < _createTime && token._alias.equals(_alias))

                         {

                             if (log.isLoggable(Level.INFO))

                             {

                                 DateFormat df = SimpleDateFormat.getTimeInstance();

                                 log.info("Facelet[" + _alias + "] was modified @ "

                                         + df.format(new Date(_createTime)) + ", flushing component applied @ "

                                         + df.format(new Date(token._time)));

                             }

                             itr.remove();

                         }

                     }

                 }

             }

         }

     }

     private void markApplied(UIComponent parent)

     {

         if (this._refreshPeriod > 0)

         {

             int facetCount = parent.getFacetCount();

             int childCount = parent.getChildCount();

             if (childCount > 0 || facetCount > 0)

             {

                 ApplyToken token = new ApplyToken(_alias, System.currentTimeMillis() + _refreshPeriod);

                 if (facetCount > 0)

                 {

                     for (UIComponent facet : parent.getFacets().values())

                     {

                         markApplied(token, facet);

                     }

                 }

                 for (int i = 0; i < childCount; i++)

                 {

                     UIComponent child = parent.getChildren().get(i);

                     markApplied(token, child);

                 }

             }

         }

     }

     private void markApplied(ApplyToken token, UIComponent c)

     {

         if (!c.isTransient())

         {

             Map<String, Object> attr = c.getAttributes();

             if (!attr.containsKey(APPLIED_KEY))

             {

                 attr.put(APPLIED_KEY, token);

             }

         }

     }

     /**

      * Return the alias name for error messages and logging

      * 

      * @return alias name

      */

     public String getAlias()

     {

         return _alias;

     }

     public String getFaceletId()

     {

         return _faceletId;

     }

     /**

      * Return this Facelet's ExpressionFactory instance

      * 

      * @return internal ExpressionFactory instance

      */

     public ExpressionFactory getExpressionFactory()

     {

         return _elFactory;

     }

     /**

      * The time when this Facelet was created, NOT the URL source code

      * 

      * @return final timestamp of when this Facelet was created

      */

     public long getCreateTime()

     {

         return _createTime;

     }

     /**

      * Delegates resolution to DefaultFaceletFactory reference. Also, caches URLs for relative paths.

      * 

      * @param path

      *            a relative url path

      * @return URL pointing to destination

      * @throws IOException

      *             if there is a problem creating the URL for the path specified

      */

     private URL getRelativePath(FacesContext facesContext, String path) throws IOException

     {

         URL url = (URL) _relativePaths.get(path);

         if (url == null)

         {

             url = _factory.resolveURL(facesContext, _src, path);

             if (url != null)

             {

                 ViewResource viewResource = (ViewResource) facesContext.getAttributes().get(

                     FaceletFactory.LAST_RESOURCE_RESOLVED);

                 if (viewResource != null)

                 {

                     // If a view resource has been used to resolve a resource, the cache is in

                     // the ResourceHandler implementation. No need to cache in _relativeLocations.

                 }

                 else

                 {

                     _relativePaths.put(path, url);

                 }

             }

         }

         return url;

     }

     /**

      * The URL this Facelet was created from.

      * 

      * @return the URL this Facelet was created from

      */

     public URL getSource()

     {

         return _src;

     }

     /**

      * Given the passed FaceletContext, apply our child FaceletHandlers to the passed parent

      * 

      * @see FaceletHandler#apply(FaceletContext, UIComponent)

      * @param ctx

      *            the FaceletContext to use for applying our FaceletHandlers

      * @param parent

      *            the parent component to apply changes to

      * @throws IOException

      * @throws FacesException

      * @throws FaceletException

      * @throws ELException

      */

     private void include(AbstractFaceletContext ctx, UIComponent parent) throws IOException, FacesException,

             FaceletException, ELException

     {

         ctx.pushPageContext(new PageContextImpl());

         try

         {

             this.refresh(parent);

             DefaultFaceletContext ctxWrapper = new DefaultFaceletContext((DefaultFaceletContext)ctx, this, false);

             ctx.getFacesContext().getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctxWrapper);

             _root.apply(ctxWrapper, parent);

             ctx.getFacesContext().getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctx);

             this.markApplied(parent);

         }

         finally

         {

             ctx.popPageContext();

         }

     }

     /**

      * Used for delegation by the DefaultFaceletContext. First pulls the URL from {@link #getRelativePath(String)

      * getRelativePath(String)}, then calls

      * {@link #include(org.apache.myfaces.view.facelets.AbstractFaceletContext,

      * javax.faces.component.UIComponent, java.net.URL)}.

      * 

      * @see FaceletContext#includeFacelet(UIComponent, String)

      * @param ctx

      *            FaceletContext to pass to the included Facelet

      * @param parent

      *            UIComponent to apply changes to

      * @param path

      *            relative path to the desired Facelet from the FaceletContext

      * @throws IOException

      * @throws FacesException

      * @throws FaceletException

      * @throws ELException

      */

     public void include(AbstractFaceletContext ctx, UIComponent parent, String path)

             throws IOException, FacesException, FaceletException, ELException

     {

         URL url = this.getRelativePath(ctx.getFacesContext(), path);

         this.include(ctx, parent, url);

     }

     /**

      * Grabs a DefaultFacelet from referenced DefaultFaceletFacotry

      * 

      * @see DefaultFaceletFactory#getFacelet(URL)

      * @param ctx

      *            FaceletContext to pass to the included Facelet

      * @param parent

      *            UIComponent to apply changes to

      * @param url

      *            URL source to include Facelet from

      * @throws IOException

      * @throws FacesException

      * @throws FaceletException

      * @throws ELException

      */

     public void include(AbstractFaceletContext ctx, UIComponent parent, URL url) throws IOException, FacesException,

             FaceletException, ELException

     {

         DefaultFacelet f = (DefaultFacelet) _factory.getFacelet(ctx, url);

         f.include(ctx, parent);

     }

     public void applyCompositeComponent(AbstractFaceletContext ctx, UIComponent parent, Resource resource)

             throws IOException, FacesException, FaceletException, ELException

     {

         // Here we are creating a facelet using the url provided by the resource.

         // It works, but the Resource API provides getInputStream() for that. But the default

         // implementation wraps everything that could contain ValueExpression and decode so

         // we can't use it here.

         //DefaultFacelet f = (DefaultFacelet) _factory.getFacelet(resource.getURL());

         //f.apply(ctx.getFacesContext(), parent);

         DefaultFacelet f = (DefaultFacelet) _factory.getFacelet(resource.getURL());

         ctx.pushPageContext(new PageContextImpl());

         try

         {

             // push the parent as a UniqueIdVendor to the stack here,

             // if there is no UniqueIdVendor on the stack yet

             boolean pushedUniqueIdVendor = false;

             FaceletCompositionContext mctx = ctx.getFaceletCompositionContext();

             if (parent instanceof UniqueIdVendor

                 && ctx.getFaceletCompositionContext().getUniqueIdVendorFromStack() == null)

             {

                 mctx.pushUniqueIdVendorToStack((UniqueIdVendor) parent);

                 pushedUniqueIdVendor = true;

             }

             f.refresh(parent);

             mctx.markForDeletion(parent);

             DefaultFaceletContext ctxWrapper = new DefaultFaceletContext( (DefaultFaceletContext)ctx, f, true);

             //Update FACELET_CONTEXT_KEY on FacesContext attribute map, to 

             //reflect the current facelet context instance

             ctx.getFacesContext().getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctxWrapper);

             f._root.apply(ctxWrapper, parent);

             ctx.getFacesContext().getAttributes().put(FaceletContext.FACELET_CONTEXT_KEY, ctx);

             mctx.finalizeForDeletion(parent);

             f.markApplied(parent);

             // remove the UniqueIdVendor from the stack again

             if (pushedUniqueIdVendor)

             {

                 ctx.getFaceletCompositionContext().popUniqueIdVendorToStack();

             }

         }

         finally

         {

             ctx.popPageContext();

         }

     }

     private static class ApplyToken implements Externalizable

     {

         public String _alias;

         public long _time;

         public ApplyToken()

         {

         }

         public ApplyToken(String alias, long time)

         {

             _alias = alias;

             _time = time;

         }

         public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException

         {

             _alias = in.readUTF();

             _time = in.readLong();

         }

         public void writeExternal(ObjectOutput out) throws IOException

         {

             out.writeUTF(_alias);

             out.writeLong(_time);

         }

     }

     public String toString()

     {

         return _alias;

     }

     @Override

     public boolean isBuildingCompositeComponentMetadata()

     {

         return _isBuildingCompositeComponentMetadata;

     }

 }