/*
 *  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.plugins.repository.events;

import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.jcr.Node;
import javax.jcr.RepositoryException;

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.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;

import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;

/**
 * Default implementation for {@link EventType} storing event in JCR
 */
public class DefaultEventType extends AbstractLogEnabled implements Configurable, EventType, Serviceable, PluginAware
{
    /** The default time range to merge compatible events : 5 minutes */
    private static final int __MAX_MERGE_EVENT_RANGE = 5 * 60 * 1000;
    
    /** The current user provider */
    protected CurrentUserProvider _currentUserProvider;
    /** Helper to get users */
    protected UserHelper _userHelper;
    
    private Map<String, I18nizableText> _supportedEventTypes;

    private String _pluginName;
    
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _supportedEventTypes = new HashMap<>();
        
        Configuration[] supportedTypesConf = configuration.getChild("supported-types").getChildren("supported-type");
        if (supportedTypesConf.length == 0)
        {
            throw new ConfigurationException("Missing 'supported-types' configuration", configuration);
        }
        
        for (Configuration conf : supportedTypesConf)
        {
            String id = conf.getAttribute("id");
            I18nizableText label = I18nizableText.parseI18nizableText(conf.getChild("label"), "plugin." + _pluginName, id);
            _supportedEventTypes.put(id, label);
        }
    }
    
    @Override   
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _currentUserProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        _userHelper = (UserHelper) serviceManager.lookup(UserHelper.ROLE);
    }
    
    
    @Override
    public Map<String, I18nizableText> getSupportedTypes()
    {
        return _supportedEventTypes;
    }
    
    @Override
    public Node storeEvent(String eventId, Map<String, Object> parameters, EventHolder eventHolder) throws RepositoryException
    {
        Node eventsNode = eventHolder.getEventsRootNode();
        Date now = new Date();
        
        Node eventNode = null;
        try
        {
            eventNode = JCREventHelper.addEventNode(eventHolder, now, eventId, _currentUserProvider.getUser());
            
            storeAdditionalEventData(eventNode, parameters);
            
            eventNode.getSession().save();
            
            return eventNode;
        }
        catch (RepositoryException e)
        {
            if (eventNode != null)
            {
                eventNode.remove();
                eventsNode.getSession().save();
            }
            throw new EventTypeProcessingException("Failed to create event of type " + eventId, e);
        }
    }
    
    /**
     * Store additional data on event
     * @param eventNode The event node
     * @param parameters The event's parameters
     * @throws RepositoryException if an error occurred
     */
    protected void storeAdditionalEventData (Node eventNode, Map<String, Object> parameters) throws RepositoryException
    {
        // Nothing
    }
    
    @Override
    public Map<String, Object> event2JSON(Node eventNode) throws RepositoryException
    {
        Map<String, Object> event = new HashMap<>();
        
        event.put("eventName", eventNode.getName());
        
        // Type
        event.put("type", eventNode.getProperty(EVENT_TYPE).getString());
        
        // Date
        Calendar date = eventNode.getProperty(EVENT_DATE).getDate();
        event.put("date", date.getTime());

        // Author
        event.put("author", _userHelper.user2json(_getAuthor(eventNode)));

        return event;
    }
    
    /**
     * Gets the identity of the author of the given event
     * @param eventNode The node of the event
     * @return the identity of the author of the given event
     * @throws RepositoryException  if an error occurs while manipulating the repository
     */
    protected UserIdentity _getAuthor(Node eventNode) throws RepositoryException
    {
        Node authorNode = eventNode.getNode(EVENT_AUTHOR);
        String populationId = authorNode.getProperty(RepositoryConstants.NAMESPACE_PREFIX + ":population").getString();
        String login = authorNode.getProperty(RepositoryConstants.NAMESPACE_PREFIX + ":login").getString();
        
        return new UserIdentity(login, populationId);
    }
    
    @Override
    @SuppressWarnings("unchecked")
    public boolean isMergeable (Map<String, Object> event1, Map<String, Object> event2)
    {
        String type1 = (String) event1.get("type");
        String type2 = (String) event2.get("type");
        
        if (!type1.equals(type2))
        {
            return false;
        }
        
        Map<String, Object> author1 = (Map<String, Object>) event1.get("author");
        Map<String, Object> author2 = (Map<String, Object>) event2.get("author");
        
        if (!author1.equals(author2))
        {
            return false;
        }
        
        Date date1 = (Date) event1.get("date");
        Date date2 = (Date) event2.get("date");
        
        return date1 != null && date2 != null && Math.abs(date1.getTime() - date2.getTime()) < __MAX_MERGE_EVENT_RANGE;
    }
    
    @Override
    public Map<String, Object> mergeEvents(List<Map<String, Object>> events)
    {
        Map<String, Object> mergedEvent = events.get(0);
        
        mergedEvent.put("amount", events.size());
        
        // Date range 
        if (events.size() > 1)
        {
            Date startDate = null;
            Date endDate = null;
            
            for (Map<String, Object> event : events)
            {
                Date eventDate = (Date) event.get("date");
                if (startDate == null || eventDate.before(startDate))
                {
                    startDate = eventDate;
                }
                
                if (endDate == null || eventDate.after(endDate))
                {
                    endDate = eventDate;
                }
            }
            
            mergedEvent.put("date", startDate);
            
            if (endDate != null && startDate != null && (endDate.getTime() - startDate.getTime() > 1000 * 60))
            {
                // Ignore end date if events are less than 1 minute apart 
                mergedEvent.put("endDate", endDate);
            }
        }
        
        return mergedEvent;
    }
}