/*

  * 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.shared.resource;

 import java.io.IOException;

 import java.io.InputStream;

 import java.net.URL;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.Map;

 import javax.faces.application.ProjectStage;

 import javax.faces.application.Resource;

 import javax.faces.context.FacesContext;

 /**

  * Default implementation for resources

  */

 public class ResourceImpl extends Resource implements ContractResource

 {

     protected final static String JAVAX_FACES_LIBRARY_NAME = "javax.faces";

     protected final static String JSF_JS_RESOURCE_NAME = "jsf.js";

     private ResourceMeta _resourceMeta;

     private ResourceLoader _resourceLoader;

     private ResourceHandlerSupport _resourceHandlerSupport;

     private URL _url;

     private String _requestPath;

     public ResourceImpl(ResourceMeta resourceMeta, 

             ResourceLoader resourceLoader, ResourceHandlerSupport support, String contentType)

     {

         _resourceMeta = resourceMeta;

         _resourceLoader = resourceLoader;

         _resourceHandlerSupport = support;

         setLibraryName(resourceMeta.getLibraryName());

         setResourceName(resourceMeta.getResourceName());

         setContentType(contentType);

     }

     public ResourceImpl(ResourceMeta resourceMeta, 

             ResourceLoader resourceLoader, ResourceHandlerSupport support, String contentType,

             URL url, String requestPath)

     {

         _resourceMeta = resourceMeta;

         _resourceLoader = resourceLoader;

         _resourceHandlerSupport = support;

         _url = url;

         _requestPath = requestPath;

         setLibraryName(resourceMeta.getLibraryName());

         setResourceName(resourceMeta.getResourceName());

         setContentType(contentType);

     }

     public ResourceLoader getResourceLoader()

     {

         return _resourceLoader;

     }    

     @Override

     public InputStream getInputStream() throws IOException

     {

         if (couldResourceContainValueExpressions())

         {

             return new ValueExpressionFilterInputStream(

                     getResourceLoader().getResourceInputStream(_resourceMeta), getLibraryName(), getResourceName()); 

         }

         else

         {

             return getResourceLoader().getResourceInputStream(_resourceMeta);            

         }

     }

     private boolean couldResourceContainValueExpressions()

     {

         if (_resourceMeta.couldResourceContainValueExpressions())

         {

             return true;

         }

         else

         {

             //By default only css resource contain value expressions

             String contentType = getContentType();

             return ("text/css".equals(contentType));

         }

     }

     @Override

     public String getRequestPath()

     {

         if (_requestPath == null)

         {

             String path;

             if (_resourceHandlerSupport.isExtensionMapping())

             {

                 path = _resourceHandlerSupport.getResourceIdentifier() + '/' + 

                     getResourceName() + _resourceHandlerSupport.getMapping();

             }

             else

             {

                 String mapping = _resourceHandlerSupport.getMapping(); 

                 path = _resourceHandlerSupport.getResourceIdentifier() + '/' + getResourceName();

                 path = (mapping == null) ? path : mapping + path;

             }

             FacesContext facesContext = FacesContext.getCurrentInstance();

             String metadata = null;

             boolean useAmp = false;

             if (getLibraryName() != null)

             {

                 metadata = "?ln=" + getLibraryName();

                 path = path + metadata;

                 useAmp = true;

                 if (!facesContext.isProjectStage(ProjectStage.Production)

                         && JSF_JS_RESOURCE_NAME.equals(getResourceName()) 

                         && JAVAX_FACES_LIBRARY_NAME.equals(getLibraryName()))

                 {

                     // append &stage=?? for all ProjectStages except Production

                     path = path + "&stage=" + facesContext.getApplication().getProjectStage().toString();

                 }

             }

             if (_resourceMeta.getLocalePrefix() != null)

             {

                 path = path + (useAmp ? '&' : '?') + "loc=" + _resourceMeta.getLocalePrefix();

                 useAmp = true;

             }

             if (_resourceMeta.getContractName() != null)

             {

                 path = path + (useAmp ? '&' : '?') + "con=" + _resourceMeta.getContractName();

                 useAmp = true;

             }

             _requestPath = facesContext.getApplication().getViewHandler().getResourceURL(facesContext, path);

         }

         return _requestPath;

     }

     @Override

     public Map<String, String> getResponseHeaders()

     {

         FacesContext facesContext = FacesContext.getCurrentInstance();

         if (facesContext.getApplication().getResourceHandler().isResourceRequest(facesContext))

         {

             Map<String, String> headers = new HashMap<String, String>();

             long lastModified;

             try

             {

                 lastModified = ResourceLoaderUtils.getResourceLastModified(this.getURL());

             }

             catch (IOException e)

             {

                 lastModified = -1;

             }

             // Here we have two cases: If the file could contain EL Expressions

             // the last modified time is the greatest value between application startup and

             // the value from file.

             if (this.couldResourceContainValueExpressions() &&

                     lastModified < _resourceHandlerSupport.getStartupTime())

             {

                 lastModified = _resourceHandlerSupport.getStartupTime();

             }            

             else if (_resourceMeta instanceof AliasResourceMetaImpl &&

                 lastModified < _resourceHandlerSupport.getStartupTime())

             {

                 // If the resource meta is aliased, the last modified time is the greatest 

                 // value between application startup and the value from file.

                 lastModified = _resourceHandlerSupport.getStartupTime();

             }

             if (lastModified >= 0)

             {

                 headers.put("Last-Modified", ResourceLoaderUtils.formatDateHeader(lastModified));

                 long expires;

                 if (facesContext.isProjectStage(ProjectStage.Development))

                 {

                     // Force to expire now to prevent caching on development time.

                     expires = System.currentTimeMillis();

                 }

                 else

                 {

                     expires = System.currentTimeMillis() + _resourceHandlerSupport.getMaxTimeExpires();

                 }

                 headers.put("Expires", ResourceLoaderUtils.formatDateHeader(expires));

             }

             return headers;

         }

         else

         {

             //No need to return headers 

             return Collections.emptyMap();

         }

     }

     @Override

     public URL getURL()

     {

         // For the default algorithm, it is safe to assume the resource

         // URL will not change over resource lifetime. See MYFACES-3458

         if (_url == null)

         {

             _url = getResourceLoader().getResourceURL(_resourceMeta);

         }

         return _url;

     }

     @Override

     public boolean userAgentNeedsUpdate(FacesContext context)

     {

         // RFC2616 says related to If-Modified-Since header the following:

         //

         // "... The If-Modified-Since request-header field is used with a method to 

         // make it conditional: if the requested variant has not been modified since 

         // the time specified in this field, an entity will not be returned from 

         // the server; instead, a 304 (not modified) response will be returned 

         // without any message-body..."

         // 

         // This method is called from ResourceHandlerImpl.handleResourceRequest and if

         // returns false send a 304 Not Modified response.

         String ifModifiedSinceString = context.getExternalContext().getRequestHeaderMap().get("If-Modified-Since");

         if (ifModifiedSinceString == null)

         {

             return true;

         }

         Long ifModifiedSince = ResourceLoaderUtils.parseDateHeader(ifModifiedSinceString);

         if (ifModifiedSince == null)

         {

             return true;

         }

         Long lastModified;

         try

         {

             lastModified = ResourceLoaderUtils.getResourceLastModified(this.getURL());

         }

         catch (IOException exception)

         {

             lastModified = -1L;

         }

         if (lastModified >= 0)

         {

             if (this.couldResourceContainValueExpressions() &&

                     lastModified < _resourceHandlerSupport.getStartupTime())

             {

                 lastModified = _resourceHandlerSupport.getStartupTime();

             }

             // If the lastModified date is lower or equal than ifModifiedSince,

             // the agent does not need to update.

             // Note the lastModified time is set at milisecond precision, but when 

             // the date is parsed and sent on ifModifiedSince, the exceding miliseconds

             // are trimmed. So, we have to compare trimming this from the calculated

             // lastModified time.

             if ( (lastModified-(lastModified % 1000)) <= ifModifiedSince)

             {

                 return false;

             }

         }

         return true;

     }

     protected ResourceHandlerSupport getResourceHandlerSupport()

     {

         return _resourceHandlerSupport;

     }

     protected ResourceMeta getResourceMeta()

     {

         return _resourceMeta;

     }

     public boolean isContractResource()

     {

         return _resourceMeta.getContractName() != null;

     }

     public String getContractName()

     {

         return _resourceMeta.getContractName();

     }

 }