/*
 *  Copyright 2012 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.core.userpref;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;

import org.ametys.core.ui.Callable;
import org.ametys.core.util.I18nizableTextKeyComparator;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.CategorizedElementDefinitionHelper;
import org.ametys.runtime.model.DefinitionContext;
import org.ametys.runtime.model.SimpleViewItemGroup;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewElement;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemGroup;
import org.ametys.runtime.plugin.component.AbstractThreadSafeComponentExtensionPoint;
import org.ametys.runtime.workspace.WorkspaceMatcher;

/**
 * Extension point holding all {@link UserPreference} definitions.
 */
public class UserPreferencesExtensionPoint extends AbstractThreadSafeComponentExtensionPoint<UserPreferenceProvider>
{
    /** Avalon Role */
    public static final String ROLE = UserPreferencesExtensionPoint.class.getName();
    
    /**
     * Get the declared user preference with the given name.
     * @param contextVars The context variables including environment elements
     * @param name The preference's name
     * @return the user preference, or <code>null</code> if none has been found.
     */
    public UserPreference getUserPreference(Map<String, String> contextVars, String name)
    {
        return getUserPreferences(contextVars)
                .stream()
                .filter(userPreference -> name.equals(userPreference.getName()))
                .findFirst()
                .orElse(null);
    }
    
    /**
     * Get all the declared user preferences.
     * @param contextVars The context variables including environment elements
     * @return the user preferences (read-only collection).
     */
    public Collection<UserPreference> getUserPreferences(Map<String, String> contextVars)
    {
        Collection<UserPreference> userPreferences = new ArrayList<>();
        
        for (String extensionId : getExtensionsIds())
        {
            UserPreferenceProvider provider = getExtension(extensionId);
            userPreferences.addAll(provider.getPreferences(contextVars));
        }
        
        return userPreferences;
    }
    
    /**
     * Get the definition of user preferences
     * @param excludePrivate true to exclude private preference from the view
     * @return the view
     */
    @Callable(rights = Callable.NO_CHECK_REQUIRED)
    public Map<String, Object> getUserPreferencesViewAsJson(boolean excludePrivate)
    {
        Request request = ContextHelper.getRequest(_context);
        Map<String, String> contextVars = Map.of(UserPreferenceProvider.CONTEXT_VAR_WORKSPACE, (String) request.getAttribute(WorkspaceMatcher.WORKSPACE_NAME));
        View userPreferencesView = getUserPreferencesView(excludePrivate, contextVars);
        DefinitionContext definitionContext = DefinitionContext.newInstance()
                                                                   .withEdition(true);
        return userPreferencesView.toJSON(definitionContext);
    }
    
    /**
     * Retrieves the view with all user preferences, classified by group and ordered.
     * @param contextVars The context variables including environment elements
     * @return the view with all user preferences, classified by group and ordered.
     */
    public View getUserPreferencesView(Map<String, String> contextVars)
    {
        return getUserPreferencesView(false, contextVars);
    }
    
    /**
     * Retrieves the view with all user preferences, classified by group and ordered.
     * @param excludePrivate <code>true</code> to exclude private preferences from the view, <code>false</code> otherwise
     * @param contextVars The context variables including environment elements
     * @return the view with all user preferences, classified by group and ordered.
     */
    public View getUserPreferencesView(boolean excludePrivate, Map<String, String> contextVars)
    {
        Collection<UserPreference> preferences = getUserPreferences(contextVars);
        
        Comparator<I18nizableText> groupsComparator = new I18nizableTextKeyComparator();
        Comparator<UserPreference> userPreferencesComparator = new UserPreferencesPositionComparator();
        
        return _buildView(preferences, groupsComparator, userPreferencesComparator, excludePrivate);
    }
    
    private View _buildView(Collection<UserPreference> wrappers, Comparator<I18nizableText> groupsComparator, Comparator<UserPreference> userPreferencesComparator, boolean excludePrivate)
    {
        View view = new View();

        Map<I18nizableText, Collection<UserPreference>> groups = _groupUserPreferences(wrappers);

        Collection<I18nizableText> sortedGroups = CategorizedElementDefinitionHelper.sortItemsList(groups.keySet(), groupsComparator);
        for (I18nizableText groupLabel : sortedGroups)
        {
            ViewItem groupViewItem = _buildGroupViewItem(groupLabel, groups.get(groupLabel), userPreferencesComparator, excludePrivate);
            view.addViewItem(groupViewItem);
        }
        return view;
    }

    private Map<I18nizableText, Collection<UserPreference>> _groupUserPreferences(Collection<UserPreference> preferences)
    {
        Map<I18nizableText, Collection<UserPreference>> groups = new HashMap<>();

        // Classify parameters by groups
        for (UserPreference preference : preferences)
        {
            I18nizableText displayGroup = preference.getDisplayGroup();
            Collection<UserPreference> group = groups.computeIfAbsent(displayGroup, __ -> new ArrayList<>());
            group.add(preference);
        }

        return groups;
    }

    private ViewItem _buildGroupViewItem(I18nizableText groupLabel, Collection<UserPreference> preferences, Comparator<UserPreference> userPreferencesComparator, boolean excludePrivate) throws IllegalArgumentException
    {
        SimpleViewItemGroup groupViewItem = new SimpleViewItemGroup();
        groupViewItem.setRole(ViewItemGroup.FIELDSET_ROLE);
        groupViewItem.setLabel(groupLabel);

        Collection<UserPreference> items = CategorizedElementDefinitionHelper.sortItemsList(preferences, userPreferencesComparator);
        for (UserPreference item : items)
        {
            if (!item.isPrivate() || !excludePrivate)
            {
                ViewElement userPreferenceViewItem = new ViewElement();
                userPreferenceViewItem.setDefinition(item);
                groupViewItem.addViewItem(userPreferenceViewItem);
            }
        }

        return groupViewItem;
    }
    
    /**
     * Compares user preferences on their position in the group
     */
    class UserPreferencesPositionComparator implements Comparator<UserPreference>
    {
        @Override
        public int compare(UserPreference preference1, UserPreference preference2)
        {
            int positionComparison = CategorizedElementDefinitionHelper.comparePositions(preference1.getPosition(), preference2.getPosition());
            if (positionComparison != 0)
            {
                return positionComparison;
            }
            else
            {
                return preference1.compareTo(preference2);
            }
        }
    }
}