/*
 *  Copyright 2011 Anyware Services
 *
 *  Licensed 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.ametys.site;

import java.util.Map;

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.acting.ServiceableAction;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Redirector;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceNotFoundException;
import org.apache.excalibur.source.TraversableSource;
import org.apache.excalibur.source.impl.FileSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.plugins.site.cache.monitoring.Constants;
import org.ametys.plugins.site.cache.monitoring.process.access.ResourceAccessComponent;
import org.ametys.plugins.site.cache.monitoring.process.access.impl.FrontResourceAccess;

/**
 * Blocks until the cacheable status is known.
 */
public class IsPageCacheableAction extends ServiceableAction implements ThreadSafe
{
    /** The cache access component. */
    protected CacheAccessManager _cacheAccess;

    /** The resource access monitoring component */
    protected ResourceAccessComponent _resourceAccessComponent;

    /** The source resolver. */
    protected SourceResolver _resolver;

    private final Logger _logger = LoggerFactory.getLogger("site.cache.log");

    /**
     * Get the cache access manager
     * @return the CacheAccessManager
     */
    protected CacheAccessManager _getCacheAccessManager()
    {
        if (_cacheAccess == null)
        {
            try
            {
                _cacheAccess = (CacheAccessManager) manager.lookup(CacheAccessManager.ROLE);
            }
            catch (ServiceException e)
            {
                throw new IllegalStateException("Cannot get CacheAccessManager", e);
            }
        }
        return _cacheAccess;
    }

    /**
     * Get the resource access component
     * @return the ResourceAccessComponent
     */
    protected ResourceAccessComponent _getResourceAccessComponent()
    {
        if (_resourceAccessComponent == null)
        {
            try
            {
                _resourceAccessComponent = (ResourceAccessComponent) manager.lookup(ResourceAccessComponent.ROLE);
            }
            catch (ServiceException e)
            {
                throw new IllegalStateException("Cannot get ResourceAccessComponent", e);
            }
        }
        return _resourceAccessComponent;
    }
    
    @Override
    public Map act(Redirector redirector, SourceResolver resolver, Map objectModel, String source, Parameters parameters) throws Exception
    {
        Request request = ObjectModelHelper.getRequest(objectModel);

        String method = request.getMethod();
        
        if (!method.equals("GET"))
        {
            return null;
        }
        
        try
        {
            // Block until known if the page is cacheable.
            boolean cacheable = _getCacheAccessManager().isCacheable(source);


            if (_logger.isDebugEnabled())
            {
                String uniqueId = request.getHeader("UNIQUE_ID");
                if (uniqueId != null)
                {
                    _logger.debug(uniqueId + " - cacheable : " + cacheable);
                }
            }

            // Resource monitoring
            FrontResourceAccess fra = (FrontResourceAccess) request.getAttribute(Constants.REQUEST_ATTRIBUTE_PAGEACCESS);
            fra.setCacheable(cacheable);

            // If the page isn't cacheable, unlock and generate (return null).
            String resourceURI = parameters.getParameter("uri", "");
            if (!cacheable)
            {
                _getResourceAccessComponent().addAccessRecord(fra);

                _getCacheAccessManager().unlock(source);
                return null;
            }
            // If cacheable and the resource exists, we don't have to generate it.
            else if (cacheable && _resourceExists(resolver, resourceURI))
            {
                fra.setCacheHit2(true);
                _getResourceAccessComponent().addAccessRecord(fra);

                _getCacheAccessManager().unlock(source);
                return EMPTY_MAP;
            }

            // Else, return null: the page will be generated into the cache and unlocked when it's done.
            fra.setCacheHit2(false);
            _getResourceAccessComponent().addAccessRecord(fra);

            return null;
        }
        catch (Exception e)
        {
            _getCacheAccessManager().unlock(source);
            throw e;
        }
    }

    /**
     * Tests if the resource exists.
     * @param resolver the resolver.
     * @param resourceURI the resource uri.
     * @return true if the resource exists, false otherwise.
     */
    protected boolean _resourceExists(SourceResolver resolver, String resourceURI)
    {
        boolean exists = false;

        Source source = null;
        try
        {
            source = resolver.resolveURI(resourceURI);

            if (source instanceof FileSource && !SiteCacheHelper.isValid((FileSource) source))
            {
                // Release the old source and replace it by a hashed file source.
                source = SiteCacheHelper.getHashedFileSource(resolver, (FileSource) source);
            }

            if (source.exists() && (!(source instanceof TraversableSource) || !((TraversableSource) source).isCollection()))
            {
                exists = true;
            }
        }
        catch (SourceNotFoundException e)
        {
            // Do not log
        }
        catch (Exception e)
        {
            getLogger().warn("Exception resolving resource " + resourceURI, e);
        }
        finally
        {
            if (source != null)
            {
                resolver.release(source);
            }
        }

        return exists;
    }
}