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

import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.InputStream;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

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.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.Constants;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;

import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.PluginsManager;
import org.ametys.runtime.plugin.component.AbstractThreadSafeComponentExtensionPoint;

/**
 * This class is in charge of handling dynamic content type descriptor extension point.<br>
 * This point handles the pool of available dynamic content type descriptors.
 */
public class DynamicContentTypeDescriptorExtentionPoint extends AbstractThreadSafeComponentExtensionPoint<DynamicContentTypeDescriptor>
{
    /** Avalon Role */
    public static final String ROLE = "org.ametys.cms.contenttype.DynamicContentTypeExtentionPoint"; // FIXME RUNTIME-1023 DynamicContentTypeDescriptorExtentionPoint.class.getName();
    
    private static final String DYNAMIC_CONTENT_TYPE_DESCRIPTOR_CACHE = "dynamicContentTypeDescriptorCache";
    
    private ServiceManager _smanager;
    private ContentTypeExtensionPoint _contentTypeEP;
    private ContentTypesHelper _contentTypesHelper;
    private AbstractCacheManager _cacheManager;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _smanager = manager;
        _contentTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        super.initialize();
        _cacheManager.createMemoryCache(DYNAMIC_CONTENT_TYPE_DESCRIPTOR_CACHE,
                new I18nizableText("plugin.cms", "PLUGIN_CMS_CACHE_DYNAMIC_CONTENT_TYPE_DESCRIPTOR_LABEL"),
                new I18nizableText("plugin.cms", "PLUGIN_CMS_CACHE_DYNAMIC_CONTENT_TYPE_DESCRIPTOR_DESCRIPTION"),
                true,
                null);
    }
    
    @Override
    public void initializeExtensions() throws Exception
    {
        org.apache.cocoon.environment.Context cocoonContext = (org.apache.cocoon.environment.Context) _context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
        final Set<String> pluginNames = PluginsManager.getInstance().getPluginNames();
        
        File rootFile = new File(cocoonContext.getRealPath("/WEB-INF/param/content-types/_dynamic"));
        File[] plugins = rootFile.listFiles(new FilenameFilter()
        {
            @Override
            public boolean accept(File dir, String name)
            {
                return pluginNames.contains(name);
            }
        });
        
        if (plugins != null)
        {
            for (File pluginDir : plugins)
            {
                String pluginName = pluginDir.getName();
                
                File[] files = pluginDir.listFiles(new FilenameFilter()
                {
                    @Override
                    public boolean accept(File dir, String name)
                    {
                        return name.endsWith(".xml");
                    }
                });
                
                for (File file : files)
                {
                    Configuration configuration = null;
                    try (InputStream is = new FileInputStream(file))
                    {
                        configuration = new DefaultConfigurationBuilder(true).build(is);
                        
                        String id = "dynamic-content-type." + file.getName().substring(0, file.getName().lastIndexOf('.'));
                        
                        DefaultConfiguration conf = new DefaultConfiguration("extension");
                        conf.setAttribute("id", id);
                        conf.addChild(configuration);
                        
                        addComponent(pluginName, "unknown", id, DynamicContentTypeDescriptor.class, conf);
                    }
                    catch (Exception ex)
                    {
                        throw new ConfigurationException("Unable to parse dynamic content type configuration at WEB-INF/param/content-types/dynamic/" + file.getName() + ".xml", configuration, ex);
                    }
                }
            }
        }
        
        super.initializeExtensions();
    }
    
    /**
     * Get the matching dynamic descriptor for given content types and mixins
     * @param contentTypes The content types
     * @param mixinTypes The mixins
     * @return The matching dynamic descriptor or <code>null</code> if not found
     */
    public DynamicContentTypeDescriptor getMatchingDescriptor (String[] contentTypes, String[] mixinTypes)
    {
        String cacheId = _getCacheIdentifier(contentTypes, mixinTypes);
        
        String extensionId = _getCache().get(cacheId);
        if (extensionId != null)
        {
            return getExtension(extensionId);
        }
        
        DynamicContentTypeDescriptor matchingDynamicCType = null;
        
        int bestCTypeScore = 0;
        int bestMixinScore = 0;
        
        for (String id : getExtensionsIds())
        {
            int cTypeScore = 0;
            int mixinScore = 0;
            
            DynamicContentTypeDescriptor dynamicContentType = getExtension(id);
            
            boolean dynamicTypesMatch = true;
            String[] dynamicCTypes = dynamicContentType.getSupertypeIds();
            Set<String> cTypesAndAncestors = _getContentTypesAndAncestor(contentTypes, mixinTypes);
            for (String cTypeId : dynamicCTypes)
            {
                if (!cTypesAndAncestors.contains(cTypeId))
                {
                    // Dynamic types do not include all content types, ignore
                    dynamicTypesMatch = false;
                    break;
                }
            }
            
            if (dynamicTypesMatch)
            {
                for (String cTypeId : dynamicContentType.getSupertypeIds())
                {
                    ContentType cType = _contentTypeEP.getExtension(cTypeId);
                    
                    if (!cType.isMixin() && ArrayUtils.contains(contentTypes, cTypeId))
                    {
                        cTypeScore += 1;
                    }
                    else if (cType.isMixin() && ArrayUtils.contains(mixinTypes, cTypeId))
                    {
                        mixinScore += 1;
                    }
                }
                
                if (cTypeScore > bestCTypeScore
                    || cTypeScore == bestCTypeScore && mixinScore > bestMixinScore)
                {
                    bestCTypeScore = cTypeScore;
                    bestMixinScore = mixinScore;

                    matchingDynamicCType = dynamicContentType;
                    _getCache().put(cacheId, id);
                }
            }
        }
        
        return matchingDynamicCType;
    }
    
    private Set<String> _getContentTypesAndAncestor (String[] contentTypes, String[] mixins)
    {
        Set<String> cTypesAndAncestors = new HashSet<>();
        
        if (_contentTypesHelper == null)
        {
            try
            {
                _contentTypesHelper = (ContentTypesHelper) _smanager.lookup(ContentTypesHelper.ROLE);
            }
            catch (ServiceException e)
            {
                throw new IllegalStateException(e);
            }
        }
        
        String[] allContentTypes = (String[]) ArrayUtils.addAll(contentTypes, mixins);
        
        for (String id : allContentTypes)
        {
            cTypesAndAncestors.add(id);
            cTypesAndAncestors.addAll(_contentTypesHelper.getAncestors(id));
        }
        
        return cTypesAndAncestors;
        
    }
    
    private String _getCacheIdentifier (String[] contentTypes, String[] mixins)
    {
        Arrays.sort(contentTypes);
        String name = StringUtils.join(contentTypes, ";");
        
        if (mixins.length > 0)
        {
            Arrays.sort(mixins);
            name += ";";
            name += StringUtils.join(mixins, ";");
        }
        
        return name;
    }
    
    private Cache<String, String> _getCache()
    {
        return _cacheManager.get(DYNAMIC_CONTENT_TYPE_DESCRIPTOR_CACHE);
    }
}