/*
 *  Copyright 2016 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.log;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.apache.log4j.lf5.LogLevel;
import org.apache.log4j.lf5.LogLevelFormatException;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.ThrowableInformation;


/**
 * Log appender that stores a pile of logs in memory.
 */
public class MemoryAppender extends org.apache.log4j.AppenderSkeleton
{
    /** Time of expiration of a log (10 minutes) */
    private static final long __LOG_EXPIRATION_TIME = 10 * 60 * 1000; 
    /** Time duration between 2 cleansing of logs queue (10 seconds) */
    private static final long __TIME_DURATION_BEFORE_NEXT_CLEAN = 10 * 1000; 
    
    private long _lastCleanTime;
    
    private LinkedList<MemoryLogRecord> _logsQueue;
    
    /**
     * Default constructor for the memory appender
     */
    public MemoryAppender()
    {
        _logsQueue = new LinkedList<>();
    }

    @Override
    protected void append(LoggingEvent event)
    {
        // Add the logging event information to a LogRecord
        // Retrieve the information from the log4j LoggingEvent.
        MemoryLogRecord record = new MemoryLogRecord();

        record.setCategory(event.getLoggerName());
        record.setMessage(event.getRenderedMessage());
        record.setLocation(event.getLocationInformation().fullInfo);
        record.setMillis(event.timeStamp);
        record.setUser((String) event.getMDC("user"));
        record.setRequestURI((String) event.getMDC("requestURI"));

        ThrowableInformation throwableInformation = event.getThrowableInformation();
        if (throwableInformation != null)
        {
            record.setThrownStackTrace(throwableInformation);
        }

        try 
        {
            String level = event.getLevel().toString();
            record.setLevel(LogLevel.valueOf(level));
        } 
        catch (LogLevelFormatException e)
        {
            // If the priority level doesn't match one of the predefined
            // log levels, then set the level to warning.
            record.setLevel(LogLevel.WARN);
        }
        
        // Remove logs older than 10 minutes
        removeExpiredEvents(System.currentTimeMillis() - __LOG_EXPIRATION_TIME);
        
        // Add logs to the queue
        synchronized (_logsQueue)
        {
            _logsQueue.add(record);
        }
    }
    
    /**
     * Get the logs from a given timestamp
     * @param fromTimestamp If greater than 0, get the events more recent than this timestamp parameter. If equals or less than 0, returns all events
     * @return The log events
     */
    @SuppressWarnings("unchecked")
    public List<MemoryLogRecord> getEvents(long fromTimestamp)
    {
        return getEvents(fromTimestamp, Collections.EMPTY_LIST);
    }
    
    /**
     * Get the logs from a given timestamp and filtered by specific categories
     * @param fromTimestamp If greater than 0, get the events more recent than this timestamp parameter. If equals or less than 0, returns all events
     * @param filterCategories The filter categories
     * @return The log events
     */
    public List<MemoryLogRecord> getEvents(long fromTimestamp, List<String> filterCategories)
    {
        // New events can occur at current time, retrieve only the fixed logs list: 1ms before now.
        long toTimestamp = System.currentTimeMillis() - 1;
        
        synchronized (_logsQueue)
        {
            if (fromTimestamp <= 0 && filterCategories.isEmpty())
            {
                // returns all records
                return new ArrayList<>(_logsQueue);
            }
            else if (toTimestamp < fromTimestamp)
            {
                return new ArrayList<>();
            }
            else
            {
                List<MemoryLogRecord> recentRecords = new ArrayList<>();
                
                Iterator<MemoryLogRecord> it = _logsQueue.descendingIterator();
                while (it.hasNext())
                {
                    MemoryLogRecord record = it.next();
                    if ((fromTimestamp <= 0 || record.getMillis() >= fromTimestamp) && record.getMillis() <= toTimestamp)
                    {
                        if (_matchCategoryFilter(filterCategories, record))
                        {
                            recentRecords.add(record);
                        }
                    }
                    else
                    {
                        // Stop iteration
                        break;
                    }
                }
                
                return recentRecords;
            }
        }
    }
    
    private boolean _matchCategoryFilter(List<String> filterCategories, MemoryLogRecord record)
    {
        String recordCategory = record.getCategory();
        if (filterCategories.isEmpty() || filterCategories.contains(recordCategory))
        {
            return true;
        }
        
        for (String category : filterCategories)
        {
            if (recordCategory.startsWith(category.concat(".")))
            {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Remove the expired log records every 10 seconds
     * @param from The expiration date in milliseconds
     */
    public void removeExpiredEvents(long from)
    {
        synchronized (_logsQueue)
        {
            if (_lastCleanTime != 0 && _lastCleanTime + __TIME_DURATION_BEFORE_NEXT_CLEAN > System.currentTimeMillis())
            {
                // The time between 2 cleansing has not yet expired, do nothing
                return;
            }
            
            // Remove logs before 'from'
            MemoryLogRecord record = _logsQueue.peek();
            while (record != null && record.getMillis() < from)
            {
                _logsQueue.remove();
                record = _logsQueue.peek();
            }
            
            _lastCleanTime = System.currentTimeMillis();
        }
    }
    
    @Override
    public boolean requiresLayout()
    {
        return false;
    }

    @Override
    public void close() 
    {
        _logsQueue.clear();
    }

}