/*
 *  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.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.ReentrantLock;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.CloseableHttpClient;

import org.ametys.plugins.site.proxy.BackOfficeRequestProxyExtensionPoint;

/**
 * Component that regulates access to the page cache.
 */
public class CacheAccessManager extends AbstractLogEnabled implements Component, Initializable, Serviceable, Contextualizable, ThreadSafe
{
    
    /** The avalon role. */
    public static final String ROLE = CacheAccessManager.class.getName();
    
    /**
     * A Map keeping record of whether the pages are cacheable or not.
     * The key is the page path, the value indicates if the page is cacheable.
     */
    protected ConcurrentMap<String, Boolean> _pageCacheable;
    
    /**
     * Map of page cache locks.
     * The lock is acquired on the first call to the page, when the cache is empty,
     * and released when the page is written into the cache.
     */
    protected ConcurrentMap<String, ReentrantLock> _pageLocks;
    
    /** The cocoon context. */
    protected Context _context;
    
    /** The extension point for adding request headers in BO request */
    protected BackOfficeRequestProxyExtensionPoint _requestProxyExtensionPoint;
    
    @Override
    public void initialize() throws Exception
    {
        _pageCacheable = new ConcurrentHashMap<>();
        _pageLocks = new ConcurrentHashMap<>();
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _requestProxyExtensionPoint = (BackOfficeRequestProxyExtensionPoint) serviceManager.lookup(BackOfficeRequestProxyExtensionPoint.ROLE);
    }
    
    /**
     * Tests if the page is cacheable.
     * If more than one thread call this method concurrently, only one tests the
     * cacheability and (possibly) generates the corresponding resource.
     * The concurrent threads are blocked until the page is known not to be cacheable,
     * or known to be cacheable and put into the cache (in {@link GeneratePageAction}).
     * @param pagePath the page path.
     * @return true if the page is cacheable, false otherwise.
     * @throws IOException if an error occurs sending the cacheability request to the back-office.
     * @see GeneratePageAction
     */
    public boolean isCacheable(String pagePath) throws IOException
    {
        boolean cacheable = false;
        
        // If we don't know if the page is cacheable, or if the page is known to be cacheable, block.
        if (!_pageCacheable.containsKey(pagePath) || _pageCacheable.get(pagePath))
        {
            if (getLogger().isDebugEnabled())
            {
                getLogger().debug("Page cacheability unknown or known to be cacheable, testing : " + pagePath);
            }
            
            // Retrieve the shared lock.
            ReentrantLock lock = new ReentrantLock();
            
            ReentrantLock oldLock = _pageLocks.putIfAbsent(pagePath, lock);
            if (oldLock != null)
            {
                lock = oldLock;
            }
            
            if (getLogger().isDebugEnabled())
            {
                getLogger().debug("Acquiring lock for page " + pagePath + (lock.isLocked() ? " (already locked)" : " (unlocked)") + ", queue length: " + lock.getQueueLength() + ", hold count: " + lock.getHoldCount());
            }
            
            // Try to acquire the lock. If the thread is the first to acquire the lock,
            // it will go on. If not, it will be blocked until the owner unlocks.
            // It MUST be unlocked (call to unlock) by the same thread.
            lock.lock();
            
            // At this point, the cacheable status could already be computed by another thread.
            if (_pageCacheable.containsKey(pagePath))
            {
                cacheable = _pageCacheable.get(pagePath);
                
                if (getLogger().isDebugEnabled())
                {
                    getLogger().debug("The page " + pagePath + " was computed to be " + (cacheable ? "" : "not ") + "cacheable by another thread, unlocking...");
                }
            }
            else
            {
                if (getLogger().isDebugEnabled())
                {
                    getLogger().debug("Asking the CMS if the page is cacheable: " + pagePath);
                }
                
                cacheable = _isCacheable(pagePath);
                
                _pageCacheable.putIfAbsent(pagePath, cacheable);
                
                if (getLogger().isDebugEnabled())
                {
                    getLogger().debug("The CMS answered that the page " + pagePath + " is " + (cacheable ? "" : "not ") + "cacheable.");
                }
            }
        }
        
        return cacheable;
    }
    
    /**
     * Release the lock associated with a page.
     * @param pagePath the page path.
     */
    public void unlock(String pagePath)
    {
        if (_pageLocks.containsKey(pagePath))
        {
            if (getLogger().isDebugEnabled())
            {
                getLogger().debug("The page " + pagePath + " is being unlocked.");
            }
            
            ReentrantLock lock = _pageLocks.get(pagePath);
            
            // This method is called from several locations, where it's hard to know if the resource has actually been locked or not.
            // So simply ask the lock itself
            if (lock.isHeldByCurrentThread())
            {
                if (getLogger().isDebugEnabled())
                {
                    getLogger().debug("Releasing lock for page " + pagePath + ", queue length: " + lock.getQueueLength() + ", hold count: " + lock.getHoldCount());
                }
                
                lock.unlock();
                
                if (getLogger().isDebugEnabled())
                {
                    getLogger().debug("The page " + pagePath + " has been successfully unlocked.");
                }
            }
        }
    }
    
    /**
     * Resets all the local caches and locks.
     */
    public void reset()
    {
        _pageCacheable = new ConcurrentHashMap<>();
    }
    
    /**
     * Remove a specified page path from the local cache and lock.
     * @param pagePath the page path.
     */
    public void resetPage(String pagePath)
    {
        _pageCacheable.remove(pagePath);
    }
    
    /**
     * Get the cacheable status of a page from the back-office.
     * @param pagePath the page path.
     * @return true if the page is cacheable, false otherwise.
     * @throws IOException  in case of a problem or the connection was aborted
     */
    protected boolean _isCacheable(String pagePath) throws IOException
    {
        Map objectModel = ContextHelper.getObjectModel(_context);
        
        CloseableHttpClient httpClient = BackOfficeRequestHelper.getHttpClient();
        HttpUriRequest cmsRequest = BackOfficeRequestHelper.getRequest(objectModel, pagePath, _requestProxyExtensionPoint);
        
        HttpResponse cmsResponse = httpClient.execute(cmsRequest);
        Request request = ObjectModelHelper.getRequest(objectModel);
        request.setAttribute("cms-request", cmsRequest);
        request.setAttribute("cms-response", cmsResponse);
        request.setAttribute("http-client", httpClient);
        
        Header header = cmsResponse.getFirstHeader("X-Ametys-Cacheable");
        return header != null && "true".equals(header.getValue());
    }
}