/*
 *  Copyright 2013 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.site.cache.monitoring.process.access;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Locale;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.logger.LogEnabled;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.io.FilenameUtils;

import org.ametys.core.util.DateUtils;
import org.ametys.core.util.StringUtils;
import org.ametys.plugins.site.cache.monitoring.process.access.impl.HTTPServerResourceAccess;
import org.ametys.runtime.config.Config;


/**
 * Import HTTP server access log and pass them to the resource access monitor
 */
public class HTTPServerAccessLogImporter implements Component, Configurable, Serviceable, Disposable, LogEnabled
{
    /** Avalon ROLE. */
    public static final String ROLE = HTTPServerAccessLogImporter.class.getName();

    /** Logger */
    protected Logger _logger;

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

    /**
     * Date of the initialization of the component, to ensure that only newer
     * log entries are importer
     */
    protected Date _initializationDate;

    private List<LogFileImporter> _logFileImporters;

    private boolean _enabled;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resourceAccessComponent = (ResourceAccessComponent) manager.lookup(ResourceAccessComponent.ROLE);
    }

    @Override
    public void enableLogging(Logger logger)
    {
        _logger = logger;
    }

    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _enabled = Config.getInstance().getValueAsBoolean("front.cache.monitoring.schedulers.enable");
        if (!_enabled)
        {
            return;
        }

        _initializationDate = new Date();
        _logFileImporters = new ArrayList<>();

        String frontConfig = Config.getInstance().getValueAsString("front.cache.monitoring.httpserver.log.paths");
        Collection<String> logFilePaths = StringUtils.stringToCollection(frontConfig);

        configureLogFiles(logFilePaths);

        initializeLogFileImporters();
    }

    @Override
    public void dispose()
    {
        _initializationDate = null;
        _logFileImporters = null;
    }

    /**
     * Scan the log files for each site importer.
     */
    public synchronized void scanLogFiles()
    {
        if (!_enabled)
        {
            return;
        }

        for (LogFileImporter importer : _logFileImporters)
        {
            importer.importEntries();
        }
    }

    private void configureLogFiles(Collection<String> paths)
    {
        for (String path : paths)
        {
            String dirLog = FilenameUtils.getFullPathNoEndSeparator(path);
            String logFilename = FilenameUtils.getName(path);
            File logFile = new File(dirLog, logFilename);

            _logFileImporters.add(new LogFileImporter(logFile));
        }
    }

    /**
     * Initialize the log file importers. This method must not be called during
     * the initialization of the component. Instead the call should be delayed,
     * and made during the first import attempt.
     */
    private void initializeLogFileImporters()
    {
        for (LogFileImporter importer : _logFileImporters)
        {
            importer.initialize();
        }
    }

    /**
     * A log file importer.
     * This class is able to import logs from an access log file.
     */
    protected final class LogFileImporter
    {
        private final File _file;
        // cached date format per importer, avoid synchronization issues while staying efficient
        private final DateFormat _df = new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss Z", Locale.US);

        private BufferedReader _br;
        private boolean _initialized;

        /**
         * Constructor
         * @param logFile the log file to import
         */
        protected LogFileImporter(File logFile)
        {
            _file = logFile;
        }

        /**
         * Initialize the log file importer.
         */
        protected synchronized void initialize()
        {
            if (_initialized)
            {
                return;
            }

            try
            {
                _br = new BufferedReader(new FileReader(_file));
                skipEntriesUntilEOS();

                _initialized = true;

                if (_logger.isInfoEnabled())
                {
                    String msg = String.format("The log file importer for the file '%s' is now initialized", _file);
                    _logger.info(msg);
                }
            }
            catch (IOException e)
            {
                _logger.error("Exception when initializing the LogFileImporter for the file : '" + _file + "'", e);
            }
        }

        /**
         * Import new entries from the httpserver log file of this importer
         */
        protected synchronized void importEntries()
        {
            if (!_initialized)
            {
                _logger.error("LogFileImporter not initialized. Unable to import the new entries for the file : '" + _file + "'");
                return;
            }

            try
            {
                scanLogEntries();
            }
            catch (IOException e)
            {
                _logger.error("IOException while importing httpserver access log.", e);
            }
            catch (Exception e)
            {
                _logger.error("Unexpected exception while importing httpserver access log.", e);
            }
        }

        /**
         * Skip to the end of the buffered stream
         * @throws IOException if something goes wrong during the entry skipping process
         */
        private void skipEntriesUntilEOS() throws IOException
        {
            long start = System.currentTimeMillis();

            while (_br.readLine() != null)
            {
                // do nothing, just consume the buffered reader.
            }

            if (_logger.isDebugEnabled())
            {
                String duration = DateUtils.formatDuration(System.currentTimeMillis() - start);
                String msg = String.format("It tooks %s to consume the whole log file '%s'", duration, _file);
                _logger.debug(msg);
            }
        }

        private void scanLogEntries() throws IOException
        {
            int scanned = 0;
            long start = System.currentTimeMillis();

            // Scan the new lines of the log file line by line.
            // For each line, create a new HTTPServerResourceAccess, and pass it to
            // the resourceAccessMonitor component if this entry must be
            // persisted.
            boolean eosReached = false;
            while (_br.ready() && !eosReached)
            {
                String entry = _br.readLine();
                if (entry != null)
                {
                    HTTPServerResourceAccess r = HTTPServerResourceAccess.createRecord(entry, _df);
                    if (r != null)
                    {
                        if (r.isOfInterest(_initializationDate))
                        {
                            _resourceAccessComponent.addAccessRecord(r);
                            scanned++;
                        }
                        else
                        {
                            if (_logger.isDebugEnabled())
                            {
                                _logger.debug(String.format("This httpserver access log entry has been filtered out : %s", r));
                            }
                        }
                    }
                }
                else
                {
                    // End of stream has been reached
                    eosReached = true;
                }
            }

            if (_logger.isDebugEnabled())
            {
                String durationStr = DateUtils.formatDuration(System.currentTimeMillis() - start);
                _logger.debug(String.format("%s log entry(ies) scanned in %s", scanned, durationStr));
            }
        }
    }
}