/*
 *  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.cms.contenttype;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.acting.ServiceableAction;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Redirector;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.repository.Content;
import org.ametys.core.cocoon.JSonReader;
import org.ametys.plugins.repository.AmetysObjectResolver;

/**
 * Get the common metadata set between given content types and/or among given contents
 */
public class GetCommonMetadataSetAction extends ServiceableAction
{
    /** The content type EP */
    protected ContentTypeExtensionPoint _cTypeEP;
    
    /** The content types Helper */
    protected ContentTypesHelper _contentTypesHelper;
    
    /** The ametys object resolver */
    protected AmetysObjectResolver _resolver;
    
    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        super.service(smanager);
        _cTypeEP = (ContentTypeExtensionPoint) smanager.lookup(ContentTypeExtensionPoint.ROLE);
        _contentTypesHelper = (ContentTypesHelper) smanager.lookup(ContentTypesHelper.ROLE);
        _resolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
    }
    
    @Override
    public Map act(Redirector redirector, SourceResolver resolver, Map objectModel, String source, Parameters parameters) throws Exception
    {
        Request request = ObjectModelHelper.getRequest(objectModel);
        
        boolean isEdition = BooleanUtils.toBoolean(request.getParameter("isEdition")); // false by default
        boolean includeInternal = BooleanUtils.toBoolean(request.getParameter("includeInternal")); // false by default
        
        Set<String> cTypesId = getContentTypes(request);
        cTypesId.addAll(getContentTypesFromContents(request));
        if (cTypesId.isEmpty())
        {
            cTypesId.addAll(getAllAvailablesContentTypes(request, true));
        }
        
        Map<String, Object> result = new HashMap<>();
        
        Collection<Map<String, Object>> commonMetadataSetsInfo = getCommonMetadataSetsInfo(cTypesId, isEdition, includeInternal);
        result.put("metadataSets", commonMetadataSetsInfo);
        
        request.setAttribute(JSonReader.OBJECT_TO_READ, result);
        return EMPTY_MAP;
    }
    
    
    /**
     * Retrieves the common metadata labels by name
     * @param cTypesId the content types ids
     * @param isEdition Is the metadata set for edition ? 
     * @param includeInternal include internal metadata sets ?
     * @return The map of metadata set
     */
    protected Collection<Map<String, Object>> getCommonMetadataSetsInfo(Collection<String> cTypesId, boolean isEdition, boolean includeInternal)
    {
        // Map<Metadata set name, Map<key, value>>>
        Map<String, Map<String, Object>> commonMetadataSetsInfo = null;
        
        for (String cTypeId : cTypesId)
        {
            List<Map<String, Object>> metadataSetsInfo = _contentTypesHelper.getMetadataSetsInfo(cTypeId, false, includeInternal);
            
            if (commonMetadataSetsInfo == null)
            {
                commonMetadataSetsInfo = new HashMap<>();
                for (Map<String, Object> entry : metadataSetsInfo)
                {
                    String metadataSetName = (String) entry.get("name");
                    commonMetadataSetsInfo.put(metadataSetName, entry);
                }
            }
            else
            {
                Set<String> metadataSetNames = new HashSet<>();
                for (Map<String, Object> entry : metadataSetsInfo)
                {
                    String metadataSetName = (String) entry.get("name");
                    metadataSetNames.add(metadataSetName);
                }
                
                // only retains common metadata (performs a set intersection)
                commonMetadataSetsInfo.keySet().retainAll(metadataSetNames);
            }
        }
        
        return commonMetadataSetsInfo != null ? commonMetadataSetsInfo.values() : Collections.EMPTY_LIST;
    }
    
    /**
     * Get the content types id to search for
     * @param request the request
     * @return the content types
     */
    protected Set<String> getContentTypes(Request request)
    {
        Set<String> cTypeIds = new HashSet<>();
        String[] ids = request.getParameterValues("ids");
        
        if (ids != null)
        {
            for (String id : ids)
            {
                if (StringUtils.isNotEmpty(id))
                {
                    // id can contains comma (when allOption is selected for example).
                    for (String idPart : StringUtils.split(id, ','))
                    {
                        cTypeIds.add(idPart);
                    }
                }
            }
        }
        
        return cTypeIds;
    }
    
    /**
     * Get the content types id to search for
     * @param request the request
     * @return the content types
     */
    protected Set<String> getContentTypesFromContents(Request request)
    {
        Set<String> cTypeIds = new HashSet<>();
        String[] contentIds = request.getParameterValues("contentIds");
        
        if (contentIds != null)
        {
            for (String contentId : contentIds)
            {
                if (StringUtils.isNotEmpty(contentId))
                {
                    Content content = _resolver.resolveById(contentId);
                    
                    String[] allContentTypes = ArrayUtils.addAll(content.getTypes(), content.getMixinTypes());
                    for (String id : allContentTypes)
                    {
                        cTypeIds.add(id);
                    }
                }
            }
        }
        
        return cTypeIds;
    }
    
    /**
     * Get all the available content types 
     * @param request the request
     * @param publicOnly Only the non private content types will be returned
     * @return all the available content types 
     */
    protected Set<String> getAllAvailablesContentTypes (Request request, boolean publicOnly)
    {
        Set<String> types = new HashSet<>();
        
        for (String id : _cTypeEP.getExtensionsIds())
        {
            if (!publicOnly || !_cTypeEP.getExtension(id).isPrivate())
            {
                types.add(id);
            }
        }
        
        return types;
    }
}