/*
 *  Copyright 2015 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.plugins.syndication;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.net.HttpURLConnection;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.LaxRedirectStrategy;

import org.ametys.runtime.config.Config;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.rometools.rome.feed.synd.SyndFeed;
import com.rometools.rome.io.SyndFeedInput;
import com.rometools.rome.io.XmlReader;

/**
 * Feed cache, supports preloading multiple feeds in multiple concurrent threads.
 */
public class FeedCache extends AbstractLogEnabled implements Component, Initializable
{
    /** The component role. */
    public static final String ROLE = FeedCache.class.getName();
    
    /** The user information cache. */
    protected LoadingCache<String, FeedResult> _cache;
    
    @Override
    public void initialize() throws Exception
    {
        FeedCacheLoader loader = new FeedCacheLoader();
        
        CacheBuilder<Object, Object> cacheBuilder = CacheBuilder.newBuilder()
                .expireAfterWrite(24, TimeUnit.HOURS);
        
        _cache = cacheBuilder.build(loader);
    }
    
    /**
     * Pre-load a collection of feeds, one by thread, to avoid getting timeouts sequentially.
     * @param feeds the feeds to preload.
     */
    public void preload(Collection<String> feeds)
    {
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Preloading " + feeds.size() + " feeds...");
        }
        
        long start = System.currentTimeMillis();
        
        // Synchronization helper.
        CountDownLatch doneSignal = new CountDownLatch(feeds.size());
        
        for (String feed : feeds)
        {
            // Test if the feed is already in the cache.
            FeedResult result = _cache.getIfPresent(feed);
            
            if (result == null)
            {
                // The feed is not in the cache: prepare and launch a thread to retrieve it.
                FeedLoadWorker worker = new FeedLoadWorker(feed, doneSignal);
                
                try
                {
                    worker.initialize(getLogger());
                }
                catch (Exception e)
                {
                    // Ignore
                }
                
                new Thread(worker).start();
            }
            else
            {
                // The feed is already in the cache: count down.
                doneSignal.countDown();
            }
        }
        
        try
        {
            // Wait for all the URLs to be loaded (i.e. all the threads to end).
            doneSignal.await();
            
            if (getLogger().isDebugEnabled())
            {
                long end = System.currentTimeMillis();
                getLogger().debug("Feed preloading ended in " + (end - start) + " millis.");
            }
        }
        catch (InterruptedException e)
        {
            // Ignore, let the threads finish or die.
        }
    }
    
    /**
     * Get a feed not from the cache.
     * @param feedUrl the feed.
     * @return the feed result.
     * @throws IOException if an error occurs while loading the feed
     */
    public FeedResult getFeedNoCache(String feedUrl) throws IOException
    {
        return loadFeed(feedUrl);
    }
    
    /**
     * Get a feed.
     * @param feedUrl the feed.
     * @param lifeTime the amount of date or time to be added to the field
     * @return the feed response.
     */
    public FeedResult getFeed(String feedUrl, int lifeTime)
    {
        try
        {
            FeedResult feedResult = _cache.get(feedUrl);
            Date dateFeed = feedResult.getCreationDate();
            
            GregorianCalendar calendar = new GregorianCalendar();
            calendar.setTime(dateFeed);
            
            calendar.add(Calendar.MINUTE, lifeTime);
            
            Date dateToday = new Date();
            if (dateToday.after(calendar.getTime()))
            {
                _cache.invalidate(feedUrl);
                return _cache.get(feedUrl);
            }
            else
            {
                return feedResult;
            }
        }
        catch (ExecutionException e)
        {
            getLogger().error(e.getLocalizedMessage());
        }
        
        return null;
    }
    
    /**
     * Build a HttpClient object
     * @return The HttpClient object
     */
    protected CloseableHttpClient _getHttpClient()
    {
        int timeoutValue = Config.getInstance().getValue("syndication.timeout", false, 2000L).intValue();
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(timeoutValue).setSocketTimeout(timeoutValue).build();
        return HttpClientBuilder.create()
                .useSystemProperties()
                .setDefaultRequestConfig(requestConfig)
                .setRedirectStrategy(new LaxRedirectStrategy()) // follow 301 and 302 redirections
                .build();
    }
    
    /**
     * Retrieve a feed's content to store it into the cache.
     * @param feedUrl the feed to load.
     * @return the feed content.
     * @throws IOException if an error occurs with the {@link HttpURLConnection}
     */
    protected FeedResult loadFeed(String feedUrl) throws IOException
    {
        FeedResult result = new FeedResult();
        
        Date todayDate = new Date();
        result.setCreationDate(todayDate);
        
        SyndFeedInput input = new SyndFeedInput();
        SyndFeed synFeed = null;
        
        try (CloseableHttpClient httpClient = _getHttpClient())
        {
            HttpGet feedSource = new HttpGet(feedUrl);
            
            CloseableHttpResponse response = httpClient.execute(feedSource);
            
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != 200)
            {
                result.setStatus(FeedResult.STATUS_ERROR);
                result.setMessageError("Unable to join the RSS feed : " + feedUrl + ". HTTP response code is " + statusCode + ".");
                getLogger().error("Unable to join the RSS feed : " + feedUrl + ". HTTP response code is " + statusCode + ".");
                return result;
            }
            
            try (InputStream is = response.getEntity().getContent(); Reader reader = new XmlReader(is))
            {
                synFeed = input.build(reader);
            }
            
            result.setStatus(FeedResult.STATUS_OK);
            result.setResponse(synFeed);
        }
        catch (Exception e)
        {
            result.setStatus(FeedResult.STATUS_ERROR);
            result.setMessageError(e.getLocalizedMessage());
            getLogger().error("Unable to read the RSS feed to the url : " + feedUrl, e);
        }
        
        return result;
    }
    
    /**
     * The feed cache loader, delegates the loading to the component's loadFeed method (to be easily overridable).
     */
    protected class FeedCacheLoader extends CacheLoader<String, FeedResult>
    {
        @Override
        public FeedResult load(String feedUrl) throws Exception
        {
            return loadFeed(feedUrl);
        }
    }
    
    /**
     * Runnable loading an URL into the cache.
     */
    protected class FeedLoadWorker implements Runnable
    {
        
        /** The logger. */
        protected Logger _logger;
        
        /** Is the engine initialized ? */
        protected boolean _initialized;
        
        private final CountDownLatch _endSignal;
        
        private final String _feedUrl;
        
        /**
         * Build a worker loading a specific feed.
         * @param feedUrl the feed to load.
         * @param endSignal the signal when done.
         */
        FeedLoadWorker(String feedUrl, CountDownLatch endSignal)
        {
            this._feedUrl = feedUrl;
            this._endSignal = endSignal;
        }
        
        /**
         * Initialize the feed loader.
         * @param logger the logger.
         * @throws ContextException if the context is badly formed
         * @throws ServiceException if somthing goes wrong with the service
         */
        public void initialize(Logger logger) throws ContextException, ServiceException
        {
            _logger = logger;
            _initialized = true;
        }
                
        public void run()
        {
            try
            {
                if (_logger.isDebugEnabled())
                {
                    _logger.debug("Preparing to load the URL '" + _feedUrl + "'");
                }
                
                long start = System.currentTimeMillis();
                
                _checkInitialization();
                
                // Load the feed and signal that it's done.
                _cache.get(_feedUrl);
                
                if (_logger.isDebugEnabled())
                {
                    long end = System.currentTimeMillis();
                    _logger.debug("URL '" + _feedUrl + "' was loaded successfully in " + (end - start) + " millis.");
                }
            }
            catch (Exception e)
            {
                _logger.error("An error occurred loading the URL '" + _feedUrl + "'", e);
            }
            finally
            {
                // Signal that the worker has finished. 
                _endSignal.countDown();
                
                // Dispose of the resources.
                _dispose();
            }
        }
        
        /**
         * Check the initialization and throw an exception if not initialized.
         */
        protected void _checkInitialization()
        {
            if (!_initialized)
            {
                String message = "Le composant de synchronisation doit être initialisé avant d'être lancé."; //TODO
                _logger.error(message);
                throw new IllegalStateException(message);
            }
        }
        
        /**
         * Dispose of the resources and looked-up components.
         */
        protected void _dispose()
        {
            _initialized = false;
        }
        
    }

}