/*
 *  Copyright 2010 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.web.cache;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.tika.io.IOUtils;
import org.apache.xpath.XPathAPI;
import org.slf4j.Logger;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;

import org.ametys.runtime.config.Config;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.sitemap.Sitemap;

/**
 * Helper for dealing with front-office cache.
 */
public final class CacheHelper
{
    static Integer _lockToken = 0;
    static Map<String, Long> _lastInvalidationDate = new HashMap<>();
    static Map<String, String> _timerTasks = new HashMap<>();
    
    static Timer _timer = new Timer("timer-cache", true);
    
    private static Map<String, Long> _cacheForPeriodOfValidity = new HashMap<>();
    
    private CacheHelper()
    {
        // empty constructor
    }

    /**
     * Request the given URL on each configured front-office.
     * @param url the url to be called.
     * @param logger logger for traces.
     * @throws Exception if an error occurred.
     */
    public static void testWS(String url, Logger logger) throws Exception
    {
        testWS(url, null, logger);
    }

    /**
     * Request the given URL on each configured front-office.
     * @param url the url to be called.
     * @param postParameters submited values
     * @param logger logger for traces.
     * @throws Exception if an error occurred.
     */
    public static void testWS(String url, List<NameValuePair> postParameters, Logger logger) throws Exception
    {
        List<Map<String, Object>> responses = callWS(url, postParameters, logger);
        for (Map<String, Object> response : responses)
        {
            byte[] byteArray = (byte[]) response.get("bodyResponse");
            HttpPost request = (HttpPost) response.get("request");
            HttpResponse httpresponse = (HttpResponse) response.get("response");
            
            if (_checkResponse(byteArray))
            {
                if (logger.isDebugEnabled())
                {
                    logger.debug("Request for cache invalidation sent and received successfully to: " + request.getURI().getHost());
                }
            }
            else
            {
                logger.error("Unable to invalidate cache with request '" + url + "' to server '" + request.getURI().getHost() + "', response: " + (httpresponse != null ? httpresponse.getStatusLine().toString() : "<no response>"));
            }
        }
    }
    
    /**
     * Request the given URL on each configured front-office.
     * @param url the url to be called.
     * @param logger logger for traces.
     * @return The streams
     * @throws Exception if an error occurred.
     */
    public static List<Map<String, Object>> callWS(String url, Logger logger) throws Exception
    {
        return callWS(url, null, logger);
    }
    
    /**
     * Request the given URL on each configured front-office.
     * @param url the url to be called.
     * @param postParameters submitted values
     * @param logger logger for traces.
     * @return The streams
     * @throws Exception if an error occurred.
     */
    public static List<Map<String, Object>> callWS(String url, List<NameValuePair> postParameters, Logger logger) throws Exception
    {
        String frontConfig = Config.getInstance().getValueAsString("org.ametys.web.front.url");
        String[] frontURLs = StringUtils.split(frontConfig, ",");
        
        List<Map<String, Object>> responses = new ArrayList<>();
        for (String rawFrontURL : frontURLs)
        {
            String frontURL = rawFrontURL.trim();
            
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(2000).setSocketTimeout(2000).build();
            
            String wsURL = frontURL + url;
            
            try (CloseableHttpClient httpclient = HttpClientBuilder.create().useSystemProperties().setDefaultRequestConfig(requestConfig).build())
            {
                
                // Prepare a request object
                HttpPost request = new HttpPost(wsURL);
                request.addHeader("X-Ametys-BO", "true");
                
                if (postParameters != null)
                {
                    request.setEntity(new UrlEncodedFormEntity(postParameters, StandardCharsets.UTF_8));
                }
                
                Map<String, Object> responseObject = new HashMap<>();
                responses.add(responseObject);
                responseObject.put("request", request);
                
                // Execute the request
                try (CloseableHttpResponse response = httpclient.execute(request))
                {
                    responseObject.put("bodyResponse", _getResponse(response));
                    responseObject.put("response", response);
                }
            }
            catch (Exception e)
            {
                if (e instanceof IOException || e instanceof ClientProtocolException)
                {
                    logger.error("Unable to send request: " + wsURL, e);
                }
                else
                {
                    throw e;
                }
            }
        }
        
        return responses;
    }

    private static boolean _checkResponse(byte[] bodyResponse) throws ParserConfigurationException, IllegalStateException, IOException, SAXException, TransformerException
    {
        if (bodyResponse == null)
        {
            return false;
        }
        
        try (InputStream is = new ByteArrayInputStream(bodyResponse))
        {
            DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
            Document document = docBuilder.parse(is);
            return XPathAPI.eval(document, "count(/ActionResult)").toString().equals("1");
        }
    }
    
    private static byte[] _getResponse(HttpResponse response) throws IllegalStateException, IOException
    {
        if (response.getStatusLine().getStatusCode() != 200)
        {
            return null;
        }
        
        if (response.getFirstHeader("X-Ametys-SafeMode") != null)
        {
            // Site application is in safe mode
            return null;
        }
        
        String cType = _getContentType (response);
        if (cType == null || !cType.startsWith("text/xml"))
        {
            return null;
        }
        
        try (InputStream is = response.getEntity().getContent())
        {
            return IOUtils.toByteArray(is);
        }
    }
    
    private static String _getContentType (HttpResponse invalidateResponse)
    {
        Header header = invalidateResponse.getFirstHeader("Content-Type");
        if (header != null)
        {
            return header.getValue();
        }
        return null;
    }

    /**
     * Invalidates the front-office from the event observed.
     * @param site the site.
     * @param logger logger for traces.
     * @throws Exception if an error occurs.
     */
    public static void invalidateCache(Site site, Logger logger) throws Exception
    {
        String siteName = site.getName();
        long periodOfValidity = _getPeriodOfValidity (site, siteName);
        
        if (isCacheValidityExpired(siteName, periodOfValidity))
        {
            testWS("/_invalidate-site/" + site.getName(), logger);
            testWS("/_invalidate-skin/" + site.getSkinId(), logger);
        }
        else
        {
            delayCacheInvalidation(siteName, "/_invalidate-site/" + site.getName(), periodOfValidity, logger);
            delayCacheInvalidation(siteName, "/_invalidate-skin/" + site.getName(), periodOfValidity, logger);
        }
    }
    
    /**
     * Invalidates the front-office from the event observed.
     * @param sitemap the sitemap.
     * @param logger logger for traces.
     * @throws Exception if an error occurs.
     */
    public static void invalidateCache(Sitemap sitemap, Logger logger) throws Exception
    {
        testWS("/_invalidate-page/" + sitemap.getSiteName() + "/" + sitemap.getName(), logger);
    }
    
    /**
     * Invalidates the front-office from the event observed.
     * @param page the page.
     * @param logger logger for traces.
     * @param recursively true to invalidate the sub-pages
     * @throws Exception if an error occurs.
     */
    public static void invalidateCache(Page page, Logger logger, boolean recursively) throws Exception
    {
        testWS("/_invalidate-page/" + page.getSiteName() + "/" + page.getSitemapName() + "/" + page.getPathInSitemap() + ".html", logger);
        
        if (recursively)
        {
            testWS("/_invalidate-page/" + page.getSiteName() + "/" + page.getSitemapName() + "/" + page.getPathInSitemap(), logger);
        }
    }
    
    /**
     * Invalidates the front-office from the event observed.
     * @param page the page.
     * @param logger logger for traces.
     * @throws Exception if an error occurs.
     */
    public static void invalidateCache(Page page, Logger logger) throws Exception
    {
        invalidateCache(page, logger, false);
    }
    
    private static long _getPeriodOfValidity (Site site, String siteName)
    {
        if (!_cacheForPeriodOfValidity.containsKey(siteName))
        {
            _cacheForPeriodOfValidity.put(siteName, site.getMetadataHolder().getLong("cache-validity", 0) * 1000);
        }
        return _cacheForPeriodOfValidity.get(siteName);
    }
    
    /**
     * Update the last invalidation cache
     * @param siteName the site name
     */
    public static void initializeTimerPeriod (String siteName)
    {
        synchronized (_lockToken)
        {
            _lastInvalidationDate.put(siteName, System.currentTimeMillis());
            _timerTasks.remove(siteName);
        }
    }
    
    /**
     * Determines if cache validity is expired for given site
     * @param siteName the site name
     * @param periodOfValidity the period of cache validity
     * @return true if cache validity is expired
     */
    public static boolean isCacheValidityExpired (String siteName, long periodOfValidity)
    {
        synchronized (_lockToken)
        {
            long currentMillisecond = System.currentTimeMillis();
            
            if (!_lastInvalidationDate.containsKey(siteName))
            {   
                _lastInvalidationDate.put(siteName, currentMillisecond);
                return true;
            }
            
            long lastInvalidationDate = _lastInvalidationDate.get(siteName);
            
            if (currentMillisecond - lastInvalidationDate >= periodOfValidity)
            {
                _lastInvalidationDate.put(siteName, currentMillisecond);
                return true;
            }
            
            // Cache is still valid
            return false;
        }
    }
    
    /**
     * Delay the cache invalidation
     * @param siteName the site name
     * @param urlWS the WS url to be called
     * @param periodOfValidity the period of cache validity
     * @param logger the logger
     */
    public static void delayCacheInvalidation (String siteName, String urlWS, long periodOfValidity, Logger logger)
    {
        synchronized (_lockToken)
        {
            if (!_timerTasks.containsKey(siteName))
            {
                _timerTasks.put(siteName, urlWS);
                
                long currentMillisecond = System.currentTimeMillis();
                
                long lastInvalidationDate = _lastInvalidationDate.get(siteName);
                
                // delay the cache invalidation
                long delay = lastInvalidationDate + periodOfValidity - currentMillisecond;
                
                if (logger.isDebugEnabled())
                {
                    logger.debug("Cache invalidation for site '" + siteName + "' has been delayed of " + delay + " milliseconds");
                }
                _timer.schedule(new InvalidateCacheTimerTask (siteName, logger), delay);
            }
        }
    }
    
    /**
     * {@link TimerTask} to invalidate site cache
     *
     */
    public static class InvalidateCacheTimerTask extends TimerTask
    {
        private String _siteName;
        private Logger _logger;
        
        /**
         * Constructor
         * @param siteName the site name
         * @param logger the logger
         */
        public InvalidateCacheTimerTask (String siteName, Logger logger)
        {
            _siteName = siteName;
            _logger = logger;
        }
        
        @Override
        public void run()
        {
            try
            {
                synchronized (_lockToken)
                {
                    if (_logger.isDebugEnabled())
                    {
                        _logger.debug("Invalide cache of site '" + _siteName + "' after delay.");
                    }
                    
                    CacheHelper.testWS(_timerTasks.get(_siteName), _logger);
                    CacheHelper.initializeTimerPeriod(_siteName);
                }
            }
            catch (Exception e)
            {
                _logger.error("Unable to invalidate cache for site: " + _siteName, e);
            }
        }
    }
}