/*
 *  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.plugins.workspaces.calendars;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.explorer.calendars.Calendar;
import org.ametys.plugins.explorer.calendars.CalendarEvent;
import org.ametys.plugins.explorer.calendars.ModifiableCalendar;
import org.ametys.plugins.explorer.calendars.actions.CalendarDAO;
import org.ametys.plugins.explorer.calendars.jcr.JCRCalendar;
import org.ametys.plugins.explorer.calendars.jcr.JCRCalendarEvent;
import org.ametys.plugins.explorer.calendars.jcr.JCRCalendarFactory;
import org.ametys.plugins.explorer.workflow.AbstractExplorerNodeWorkflowComponent;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectIterator;
import org.ametys.plugins.repository.query.QueryHelper;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.plugins.workspaces.project.ProjectManager;
import org.ametys.runtime.i18n.I18nizableText;

import com.google.common.primitives.Ints;
import com.opensymphony.workflow.Workflow;
import com.opensymphony.workflow.WorkflowException;
import com.opensymphony.workflow.loader.ActionDescriptor;
import com.opensymphony.workflow.loader.StepDescriptor;
import com.opensymphony.workflow.loader.WorkflowDescriptor;
import com.opensymphony.workflow.spi.Step;

/**
 * DAO for manipulating calendars of a project
 *
 */
public class WorkspaceCalendarDAO extends CalendarDAO
{
    /** Avalon Role */
    @SuppressWarnings("hiding")
    public static final String ROLE = WorkspaceCalendarDAO.class.getName();
    
    private ProjectManager _projectManager;
    
    private MessagingConnectorCalendarManager _messagingConnectorCalendarManager;
   
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _projectManager = (ProjectManager) manager.lookup(ProjectManager.ROLE);
        _messagingConnectorCalendarManager = (MessagingConnectorCalendarManager) manager.lookup(MessagingConnectorCalendarManager.ROLE);
        
    }
    
    /**
     * Add an event
     * @param parameters The map of parameters to perform the action
     * @return The map of results populated by the underlying workflow action
     * @throws WorkflowException if an error occurred
     * @throws IllegalAccessException  If the user does not have the right to add an event
     */
    @Callable
    public Map<String, Object> addEvent(Map<String, Object> parameters) throws WorkflowException, IllegalAccessException
    {
        // Sanitize keywords and location (respectively tags and places in the client parameters)
        @SuppressWarnings("unchecked")
        Collection<String> keywords = (Collection<String>) parameters.get("tags");
        keywords = _sanitizeEventKeywordsInput(keywords);
        parameters.put("keywords", keywords);
        
        @SuppressWarnings("unchecked")
        Collection<String> locations = (Collection<String>) parameters.get("places");
        String location = _sanitizeEventLocationsInput(locations);
        parameters.put("location", location);
        
        Map<String, Object> result = doWorkflowEventAction(parameters);
        
        //TODO Move to create event action (workflow) ?
        String eventId = (String) result.get("id");
        _messagingConnectorCalendarManager.addEventInvitation(parameters, eventId);
        
        _projectManager.addTags(keywords);
        _projectManager.addPlaces(Arrays.asList(location.split(",")));
        
        _projectManager.getProjectsRoot().saveChanges();
        
        return result;
    }
    
    /**
     * Edit an event
     * @param parameters The map of parameters to perform the action
     * @return The map of results populated by the underlying workflow action
     * @throws WorkflowException if an error occurred
     */
    @Callable
    public Map<String, Object> editEvent(Map<String, Object> parameters) throws WorkflowException
    {
        // Sanitize keywords and location (respectively tags and places in the client parameters)
        @SuppressWarnings("unchecked")
        Collection<String> keywords = (Collection<String>) parameters.get("tags");
        keywords = _sanitizeEventKeywordsInput(keywords);
        parameters.put("keywords", keywords);
        
        @SuppressWarnings("unchecked")
        Collection<String> locations = (Collection<String>) parameters.get("places");
        String location = _sanitizeEventLocationsInput(locations);
        parameters.put("location", location);
        
        String eventId = (String) parameters.get("id");
        JCRCalendarEvent event = _resolver.resolveById(eventId);
        
        // handle event move if calendar has changed
        String previousCalendarId = event.getParent().getId();
        String parentId = (String) parameters.get("parentId");
        
        if (previousCalendarId != null && !StringUtils.equals(parentId, previousCalendarId))    
        {
            JCRCalendar parentCalendar = _resolver.resolveById(parentId);
            move(event, parentCalendar);
        }
        
        Map<String, Object> result = doWorkflowEventAction(parameters);
        
        //TODO Move to edit event action (workflow) ?
        String choice = (String) parameters.get("choice");
        if (!"unit".equals(choice))
        {
            _messagingConnectorCalendarManager.editEventInvitation(parameters, eventId);
        }
        
        _projectManager.addTags(keywords);
        _projectManager.addPlaces(Arrays.asList(location.split(",")));
        
        _projectManager.getProjectsRoot().saveChanges();
        
        return result;
    }
    
    @Override
    @Callable
    public Map<String, Object> deleteEvent(String id, String occurrence, String choice) throws IllegalAccessException
    {
        if (!"unit".equals(choice))
        {
            JCRCalendarEvent event = _resolver.resolveById(id);
            _messagingConnectorCalendarManager.deleteEvent(event);
        }
        
        return super.deleteEvent(id, occurrence, choice);
    }
    
    @Override
    @Callable
    public Map<String, Object> getCalendarData(Calendar calendar, boolean recursive, boolean includeEvents)
    {
        Map<String, Object> data = super.getCalendarData(calendar, recursive, includeEvents);
        data.put("rights", _extractCalendarRightData(calendar));
        return data;
    }
    
    @Override
    public Map<String, Object> getEventData(CalendarEvent event, boolean fullInfo)
    {
        Map<String, Object> eventData = super.getEventData(event, fullInfo);
        
        eventData.put("calendar", event.getParent().getName()); 
        
        eventData.put("isStillSynchronized", _messagingConnectorCalendarManager.isEventStillSynchronized(event.getId()));
        
        // tags and places are expected by the client (respectively keywords and location on the server side)
        eventData.put("tags", event.getKeywords());
        
        String location = StringUtils.defaultString(event.getLocation());
        eventData.put("places", Stream.of(location.split(",")).filter(StringUtils::isNotEmpty).collect(Collectors.toList()));
        
        // add event rights
        eventData.put("rights", _extractEventRightData(event));
        
        return eventData;
    }
    
    /**
     * Retrieves the available workflows for the calendars 
     * @param withSteps true to include the list of steps and corresponding actions
     * @return The list of workflow. Each entry is a map of data (id, label)
     */
    @Callable
    public List<Map<String, Object>> getWorkflows(boolean withSteps)
    {
        List<Map<String, Object>> workflows = new ArrayList<>();
        
        for (String workflowName : _workflowHelper.getWorkflowNames())
        {
            if (StringUtils.startsWith(workflowName, "calendar-"))
            {
                Map<String, Object> workflow = new HashMap<>();
                workflows.add(workflow);
                
                workflow.put("id", workflowName);
                workflow.put("isDefault", StringUtils.contains(workflowName, "default"));
                
                String i18nKey = "WORKFLOW_" + workflowName;
                workflow.put("label", new I18nizableText("application", i18nKey));
                
                if (withSteps)
                {
                    WorkflowDescriptor workflowDescriptor = _workflowHelper.getWorkflowDescriptor(workflowName);
                    workflow.put("steps", _getSteps(workflowDescriptor));
                    workflow.put("actions", _getActions(workflowDescriptor));
                }
            }
        }
        
        return workflows;
    }
    
    /**
     * Get the workflow state of an event
     * @param eventId The id of the event
     * @return A map containing information about the workflow state
     */
    @Callable
    public Map<String, Object> getWorkflowState(String eventId)
    {
        Map<String, Object> state = new HashMap<>();
        
        CalendarEvent event = _resolver.resolveById(eventId);
        Workflow workflow = _workflowProvider.getAmetysObjectWorkflow(event);
        
        long workflowId = event.getWorkflowId();
        state.put("workflowName", workflow.getWorkflowName(workflowId));
        
        Step step = (Step) workflow.getCurrentSteps(workflowId).stream().findFirst().get();
        state.put("step", step.getStepId());
        
        Map<String, Object> inputs = new HashMap<>();
        inputs.put(AbstractExplorerNodeWorkflowComponent.EXPLORERNODE_KEY, event.getParent()); // event's parent is the calendar
        state.put("actions", workflow.getAvailableActions(workflowId, inputs));
        
        return state;
    }
    
    /**
     * Get the ICS token for the given calendar
     * @param calendarId The calendar id
     * @return The ICS token
     */
    @Callable
    public Map<String, Object> getCalendarIcsToken(String calendarId)
    {
        Map<String, Object> result = new HashMap<>();
        
        Calendar calendar = (Calendar) _resolver.resolveById(calendarId);
        String token = getCalendarIcsToken(calendar, true);
        
        if (StringUtils.isNotEmpty(token))
        {
            result.put("token", token);
        }
        
        return result;
    }
    
    
    /**
     * Get or create the calendar ICS token
     * @param calendar The calendar
     * @param createIfNotExisting Create the token if none exists for the given calendar
     * @return The token
     */
    public String getCalendarIcsToken(Calendar calendar, boolean createIfNotExisting)
    {
        String token = calendar.getIcsUrlToken();
        
        if (createIfNotExisting && token == null && calendar instanceof ModifiableCalendar)
        {
            token = UUID.randomUUID().toString();
            ((ModifiableCalendar) calendar).setIcsUrlToken(token);
            ((ModifiableCalendar) calendar).saveChanges();
        }
        
        return token;
    }
    
    /**
     * Retrieve the calendar for the matching ICS token
     * @param token The ICS token
     * @return The calendar, or null if not found
     */
    public Calendar getCalendarFromIcsToken(String token)
    {
        if (StringUtils.isEmpty(token))
        {
            return null;
        }
        
        Expression expr = new StringExpression(JCRCalendar.CALENDAR_ICS_TOKEN, Operator.EQ, token);
        String calendarsQuery = QueryHelper.getXPathQuery(null, JCRCalendarFactory.CALENDAR_NODETYPE, expr);
        AmetysObjectIterable<Calendar> calendars = _resolver.query(calendarsQuery);
        AmetysObjectIterator<Calendar> calendarsIterator = calendars.iterator();
        
        if (calendarsIterator.getSize() > 0)
        {
            return calendarsIterator.next();
        }

        return null;
    }
    
    
    /**
     * Get the steps of a workflow
     * @param workflowDescriptor workflow descriptor
     * @return The list of steps
     */
    protected List<Map<String, Object>> _getSteps(WorkflowDescriptor workflowDescriptor)
    {
        List<StepDescriptor> stepDescriptors = workflowDescriptor.getSteps();
                
        return stepDescriptors.stream()
            .map(stepDescriptor -> _getStep(workflowDescriptor, stepDescriptor))
            .collect(Collectors.toList());
    }
    
    /**
     * Get a map of data about a step
     * @param workflowDescriptor workflow descriptor
     * @param stepDescriptor step descriptor
     * @return The map of data
     */
    protected Map<String, Object> _getStep(WorkflowDescriptor workflowDescriptor, StepDescriptor stepDescriptor)
    {
        Map<String, Object> step = new HashMap<>();
        
        int stepId = stepDescriptor.getId();
        String stepName = stepDescriptor.getName();
        String[] nameParts = stepName.split(":");
        
        step.put("id", stepId);
        step.put("name", nameParts[nameParts.length - 1]); // step name without the possible catalog name
        
        I18nizableText i18nStepName = new I18nizableText("application", stepName);
        step.put("label", i18nStepName);
        step.put("description", new I18nizableText("application", stepName + "_DESCRIPTION"));
        
        // Default icons
        String[] icons = new String[]{"-small", "-medium", "-large"};
        for (String icon : icons)
        {
            if ("application".equals(i18nStepName.getCatalogue()))
            {
                step.put("icon" + icon, new I18nizableText("/plugins/explorer/resources_workflow/" + i18nStepName.getKey() + icon + ".png"));
            }
            else
            {
                String pluginName = i18nStepName.getCatalogue().substring("plugin.".length());
                step.put("icon" + icon, new I18nizableText("/plugins/" + pluginName + "/resources/img/workflow/" + i18nStepName.getKey() + icon + ".png"));
            }
        }
        
        List<Integer> actionsId = new LinkedList<>();
        step.put("actions", actionsId);
        
        for (int actionId : _workflowHelper.getAllActionsFromStep(workflowDescriptor.getName(), stepId))
        {
            actionsId.add(actionId);
        }
        
        return step;
    }
    
    /**
     * Get the actions of a workflow
     * @param workflowDescriptor workflow descriptor
     * @return The list of steps
     */
    protected List<Map<String, Object>> _getActions(WorkflowDescriptor workflowDescriptor)
    {
        int[] allActions = _workflowHelper.getAllActions(workflowDescriptor.getName());
        
        return Ints.asList(allActions).stream()
            .map(workflowDescriptor::getAction)
            .map(actionDescriptor -> _getAction(workflowDescriptor, actionDescriptor))
            .collect(Collectors.toList());
    }
    
    /**
     * Get a map of data about an action
     * @param workflowDescriptor workflow descriptor
     * @param actionDescriptor action descriptor
     * @return The map of data
     */
    protected Map<String, Object> _getAction(WorkflowDescriptor workflowDescriptor, ActionDescriptor actionDescriptor)
    {
        Map<String, Object> action = new HashMap<>();
        
        int actionId = actionDescriptor.getId();
        String actionName = actionDescriptor.getName();
        String[] nameParts = actionName.split(":");
        
        action.put("id", actionId);
        action.put("name", nameParts[nameParts.length - 1]); // action name without the possible catalog name
        
        action.put("label", new I18nizableText("application", actionName));
        action.put("description", new I18nizableText("application", actionName + "_DESCRIPTION"));
        
        action.put("internal", BooleanUtils.toBoolean((String) actionDescriptor.getMetaAttributes().get("internal")));
        
        return action;
    }
    
    /**
     * Internal method to extract the data concerning the right of the current user for an event
     * @param event The event
     * @return The map of right data. Keys are the rights id, and values indicates whether the current user has the right or not.
     */
    protected  Map<String, Object> _extractEventRightData(CalendarEvent event)
    {
        Map<String, Object> rightsData = new HashMap<>();
        UserIdentity user = _currentUserProvider.getUser();
        Calendar calendar = event.getParent();
        
        rightsData.put("edit", _rightManager.hasRight(user, RIGHTS_EVENT_EDIT, calendar) == RightResult.RIGHT_ALLOW);
        rightsData.put("delete", _rightManager.hasRight(user, RIGHTS_EVENT_DELETE, calendar) == RightResult.RIGHT_ALLOW);
        rightsData.put("delete-own", _rightManager.hasRight(user, RIGHTS_EVENT_DELETE_OWN, calendar) == RightResult.RIGHT_ALLOW);
        
        return rightsData;
    }
    
    /**
     * Internal method to extract the data concerning the right of the current user for a calendar
     * @param calendar The calendar
     * @return The map of right data. Keys are the rights id, and values indicates whether the current user has the right or not.
     */
    protected  Map<String, Object> _extractCalendarRightData(Calendar calendar)
    {
        Map<String, Object> rightsData = new HashMap<>();
        UserIdentity user = _currentUserProvider.getUser();
        
        // Add
        rightsData.put("add-event", _rightManager.hasRight(user, RIGHTS_EVENT_ADD, calendar) == RightResult.RIGHT_ALLOW);
        
        // edit - delete
        rightsData.put("edit", _rightManager.hasRight(user, RIGHTS_CALENDAR_EDIT, calendar) == RightResult.RIGHT_ALLOW);
        rightsData.put("delete", _rightManager.hasRight(user, RIGHTS_CALENDAR_DELETE, calendar) == RightResult.RIGHT_ALLOW);
        
        return rightsData;
    }
    
    /**
     * Sanitize the locations parameters received as input
     * @param locations collection of locations passed as an input
     * @return The sanitized location, a single string that represent a comma-separated list of locations 
     */
    protected String _sanitizeEventLocationsInput(Collection<String> locations)
    {
        Set<String> lowercasedPlaces = new HashSet<>();
        
        // duplicates are filtered out
        // and result is returned as a single string joined with a comma delimiter  
        return Optional.ofNullable(locations).orElseGet(ArrayList::new).stream()
                .map(String::trim)
                .filter(StringUtils::isNotEmpty)
                .filter(p -> lowercasedPlaces.add(p.toLowerCase()))
                .collect(Collectors.joining(","));
    }
    
    /**
     * Sanitize the keyword parameters received as input
     * @param keywords collection of keywords passed as an input
     * @return The sanitized collection
     */
    protected Collection<String> _sanitizeEventKeywordsInput(Collection<String> keywords)
    {
        // Enforce lowercase and remove possible duplicate tags
        return Optional.ofNullable(keywords).orElseGet(ArrayList::new).stream()
                .map(String::trim)
                .map(String::toLowerCase)
                .filter(StringUtils::isNotEmpty)
                .distinct()
                .collect(Collectors.toList());
    }
}