/*
 *  Copyright 2013 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.cms.clientsideelement;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.component.ComponentException;
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.slf4j.LoggerFactory;

import org.ametys.core.ui.ClientSideElement;
import org.ametys.core.ui.MenuClientSideElement;
import org.ametys.core.ui.RibbonControlsManager;
import org.ametys.core.ui.SimpleMenu;
import org.ametys.core.ui.StaticClientSideElement;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;
import org.ametys.runtime.workspace.WorkspaceMatcher;

/**
 * A smart menu to use for content
 *
 */
public class SmartContentMenu extends SmartContentClientSideElement implements MenuClientSideElement
{
    /** The client side element component manager for menu items. */
    protected ThreadSafeComponentManager<ClientSideElement> _menuItemManager;
    /** The ribbon control manager */
    protected RibbonControlsManager _ribbonControlManager;
    /** The service manager. */
    protected ServiceManager _serviceManager;
    
    /** The menu items */
    protected List<ClientSideElement> _menuItems;
    /** The primary menu item */
    protected ClientSideElement _primaryMenuItem;

    private List<ClientSideElement> _referencedClientSideElement;
    private List<UnresolvedItem> _unresolvedMenuItems;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        super.service(serviceManager);
        _serviceManager = serviceManager;
        _ribbonControlManager = (RibbonControlsManager) serviceManager.lookup(RibbonControlsManager.ROLE);
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _menuItemManager = new ThreadSafeComponentManager<>();
        _menuItemManager.setLogger(LoggerFactory.getLogger("cms.plugin.threadsafecomponent"));
        _menuItemManager.service(_serviceManager);
        
        super.configure(configuration);
        
        // Menu items.
        _referencedClientSideElement = new ArrayList<>();
        _unresolvedMenuItems = new ArrayList<>();
        _menuItems = new ArrayList<>();
        
        _configureItemsMenu(configuration);
    }
    
    /**
     * Configure the items menu
     * @param configuration the configuration
     * @throws ConfigurationException If the configuration is not correct.
     */
    protected void _configureItemsMenu(Configuration configuration) throws ConfigurationException
    {
        for (Configuration menuItemConfiguration : configuration.getChildren("menu-items"))
        {
            for (Configuration itemConfig : menuItemConfiguration.getChildren("item"))
            {
                boolean isPrimary = itemConfig.getAttributeAsBoolean("primaryItem", false);
                
                if (itemConfig.getAttribute("ref", null) != null)
                {
                    _unresolvedMenuItems.add(new UnresolvedItem(itemConfig.getAttribute("ref"), false, isPrimary));
                }
                else
                {
                    String id = itemConfig.getAttribute("id");

                    DefaultConfiguration conf = new DefaultConfiguration("extension");
                    conf.setAttribute("id", id);
                    conf.addChild(itemConfig.getChild("class"));
                    
                    if (itemConfig.getChild("menu-items", false) != null || itemConfig.getChild("gallery-item", false) != null)
                    {
                        if (itemConfig.getChild("menu-items", false) != null)
                        {
                            conf.addChild(itemConfig.getChild("menu-items"));
                        }
                        
                        if (itemConfig.getChild("gallery-item", false) != null)
                        {
                            conf.addChild(itemConfig.getChild("gallery-item"));
                        }
                        
                        _menuItemManager.addComponent(_pluginName, null, id, SimpleMenu.class, conf);
                    }
                    else
                    {
                        _menuItemManager.addComponent(_pluginName, null, id, StaticClientSideElement.class, conf);
                    }
                    _unresolvedMenuItems.add(new UnresolvedItem(id, true, isPrimary));
                }
            }
        }        
    }
    
    @Override
    public List<Script> getScripts(boolean ignoreRights, Map<String, Object> contextParameters)
    {
        List<Script> result = new ArrayList<>();
        
        try
        {
            _resolveMenuItems();
        }
        catch (Exception e)
        {
            throw new IllegalStateException("Unable to lookup client side element local components", e);
        }
        
        Map<String, Object> parameters = new HashMap<>();
        List<ScriptFile> cssFiles = new ArrayList<>();
        List<ScriptFile> scriptFiles = new ArrayList<>();

        // FIXME handle rights for workspace admin, here is a temporary workaround
        if (ignoreRights || (contextParameters != null && "admin".equals(contextParameters.get(WorkspaceMatcher.WORKSPACE_NAME))) || hasRight(getRights(contextParameters)))
        {
            List<Script> scripts = super.getScripts(ignoreRights, contextParameters);
            for (Script script : scripts)
            {
                cssFiles.addAll(script.getCSSFiles());
                scriptFiles.addAll(script.getScriptFiles());
                parameters.putAll(script.getParameters());
            }
            
            if (_primaryMenuItem != null)
            {
                for (Script script : _primaryMenuItem.getScripts(ignoreRights, contextParameters))
                {
                    Map<String, Object> primaryParameters = script.getParameters();
                    parameters.put("primary-menu-item-id", script.getId());
                    for (String paramId : primaryParameters.keySet())
                    {
                        if (!parameters.containsKey(paramId))
                        {
                            parameters.put(paramId, primaryParameters.get(paramId));
                        }
                    }
                }
            }
            
            // Menu items
            if (_menuItems.size() > 0)
            {
                List<String> menuItems = new ArrayList<>();
                for (ClientSideElement element : _menuItems)
                {
                    menuItems.add(element.getId());
                }
                parameters.put("menu-items", menuItems);
            }

            result.add(new Script(this.getId(), _script.getScriptClassname(), scriptFiles, cssFiles, parameters));
        }
        
        return result;
    }
    
    @Override
    public List<ClientSideElement> getReferencedClientSideElements()
    {
        return Collections.unmodifiableList(_referencedClientSideElement);
    }
    
    
    private void _resolveMenuItems() throws Exception
    {
        if (_unresolvedMenuItems != null)
        {
            _menuItemManager.initialize();
            
            for (UnresolvedItem unresolvedItem : _unresolvedMenuItems)
            {
                String id = unresolvedItem.getId();
                ClientSideElement element;
                if (unresolvedItem.isLocalItem())
                {
                    try
                    {
                        element = _menuItemManager.lookup(id);
                    }
                    catch (ComponentException e)
                    {
                        throw new Exception("Unable to lookup client side element role: '" + id + "'", e);
                    }
                }
                else
                {
                    element = _ribbonControlManager.getExtension(id);
                }
                
                if (unresolvedItem.isPrimary())
                {
                    _primaryMenuItem = element;
                }
                
                _menuItems.add(element);
                _referencedClientSideElement.add(element);
            }
        }
        
        _unresolvedMenuItems = null;
    }
    
    class UnresolvedItem
    {
        private String _itemId;
        private boolean _local;
        private boolean _primary;
        
        public UnresolvedItem(String id, boolean local)
        {
            _itemId = id;
            _local = local;
            _primary = false;
        }
        
        public UnresolvedItem(String id, boolean local, boolean primary)
        {
            _itemId = id;
            _local = local;
            _primary = primary;
        }
        
        public String getId ()
        {
            return _itemId;
        }
        
        public boolean isLocalItem ()
        {
            return _local;
        }
        
        public boolean isPrimary ()
        {
            return _primary;
        }
    }
}