/*
 *  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.runtime.plugins.admin.logs;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.ProcessingException;
import org.apache.commons.lang3.Strings;
import org.apache.excalibur.source.ModifiableSource;
import org.apache.excalibur.source.ModifiableTraversableSource;
import org.apache.excalibur.source.SourceException;
import org.apache.excalibur.source.SourceResolver;
import org.apache.excalibur.source.TraversableSource;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggerRepository;

import org.ametys.core.ui.Callable;
import org.ametys.core.ui.StaticClientSideElement;
import org.ametys.core.util.DateUtils;

/**
 * Client side element for log actions
 */
public class LogsClientSideElement extends StaticClientSideElement
{
    /** The path to the application's logs folder */
    private static final String __LOGS_BASE = "ametys-home://logs/";
    private static final Pattern __DATED_LOG_FILENAME = Pattern.compile("(.*)[-_]\\d{4}[-_]\\d{2}(?:[-_]\\d{2})?.*\\.log(?:.gz)?");
    
    /** The Excalibur source resolver */
    private SourceResolver _sourceResolver;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        super.service(serviceManager);
        _sourceResolver = (SourceResolver) serviceManager.lookup(SourceResolver.ROLE);
    }
    
    /**
     * Delete the log files
     * @param files the files to delete
     * @return the result map with the successes and failures files.
     * @throws IOException if an error occurred during deletion
     * @throws ProcessingException if an error occurred during deletion
     */
    @Callable (rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public Map<String, Object> deleteLogs(List<String> files) throws ProcessingException, IOException
    {
        Map<String, Object> result = new HashMap<>();
        List<String> failures = new ArrayList<> ();
        List<String> successes = new ArrayList<> ();
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("Administrator starts a deletion of " + files.size() + " logged file");
        }
        
        // Delete the selected files one by one
        for (String location : files)
        {
            if (_deleteFile(location))
            {
                successes.add(location);
            }
            else
            {
                failures.add(location);
            }
        }
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("Process terminated with following results : failure '" + failures.toString() + " successes '" + successes.toString());
        }
        
        result.put("failures", failures);
        result.put("successes", successes);
        return result;
    }
    
    /**
     * Delete the log entries that are at least 12 days old
     * @return the result
     * @throws ProcessingException if an exception occurs while processing the deletion
     */
    @Callable (rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public Map<String, Object> purgeLogs() throws ProcessingException
    {
        Calendar purgeCalendar = new GregorianCalendar();
        purgeCalendar.add(Calendar.DAY_OF_MONTH, -12);
        Date purgeDate = new Date(purgeCalendar.getTimeInMillis());

        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Starting purge...");
            getLogger().debug("Purge date is " + purgeDate);
        }

        List<String> filesList = new ArrayList<>();
        TraversableSource logsSources = null;
        try
        {
            logsSources = (TraversableSource) _sourceResolver.resolveURI(__LOGS_BASE);
            for (Object log : logsSources.getChildren())
            {
                ModifiableTraversableSource logSource = (ModifiableTraversableSource) log;
                if (!logSource.isCollection()
                        && (logSource.getURI().endsWith(".log") || logSource.getURI().endsWith(".log.gz"))
                        && !(logSource.getName().startsWith("forensic-"))
                        && new Date(logSource.getLastModified()).before(purgeDate))
                {
                    String location = logSource.getURI();
                    String name = location.substring(location.lastIndexOf('/') + 1);
                    filesList.add(name);
                    if (getLogger().isDebugEnabled())
                    {
                        getLogger().debug("Adding file to purge : " + name);
                    }
                }
            }
            
            return deleteLogs(filesList);
        }
        catch (SourceException e)
        {
            String message = "The purge of old log files failed";
            getLogger().error(message, e);
            throw new ProcessingException(message, e);
        }
        catch (IOException e)
        {
            String message = "The log directory was not found";
            getLogger().error(message, e);
            throw new ProcessingException(message, e);
        }
        finally
        {
            if (logsSources != null)
            {
                _sourceResolver.release(logsSources);
            }
        }
    }
    
    private boolean _deleteFile(String fileLocation) throws IOException, ProcessingException
    {
        if (fileLocation.indexOf("/") != -1 || fileLocation.indexOf('\\') != -1)
        {
            String message = "The LogsDeleteAction has been call with the forbiden parameter '" + fileLocation + "'";
            getLogger().error(message);
            throw new ProcessingException(message);
        }
        
        ModifiableSource logsource = null;
        try
        {
            if (fileLocation.endsWith(".log"))
            {
                logsource = (ModifiableSource) _sourceResolver.resolveURI(__LOGS_BASE + fileLocation);
                if (getLogger().isInfoEnabled())
                {
                    getLogger().info("Removing log file " + logsource.getURI());
                }
                logsource.delete();
                return true;
            }
            else if (getLogger().isWarnEnabled())
            {
                getLogger().warn("Ignoring this file during deletion '" + "' because it does not ends with .log");
            }
            return false;
        }
        catch (SourceException e)
        {
            getLogger().error("The administrator tried unsuccessfully to remove the following log file '" + (logsource != null ? logsource.getURI() : fileLocation) + "'.", e);
            return false;
        }
        finally
        {
            if (logsource != null)
            {
                _sourceResolver.release(logsource);
            }
        }
    }
    
    /**
     * Change the log level of the selected category to the selected level
     * @param level the selected level
     * @param category the selected category
     * @return a map
     */
    @Callable (rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public Map<String, Object> changeLogLevel(String level, String category)
    {
        Map<String, Object> result = new HashMap<>();
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("Administrator change log level");
        }

        LoggerRepository loggerRepository = LogManager.getLoggerRepository();
        
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("Log level changing category '" + category + "' " + level);
        }

        try
        {
            _changeLogLevel(loggerRepository, category, level);
        }
        catch (Throwable t)
        {
            String errorMessage = "Cannot change log level correctly : changing category '" + category + "'";
            getLogger().error(errorMessage, t);
            result.put("error", "error");
            return result;
        }
        
        return result;
    }
    
    private void _changeLogLevel(LoggerRepository loggerRepository, String category, String mode)
    {
        boolean inherited = "INHERIT".equals(mode) || "INHERITFORCED".equals(mode);
        boolean force = "FORCE".equals(mode) || "INHERITFORCED".equals(mode);

        Logger logger;
        boolean isRoot = false;
        
        if ("root".equals(category))
        {
            isRoot = true;
            logger = loggerRepository.getRootLogger();
        }
        else
        {
            logger = loggerRepository.getLogger(category);
        }
    
        if (inherited && !isRoot)
        {
            logger.setLevel(null);
        }
        
        if (force)
        {
            Enumeration<Logger> e = loggerRepository.getCurrentLoggers();
            while (e.hasMoreElements())
            {
                Logger l = e.nextElement();
                if (l.getParent() == logger)
                {
                    _changeLogLevel(loggerRepository, l.getName(), "INHERITFORCED");
                }
            }
        }

        if (!inherited && !force)
        {
            Level level = Level.toLevel(mode);
            logger.setLevel(level);
        }
    }
    
    /**
     * Get the list of log files
     * @return the list of log files
     * @throws IOException if a error occurs
     */
    @Callable (rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public List<Map<String, Object>> getLogFiles() throws IOException
    {
        List<Map<String, Object>> logs = new ArrayList<>();
        TraversableSource logsDirectorySource = (TraversableSource) _sourceResolver.resolveURI(__LOGS_BASE);
        
        try
        {
            Map<String, List<TraversableSource>> logSources = _prepareLogs(logsDirectorySource);
            
            for (String logname : logSources.keySet())
            {
                for (TraversableSource logSource : logSources.get(logname))
                {
                    Map<String, Object> log = new HashMap<>();
                    log.put("name", logname);
                    log.put("location", logSource.getURI().substring(logSource.getURI().lastIndexOf('/') + 1));
                    log.put("lastModified", DateUtils.dateToString(new Date(logSource.getLastModified())));
                    log.put("size", Long.toString(logSource.getContentLength()));
                    
                    logs.add(log);
                }
                
            }
        }
        finally
        {
            _sourceResolver.release(logsDirectorySource);
        }
        
        return logs;
    }
    
    private Map<String, List<TraversableSource>> _prepareLogs(TraversableSource logsDirectorySource) throws SourceException
    {
        Map<String, List<TraversableSource>> logs = new HashMap<>();
        
        if (logsDirectorySource.exists())
        {
            Collection<TraversableSource> logFiles = logsDirectorySource.getChildren();
            for (TraversableSource logSource : logFiles)
            {
                if (!logSource.isCollection())
                {
                    String name = logSource.getName();
                    String canonicalName = _getCanonicalName(name);
                    
                    if (canonicalName != null)
                    {
                        List<TraversableSource> underLogs = logs.get(canonicalName);
                        if (underLogs == null)
                        {
                            underLogs = new ArrayList<>();
                            logs.put(canonicalName, underLogs);
                        }
                        
                        underLogs.add(logSource);
                    }
                }
            }
        }
        
        return logs;
    }
    
    private String _getCanonicalName(String name)
    {
        Matcher matcher = __DATED_LOG_FILENAME.matcher(name);
        if (matcher.matches())
        {
            return matcher.group(1);
        }
        else if (name.endsWith(".log"))
        {
            return name;
        }
        else
        {
            return null;
        }
    }
    
    /**
     * Get the log levels
     * @return the JSON tree of log level by categories
     */
    @Callable (rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public Map<String, Object> getLogLevels()
    {
        LoggerRepository loggerRepository = LogManager.getLoggerRepository();
        List<Logger> loggers = new ArrayList<>();
        Enumeration<org.apache.log4j.Logger> enumLogger = loggerRepository.getCurrentLoggers();
        
        while (enumLogger.hasMoreElements())
        {
            loggers.add(enumLogger.nextElement());
        }
        
        loggers.add(loggerRepository.getRootLogger());
        
        Collections.sort(loggers, new LoggerComparator());
        
        Map<String, Object> logCategories = new HashMap<>();
        Set<Map<String, String>> categoryLevels = new HashSet<> ();
        
        for (Logger logger : loggers)
        {
            Level level = logger.getLevel();

            String category = logger.getName();
            if (category.equals("root"))
            {
                logCategories.put("children", new ArrayList<> ());
                logCategories.put("name", "root");
                logCategories.put("fullname", "root");
                logCategories.put("level", level.toString());
            }
            else
            {
                Map<String, String> categoryLevel = new HashMap<>();
                categoryLevel.put("category", category);
                categoryLevel.put("level", level == null ? "inherit" : level.toString());
                categoryLevels.add(categoryLevel);
            }
        }

        String fullName = null;
        for (Map<String, String> categoryLevel : categoryLevels)
        {
            fullName = categoryLevel.get("category");
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> childrenCategories = (List<Map<String, Object>>) logCategories.get("children");
            createCategory(childrenCategories, fullName, categoryLevel.get("level"), fullName);
        }
        
        return Map.of("children", logCategories);
    }
    
    /**
     * Creates a log category
     * @param children the list of categories already created
     * @param categoryName the name of the category to create
     * @param level the level of the category to create
     * @param fullName the full name of the category
     */
    protected void createCategory(List<Map<String, Object>> children, String categoryName, String level, String fullName)
    {
        int i = categoryName.indexOf(".");
        if (i != -1)
        {
            // Creates intermediary tree nodes
            String parentCategoryName = categoryName.substring(0, i);
            String childCategoryName = categoryName.substring(i + 1);
            
            Map<String, Object> parentCategoryNode = _getNode(children, parentCategoryName);
            
            if (parentCategoryNode == null)
            {
                // We did not find any existing node, let's create it
                parentCategoryNode = new HashMap<> ();
                parentCategoryNode.put("children", new ArrayList<> ());
                parentCategoryNode.put("leaf", false);
                parentCategoryNode.put("level", "inherit");
                parentCategoryNode.put("name", parentCategoryName);
                parentCategoryNode.put("fullname", fullName.substring(0, fullName.indexOf(parentCategoryName)) + parentCategoryName);
                
                children.add(parentCategoryNode);
            }
            
            parentCategoryNode.put("leaf", false);
            
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> childrenCategories = (List<Map<String, Object>>) parentCategoryNode.get("children");
            createCategory(childrenCategories, childCategoryName, level, fullName);
        }
        else
        {
            Map<String, Object> categoryNode = _getNode(children, categoryName);
            if (categoryNode == null)
            {
                // Creates tree leaves
                categoryNode = new HashMap<> ();
                
                categoryNode.put("children", new ArrayList<> ());
                categoryNode.put("leaf", true);
                categoryNode.put("level", level);
                categoryNode.put("name", categoryName);
                categoryNode.put("fullname", fullName);
    
                children.add(categoryNode);
            }
            else
            {
                // The intermediary node was already created, let's update it
                categoryNode.put("level", level);
            }
        }
    }
    
    private Map<String, Object> _getNode(List<Map<String, Object>> children, String categoryName)
    {
        for (Map<String, Object> child : children)
        {
            if (Strings.CS.equals((String) child.get("name"), categoryName))
            {
                return child;
            }
        }
        return null;
    }
}