/*
 *  Copyright 2010 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.web.clientsideelement;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang.StringUtils;

import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.ui.Callable;
import org.ametys.core.ui.StaticClientSideElement;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.I18nUtils;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.web.repository.page.ModifiablePage;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.ServicesAssignmentHandler;
import org.ametys.web.service.Service;
import org.ametys.web.service.ServiceExtensionPoint;

/**
 * Menu that lists the services
 */
public class ServiceMenu extends AbstractPageMenu
{
    /** The list of content types */
    protected ServiceExtensionPoint _serviceExtensionPoint;
    /** The service assignment handler */
    protected ServicesAssignmentHandler _servicesHandler;
    /** The i18n utils */
    protected I18nUtils _i18nUtils;
    
    private boolean _servicesInitialized;
    
    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        super.service(smanager);
        
        _serviceExtensionPoint = (ServiceExtensionPoint) smanager.lookup(ServiceExtensionPoint.ROLE);
        _resolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
        _servicesHandler = (ServicesAssignmentHandler) smanager.lookup(ServicesAssignmentHandler.ROLE);
        _i18nUtils = (I18nUtils) smanager.lookup(I18nUtils.ROLE);
    }
    
    @Override
    protected Script _configureScript(Configuration configuration) throws ConfigurationException
    {
        Script script = super._configureScript(configuration);
        
        for (String serviceId : _serviceExtensionPoint.getExtensionsIds())
        {
            Service service = _serviceExtensionPoint.getExtension(serviceId);
            
            script.getCSSFiles().addAll(service.getCSSFiles());
            script.getCSSFiles().addAll(service.getParametersScript().getCSSFiles());
            script.getScriptFiles().addAll(service.getParametersScript().getScriptFiles());
        }
        
        return script;
    }
    
    @Override
    public List<Script> getScripts(boolean ignoreRights, Map<String, Object> contextParameters)
    {
        if (_serviceExtensionPoint.getExtensionsIds().size() == 0)
        {
            // Hide menu if there is no service
            return new ArrayList<>();
        }

        return super.getScripts(ignoreRights, contextParameters);
    }
    
    /**
     * Get the available templates for pages
     * @param pageId The id of the page
     * @param zoneName the name of the zone
     * @return the list of templates' name
     */
    @Callable
    public Map<String, Object> getAvailableServices (String pageId, String zoneName)
    {
        Map<String, Object> result = new HashMap<>();
        
        List<String> services = new ArrayList<>();
        
        Page page = _resolver.resolveById(pageId);
        
        if (!(page instanceof ModifiablePage))
        {
            Map<String, Object> pageParams = getPageDefaultParameters(page);
            pageParams.put("description", getNoModifiablePageDescription(page));

            result.put("nomodifiable-page", pageParams);
        }
        else if (!hasRight(page))
        {
            Map<String, Object> pageParams = getPageDefaultParameters(page);
            pageParams.put("description", getNoRightPageDescription(page));

            @SuppressWarnings("unchecked")
            List<Map<String, Object>> norightPages = (List<Map<String, Object>>) result.get("noright-pages");
            norightPages.add(pageParams);
        }
        else
        {
            Set<String> availablesServicesId = _servicesHandler.getAvailableServices(page, zoneName);
            for (String serviceId : availablesServicesId)
            {
                Service service = _serviceExtensionPoint.getExtension(serviceId);
                if (hasRight(service, page))
                {
                    services.add(serviceId);
                }
                
            }
        }
        
        result.put("services", services);
        return result;
    }
    
    /**
     * Determines if user has convenient right on page
     * @param page The page
     * @param rightId The right to check
     * @return true if the user has convenient right
     */
    protected boolean _hasRight (Page page, String rightId)
    {
        if (StringUtils.isEmpty(rightId))
        {
            return true;
        }

        return _rightManager.hasRight(_currentUserProvider.getUser(), rightId, page) == RightResult.RIGHT_ALLOW;
    }
    
    @Override
    protected void _getGalleryItems(Map<String, Object> parameters, Map<String, Object> contextualParameters)
    {
        try
        {
            _lazyInitializeServiceGallery();
        }
        catch (Exception e)
        {
            throw new IllegalStateException("Unable to lookup client side element local components", e);
        }
        
        super._getGalleryItems(parameters, contextualParameters);
    }
    
    private void _lazyInitializeServiceGallery() throws ConfigurationException
    {
        if (!_servicesInitialized)
        {
            Map<I18nizableText, Set<Service>> servicesByGroup = _getServicesByGroup();
            
            if (servicesByGroup.size() > 0)
            {
                GalleryItem galleryItem = new GalleryItem();
                
                for (I18nizableText groupLabel : servicesByGroup.keySet())
                {
                    GalleryGroup galleryGroup = new GalleryGroup(groupLabel);
                    galleryItem.addGroup(galleryGroup);
                    
                    Set<Service> cTypes = servicesByGroup.get(groupLabel);
                    for (Service service : cTypes)
                    {
                        String id = this.getId() + "-" + service.getId();
                        
                        Configuration conf = _getServiceConfiguration (id, service);
                        _galleryItemManager.addComponent(_pluginName, null, id, StaticClientSideElement.class, conf);
                        galleryGroup.addItem(new UnresolvedItem(id, true));
                    }
                }
                
                _galleryItems.add(galleryItem);
            }
            
            if (_galleryItems.size() > 0)
            {
                try
                {
                    _galleryItemManager.initialize();
                }
                catch (Exception e)
                {
                    throw new ConfigurationException("Unable to lookup parameter local components", e);
                }
            }
        }
        
        _servicesInitialized = true;
    }
    
    /**
     * Get the list of services classified by groups
     * @return The content types
     */
    protected Map<I18nizableText, Set<Service>> _getServicesByGroup ()
    {
        Map<I18nizableText, Set<Service>> groups = new TreeMap<>(new I18nizableTextComparator());
        
        if (this._script.getParameters().get("services") != null)
        {
            String[] serviceIds = ((String) this._script.getParameters().get("services")).split(",");
            
            for (String serviceId : serviceIds)
            {
                Service service = _serviceExtensionPoint.getExtension(serviceId);
                
                if (isValidService(service))
                {
                    addService (service, groups);
                }
            }
        }
        else
        {
            Set<String> serviceIds = _serviceExtensionPoint.getExtensionsIds();
            
            for (String serviceId : serviceIds)
            {
                Service service = _serviceExtensionPoint.getExtension(serviceId);
                
                if (isValidService(service))
                {
                    addService (service, groups);
                }
            }
        }
        
        return groups;
    }
    
    /**
     * Add service to groups
     * @param service The service
     * @param groups The groups
     */
    protected void addService (Service service, Map<I18nizableText, Set<Service>> groups)
    {
        I18nizableText group = service.getCategory();
        if ((group.isI18n() && group.getKey().isEmpty()) || (!group.isI18n() && group.getLabel().isEmpty()))
        {
            group = new I18nizableText("plugin.web", "PLUGINS_WEB_SERVICE_CATEGORY_90_OTHERS");
        }
        
        if (!groups.containsKey(group))
        {
            groups.put(group, new TreeSet<>(new ServiceComparator()));
        }
        
        Set<Service> services = groups.get(group);
        services.add(service);
    }
    
    
    /**
     * Determines if the service is a valid service for the gallery
     * @param service The service
     * @return true if it is a valid service
     */
    protected boolean isValidService (Service service)
    {
        return !service.isPrivate();
    }
    
    /**
     * Get the configuration of the service item
     * @param id The id of item
     * @param service The service
     * @return The configuration
     */
    protected Configuration _getServiceConfiguration (String id, Service service)
    {
        DefaultConfiguration conf = new DefaultConfiguration("extension");
        conf.setAttribute("id", id);
        
        DefaultConfiguration classConf = new DefaultConfiguration("class");
        classConf.setAttribute("name", "Ametys.ribbon.element.ui.ButtonController");
        
        // Label
        DefaultConfiguration labelConf = new DefaultConfiguration("label");
        I18nizableText label = service.getLabel();
        if (label.isI18n())
        {
            labelConf.setAttribute("i18n", "true");
            labelConf.setValue(label.getCatalogue() + ":" + label.getKey());
        }
        else
        {
            labelConf.setValue(label.getLabel());
        }
        classConf.addChild(labelConf);
        
        // Description
        DefaultConfiguration descConf = new DefaultConfiguration("description");
        I18nizableText description = service.getLabel();
        if (description.isI18n())
        {
            descConf.setAttribute("i18n", "true");
            descConf.setValue(description.getCatalogue() + ":" + description.getKey());
        }
        else
        {
            descConf.setValue(description.getLabel());
        }
        classConf.addChild(descConf);
        
        // Service id
        DefaultConfiguration idConf = new DefaultConfiguration("serviceId");
        idConf.setValue(service.getId());
        classConf.addChild(idConf);
        
        // Icons or glyph
        if (service.getIconGlyph() != null)
        {
            DefaultConfiguration iconGlyphConf = new DefaultConfiguration("icon-glyph");
            iconGlyphConf.setValue(service.getIconGlyph());
            classConf.addChild(iconGlyphConf);
        }
        if (service.getIconDecorator() != null)
        {
            DefaultConfiguration iconDecoratorConf = new DefaultConfiguration("icon-decorator");
            iconDecoratorConf.setValue(service.getIconDecorator());
            classConf.addChild(iconDecoratorConf);
        }
        if (service.getSmallIcon() != null)
        {
            DefaultConfiguration iconSmallConf = new DefaultConfiguration("icon-small");
            iconSmallConf.setValue(service.getSmallIcon());
            classConf.addChild(iconSmallConf);
            DefaultConfiguration iconMediumConf = new DefaultConfiguration("icon-medium");
            iconMediumConf.setValue(service.getMediumIcon());
            classConf.addChild(iconMediumConf);
            DefaultConfiguration iconLargeConf = new DefaultConfiguration("icon-large");
            iconLargeConf.setValue(service.getLargeIcon());
            classConf.addChild(iconLargeConf);
        }
        
        // Parameters action
        DefaultConfiguration paramsAction = new DefaultConfiguration("params-action");
        paramsAction.setValue(service.getParametersScript().getScriptClassname());
        classConf.addChild(paramsAction);
        
        // Common configuration
        @SuppressWarnings("unchecked")
        Map<String, Object> commonConfig = (Map<String, Object>) this._script.getParameters().get("items-config");
        for (String tagName : commonConfig.keySet())
        {
            DefaultConfiguration c = new DefaultConfiguration(tagName);
            c.setValue(String.valueOf(commonConfig.get(tagName)));
            classConf.addChild(c);
        }
        
        conf.addChild(classConf);
        return conf;
    }
    
    class ServiceComparator implements Comparator<Service>
    {
        @Override
        public int compare(Service s1, Service s2)
        {
            I18nizableText t1 = s1.getLabel();
            I18nizableText t2 = s2.getLabel();
            
            String str1 = t1.isI18n() ? t1.getKey() : t1.getLabel();
            String str2 = t2.isI18n() ? t2.getKey() : t2.getLabel();
            
            int compareTo = str1.toString().compareTo(str2.toString());
            if (compareTo == 0)
            {
                // Content types have same keys but there are not equals, so do not return 0 to add it in TreeSet
                // Indeed, in a TreeSet implementation two elements that are equal by the method compareTo are, from the standpoint of the set, equal 
                return 1;
            }
            return compareTo;
        }
    }
    
    class I18nizableTextComparator implements Comparator<I18nizableText>
    {
        @Override
        public int compare(I18nizableText t1, I18nizableText t2)
        {
            String str1 = t1.isI18n() ? t1.getKey() : t1.getLabel();
            String str2 = t2.isI18n() ? t2.getKey() : t2.getLabel();
            
            return str1.toString().compareTo(str2.toString());
        }
    }
    
    
    /**
     * Test if the current user has the right needed by the service to create it.
     * @param service the service.
     * @param page the current page.
     * @return true if the user has the right needed, false otherwise.
     */
    protected boolean hasRight(Service service, Page page)
    {
        boolean hasRight = false;
        
        if (service != null)
        {
            String right = service.getRight();
            
            if (right == null)
            {
                hasRight = true;
            }
            else
            {
                UserIdentity user = _currentUserProvider.getUser();
                hasRight = _rightManager.hasRight(user, right, page) == RightResult.RIGHT_ALLOW;
            }
        }
        
        return hasRight;
    }
    
}