/*
 *  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.workspaces.events.activitystream;

import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.stream.Collectors;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.query.Query;

import org.apache.avalon.framework.component.Component;
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.lang.StringUtils;

import org.ametys.core.right.RightManager;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.explorer.resources.ModifiableResourceCollection;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.events.EventType;
import org.ametys.plugins.repository.events.EventTypeExpression;
import org.ametys.plugins.repository.events.EventTypeExtensionPoint;
import org.ametys.plugins.repository.provider.AbstractRepository;
import org.ametys.plugins.repository.query.SortCriteria;
import org.ametys.plugins.repository.query.expression.AndExpression;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.OrExpression;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.plugins.workspaces.project.ProjectManager;
import org.ametys.plugins.workspaces.project.modules.WorkspaceModule;
import org.ametys.plugins.workspaces.project.objects.Project;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;

/**
 * Component gathering methods for the activity stream service
 */
public class ActivityStreamClientInteraction extends AbstractLogEnabled implements Component, Serviceable, PluginAware
{
    /** The Avalon role */
    public static final String ROLE = ActivityStreamClientInteraction.class.getName();
    
    private ProjectManager _projectManager;
    private EventTypeExtensionPoint _eventTypeExtensionPoint;

    private CurrentUserProvider _currentUserProvider;

    private RightManager _rightManager;

    private Repository _repository;

    private String _pluginName;

    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _projectManager = (ProjectManager) serviceManager.lookup(ProjectManager.ROLE);
        _rightManager = (RightManager) serviceManager.lookup(RightManager.ROLE);
        _eventTypeExtensionPoint = (EventTypeExtensionPoint) serviceManager.lookup(EventTypeExtensionPoint.ROLE);
        _currentUserProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        
        _repository = (Repository) serviceManager.lookup(AbstractRepository.ROLE);
    }
    
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
    }
    
    /**
     * Get the events of the given project and of the given event types
     * @param projectName the project's name
     * @param filterEventTypes the type of events to retain 
     * @param limit The max number of events
     * @return the retained events
     */
    @Callable
    public List<Map<String, Object>> getProjectEvents(String projectName, List<String> filterEventTypes, int limit)
    {
        if (projectName == null)
        {
            List<String> projectNames = transformProjectsToName(getProjectsForCurrentUser());
            return getEvents(projectNames, filterEventTypes, limit);
        }
        else
        {
            return getEvents(Collections.singletonList(projectName), filterEventTypes, limit);
        }
    }
    
    /**
     * Get the events of the given projects and of the given event types
     * @param projectNames the names of the projects. Can not be null. 
     * @param filterEventTypes the type of events to retain. Can be empty to get all events.
     * @param limit The max number of events
     * @return the retained events
     */
    @Callable
    public List<Map<String, Object>> getEvents(List<String> projectNames, List<String> filterEventTypes, int limit)
    {
        List<Map<String, Object>> mergedEvents = new ArrayList<>();
        
        if (projectNames.isEmpty())
        {
            return mergedEvents;
        }
        
        List<Expression> exprs = new ArrayList<>();
        
        for (String projectName : projectNames)
        {
            Project project = _projectManager.getProject(projectName);
            
            Set<String> allowedEventTypes = _getAllowedEventTypesByProject(project);
            
            if (filterEventTypes != null && filterEventTypes.size() > 0)
            {
                allowedEventTypes.retainAll(filterEventTypes);
            }
            
            if (allowedEventTypes.size() > 0)
            {
                Expression eventExpr = new EventTypeExpression(Operator.EQ, allowedEventTypes.toArray(new String[allowedEventTypes.size()]));
                Expression projectExpr = new StringExpression("projectName", Operator.EQ, projectName);
                
                exprs.add(new AndExpression(eventExpr, projectExpr));
            }
        }
        
        List<Map<String, Object>> events = new ArrayList<>();
        
        if (exprs.size() > 0)
        {
            // FIXME Not possible to use JCREventHelper or #_eventTypeExtensionPoint.getEvents here (waiting for Solr query)
            
            SortCriteria sortCriteria = new SortCriteria();
            sortCriteria.addJCRPropertyCriterion(EventType.EVENT_DATE, false, false);
            
            Expression finalExpr = new OrExpression(exprs.toArray(new Expression[exprs.size()]));
            
            String xpathQuery = _getXPathQuery(finalExpr, sortCriteria);
            NodeIterator nodesIt = _query(xpathQuery);
            
            int count = 0;
            while (nodesIt.hasNext() && count <= limit)
            {
                Node eventNode = nodesIt.nextNode();
                try
                {
                    String type = eventNode.getProperty(EventType.EVENT_TYPE).getString();
                    
                    Map<String, Object> event2json = _eventTypeExtensionPoint.getEventType(type).event2JSON(eventNode);
                    if (!event2json.isEmpty())
                    {
                        events.add(event2json);
                        count++;
                    }
                }
                catch (RepositoryException e)
                {
                    getLogger().error("Unable to retrieve event '" + eventNode.toString() + "' for activity stream of project(s) " + projectNames + ". Event has been skipped from activity stream", e);
                }
                
                
            }
        }
        
        // FIXME After merge, the number of events could be lower than limit
        mergedEvents.addAll(_eventTypeExtensionPoint.mergeEvents(events));
        
        return mergedEvents;
    }
    
    /**
     * Get the date of last event regardless the current user's rights
     * @param projectName The project's name
     * @param excludeEventTypes the types of event to ignore from this search
     * @return the date of last event or null if no event found or an error occurred
     */
    public ZonedDateTime getDateOfLastEvent(String projectName, List<String> excludeEventTypes)
    {
        List<Expression> expressions = new ArrayList<>();
        
        for (String eventType : excludeEventTypes)
        {
            expressions.add(new EventTypeExpression(Operator.NE, eventType));
        }
        
        return _getDateOfLastEvent(projectName, new AndExpression(expressions.toArray(new Expression[expressions.size()])));
    }

    /**
     * Get the date of last event regardless the current user's rights
     * @param projectName The project's name
     * @param includeEventTypes the types of event to ignore from this search
     * @return the date of last event or null if no event found or an error occurred
     */
    public ZonedDateTime getDateOfLastEventByEventType(String projectName, Collection<String> includeEventTypes)
    {
        List<Expression> expressions = new ArrayList<>();
        
        for (String eventType : includeEventTypes)
        {
            expressions.add(new EventTypeExpression(Operator.EQ, eventType));
        }
        
        return _getDateOfLastEvent(projectName, new OrExpression(expressions.toArray(new Expression[expressions.size()])));
    }
    
    private ZonedDateTime _getDateOfLastEvent(String projectName, Expression eventTypesExpression)
    {
        Expression projectNameExpression = new StringExpression("projectName", Operator.EQ, projectName);
        
        Expression eventExpr = new AndExpression(projectNameExpression, eventTypesExpression);
        SortCriteria sortCriteria = new SortCriteria();
        sortCriteria.addJCRPropertyCriterion(EventType.EVENT_DATE, false, false);
        
        String xpathQuery = _getXPathQuery(eventExpr, sortCriteria);
        NodeIterator nodesIt = _query(xpathQuery);
        
        if (nodesIt.hasNext())
        {
            Node eventNode = nodesIt.nextNode();
            try
            {
                Calendar date = eventNode.getProperty(EventType.EVENT_DATE).getDate();
                return DateUtils.asZonedDateTime(date);
            }
            catch (RepositoryException e)
            {
                getLogger().error("Fail to get the last event date for project %s", projectName);
            }
        }
        
        return null;
    }
    
    // FIXME Temporary method, should be removed when the events will indexed in Solr
    private String _getXPathQuery(Expression expr, SortCriteria sortCriteria)
    {
        String predicats = StringUtils.trimToNull(expr.build());
        
        return "//element(*, ametys:event)" 
            + (predicats != null ? "[" + predicats + "]" : "") 
            + ((sortCriteria != null) ? (" " + sortCriteria.build()) : "");
    }
    
    // FIXME Temporary method, should be removed when the events will indexed in Solr
    private NodeIterator _query(String jcrQuery)
    {
        Session session = null;
        try
        {
            session = _repository.login();
            @SuppressWarnings("deprecation")
            Query query = session.getWorkspace().getQueryManager().createQuery(jcrQuery, Query.XPATH);
            return query.execute().getNodes();
        }
        catch (RepositoryException ex)
        {
            if (session != null)
            {
                session.logout();
            }

            throw new AmetysRepositoryException("An error occured executing the JCR query : " + jcrQuery, ex);
        }
    }
    
    /**
     * Get the allowed event types classified by categories
     * @param projectName The project's name
     * @return The allowed event types
     */
    @Callable
    public Map<String, Map<String, Object>> getAllowedEventTypes(String projectName)
    {
        // FIXME To be rewrite when event will be indexed in Solr
        // TODO The events stored by workspaces should store their own category. This will be avoid to hard coded this classification.
        
        Set<String> allowedTypes = new HashSet<>();
        
        if (StringUtils.isEmpty(projectName))
        {
            Set<Project> userProjects = getProjectsForCurrentUser();
            for (Project userProject : userProjects)
            {
                allowedTypes.addAll(_getAllowedEventTypesByProject(userProject));
            }
        }
        else
        {
            Project project = _projectManager.getProject(projectName);
            allowedTypes.addAll(_getAllowedEventTypesByProject(project));
        }
        
        Map<String, Map<String, Object>> allowedEventTypes = new HashMap<>();
        
        allowedEventTypes.put("documents", new HashMap<>());
        allowedEventTypes.get("documents").put("label", new I18nizableText("plugin." + _pluginName, "PLUGINS_WORKSPACES_PROJECT_SERVICE_ACTIVITY_STREAM_DOCUMENTS_LABEL"));
         
        allowedEventTypes.put("calendars", new HashMap<>());
        allowedEventTypes.get("calendars").put("label", new I18nizableText("plugin." + _pluginName, "PLUGINS_WORKSPACES_PROJECT_SERVICE_ACTIVITY_STREAM_CALENDARS_LABEL"));
        
        allowedEventTypes.put("threads", new HashMap<>());
        allowedEventTypes.get("threads").put("label", new I18nizableText("plugin." + _pluginName, "PLUGINS_WORKSPACES_PROJECT_SERVICE_ACTIVITY_STREAM_THREADS_LABEL"));
        
        allowedEventTypes.put("minisite", new HashMap<>());
        allowedEventTypes.get("minisite").put("label", new I18nizableText("plugin." + _pluginName, "PLUGINS_WORKSPACES_PROJECT_SERVICE_ACTIVITY_STREAM_MINISITE_LABEL"));
        
        allowedEventTypes.put("tasks", new HashMap<>());
        allowedEventTypes.get("tasks").put("label", new I18nizableText("plugin." + _pluginName, "PLUGINS_WORKSPACES_PROJECT_SERVICE_ACTIVITY_STREAM_TASKS_LABEL"));
        
        allowedEventTypes.put("projects", new HashMap<>());
        allowedEventTypes.get("projects").put("label", new I18nizableText("plugin." + _pluginName, "PLUGINS_WORKSPACES_PROJECT_SERVICE_ACTIVITY_STREAM_PROJECTS_LABEL"));
        
        Set<String> eventTypeIds = _eventTypeExtensionPoint.getExtensionsIds();
        for (String eventTypeId : eventTypeIds)
        {
            EventType eventType = _eventTypeExtensionPoint.getExtension(eventTypeId);
            Map<String, I18nizableText> supportedTypes = eventType.getSupportedTypes();
            
            for (Entry<String, I18nizableText> entry : supportedTypes.entrySet())
            {
                if (allowedTypes.contains(entry.getKey()))
                {
                    _classifyEventType(allowedEventTypes, entry.getKey(), entry.getValue());
                }
            }
        }
        
        return allowedEventTypes;
    }
    
    private boolean _classifyEventType(Map<String, Map<String, Object>> allowedEventTypes, String eventTypeId, I18nizableText eventTypeLabel)
    {
        boolean classified = _classifyEventType("resource.", "documents", allowedEventTypes, eventTypeId, eventTypeLabel) 
                                || _classifyEventType("calendar.", "calendars", allowedEventTypes, eventTypeId, eventTypeLabel)
                                || _classifyEventType("task.", "tasks", allowedEventTypes, eventTypeId, eventTypeLabel)
                                || _classifyEventType("thread.", "threads", allowedEventTypes, eventTypeId, eventTypeLabel)
                                || _classifyEventType("member.", "projects", allowedEventTypes, eventTypeId, eventTypeLabel)
                                || _classifyEventType("wallcontent.", "projects", allowedEventTypes, eventTypeId, eventTypeLabel)
                                || _classifyEventType("wiki.", "wiki", allowedEventTypes, eventTypeId, eventTypeLabel);
        
        return classified;
        
    }
    
    @SuppressWarnings("unchecked")
    private boolean _classifyEventType(String withPrefix, String toAllowedEventType, Map<String, Map<String, Object>> allowedEventTypes, String eventTypeId, I18nizableText eventTypeLabel)
    {
        if (eventTypeId.startsWith(withPrefix))
        {
            if (!allowedEventTypes.get(toAllowedEventType).containsKey("eventTypes"))
            {
                allowedEventTypes.get(toAllowedEventType).put("eventTypes", new HashMap<String, Object>());
            }
            
            ((Map<String, I18nizableText>) allowedEventTypes.get(toAllowedEventType).get("eventTypes")).put(eventTypeId, eventTypeLabel);
            
            return true;
        }
        
        return false;
    }
    
    /**
     * Get the list of allowed event types for the given projects
     * @param projects The projects
     * @return The allowed event types
     */
    public Set<String> getAllowedEventTypes (Set<Project> projects)
    {
        Set<String> allowedTypes = new HashSet<>();
        
        for (Project project : projects)
        {
            allowedTypes.addAll(_getAllowedEventTypesByProject(project));
        }
        
        return allowedTypes;
    }
    
    // FIXME temporary method
    // The allowed types are hard coded according the user access on root modules.
    private Set<String> _getAllowedEventTypesByProject (Project project)
    {
        Set<String> allowedTypes = new HashSet<>();
        
        for (WorkspaceModule moduleManager : _projectManager.getModules(project))
        {
            ModifiableResourceCollection moduleRoot = moduleManager.getModuleRoot(project, false);
            if (moduleRoot != null && _rightManager.currentUserHasReadAccess(moduleRoot))
            {
                allowedTypes.addAll(moduleManager.getAllowedEventTypes());
            }
        }
        
        return allowedTypes;
    }
    
    /**
     * Get the events for the current user with the allowed event types get into the user projects.
     * @param limit The max number of results
     * @return The events for the user projects
     */
    public List<Map<String, Object>> getEventsForCurrentUser(int limit)
    {
        Set<Project> userProjects = getProjectsForCurrentUser();
        return getEventsForCurrentUser(userProjects, limit);
    }
    
    /**
     * Get the events for the current user with the allowed event types get into the given projects.
     * @param projects the projects
     * @param limit The max number of results
     * @return The events for the user projects
     */
    public List<Map<String, Object>> getEventsForCurrentUser(Set<Project> projects, int limit)
    {
        List<String> projectNames = transformProjectsToName(projects);
        Set<String> allowedEventTypes = getAllowedEventTypes(projects);
        
        List<Map<String, Object>> events = getEvents(projectNames, new ArrayList<>(allowedEventTypes), limit);
        
        // Add a parameter representing the date in the ISO 8601 format
        events.stream().forEach(event -> 
        {
            // start date
            event.put("date-iso", DateUtils.dateToString((Date) event.get("date")));
            
            // optional end date
            Date endDate = (Date) event.get("endDate");
            if (endDate != null)
            {
                event.put("end-date-iso", DateUtils.dateToString(endDate));
            }
        });
        
        return events;
    }
    
    private Set<Project> getProjectsForCurrentUser()
    {
        UserIdentity user = _currentUserProvider.getUser();
        return _projectManager.getUserProjects(user).keySet();
    }
    
    private List<String> transformProjectsToName(Set<Project> userProjects)
    {
        return userProjects.stream()
            .map(p -> p.getName())
            .collect(Collectors.toList());
    }
}