/*
 *  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.search.ui.model;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;

import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeEnumerator;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.query.Query.Operator;
import org.ametys.cms.search.ui.model.impl.AbstractSearchUICriterion;
import org.ametys.cms.search.ui.model.impl.SystemSearchUICriterion;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ModelViewItem;
import org.ametys.runtime.model.ViewItemContainer;
import org.ametys.runtime.parameter.Enumerator;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

/**
 * Dynamic search model wrapping a search model with a restriction on content types
 *
 */
public class DynamicWrappedSearchUIModel implements SearchUIModel
{
    private ThreadSafeComponentManager<Enumerator> _enumeratorManager;
    
    private Logger _logger;
    private SearchUIModel _wrappedModel;
    private Set<String> _restrictedContentTypes;
    private Set<String> _restrictedMixins;
    private boolean _containsReferenceTable;
    
    /**
     * Constructor
     * @param model The wrapped search model
     * @param restrictedContentTypes The restricted content types
     * @param cTypeEP The content type extension point
     * @param logger The logger
     * @param context The context
     * @param manager The service manager
     */
    public DynamicWrappedSearchUIModel(SearchUIModel model, Collection<String> restrictedContentTypes, ContentTypeExtensionPoint cTypeEP, Logger logger, Context context, ServiceManager manager)
    {
        _wrappedModel = model;
        
        _restrictedContentTypes = new HashSet<>();
        _restrictedMixins = new HashSet<>();
        
        for (String cTypeId : restrictedContentTypes)
        {
            ContentType cType = cTypeEP.getExtension(cTypeId);
            if (cType.isMixin())
            {
                _restrictedMixins.add(cTypeId);
            }
            else
            {
                _restrictedContentTypes.add(cTypeId);
            }
            
            _containsReferenceTable = cType.isReferenceTable() || _containsReferenceTable;
            
            for (String subTypeId : cTypeEP.getSubTypes(cTypeId))
            {
                ContentType subCType = cTypeEP.getExtension(subTypeId);
                if (subCType.isMixin())
                {
                    _restrictedMixins.add(subTypeId);
                }
                else
                {
                    _restrictedContentTypes.add(subTypeId);
                }
                
                _containsReferenceTable = subCType.isReferenceTable() || _containsReferenceTable;
            }
        }
        
        try
        {
            _logger = logger;
            _enumeratorManager = new ThreadSafeComponentManager<>();
            _enumeratorManager.setLogger(logger);
            _enumeratorManager.contextualize(context);
            _enumeratorManager.service(manager);
            
            _addContentTypeEnumeratorComponent();
            _addContentTypeAndMixinEnumeratorComponent();
            _addMixinEnumeratorComponent();
            
            _enumeratorManager.initialize();
        }
        catch (Exception e)
        {
            _logger.error("Unable to instantiate enumerator for class: " + ContentTypeEnumerator.class.getName(), e);
        }
    }
    
    private void _addContentTypeEnumeratorComponent()
    {
        DefaultConfiguration conf = new DefaultConfiguration("criteria");
        
        DefaultConfiguration enumConf = new DefaultConfiguration("enumeration");
        
        DefaultConfiguration customEnumerator = new DefaultConfiguration("custom-enumerator");
        customEnumerator.setAttribute("class", ContentTypeEnumerator.class.getName());
        
        if (!_restrictedContentTypes.isEmpty())
        {
            DefaultConfiguration cTypeConf = new DefaultConfiguration("strictContentTypes");
            cTypeConf.setValue(StringUtils.join(_restrictedContentTypes, ","));
            customEnumerator.addChild(cTypeConf);
            
            DefaultConfiguration excludeConf = new DefaultConfiguration("excludeMixin");
            excludeConf.setValue(true);
            customEnumerator.addChild(excludeConf);
            
            if (_containsReferenceTable)
            {
                DefaultConfiguration excludeRefTableConf = new DefaultConfiguration("excludeReferenceTable");
                excludeRefTableConf.setValue(false);
                customEnumerator.addChild(excludeRefTableConf);
            }
            
            enumConf.addChild(customEnumerator);
            conf.addChild(enumConf);
            
            _enumeratorManager.addComponent("cms", null, ContentTypeEnumerator.class.getName(), ContentTypeEnumerator.class, conf);
        }
    }
    
    private void _addContentTypeAndMixinEnumeratorComponent()
    {
        DefaultConfiguration conf = new DefaultConfiguration("criteria");
        
        DefaultConfiguration enumConf = new DefaultConfiguration("enumeration");
        
        DefaultConfiguration customEnumerator = new DefaultConfiguration("custom-enumerator");
        customEnumerator.setAttribute("class", ContentTypeEnumerator.class.getName());
        
        if (_restrictedContentTypes.size() > 0)
        {
            DefaultConfiguration cTypeConf = new DefaultConfiguration("strictContentTypes");
            cTypeConf.setValue(StringUtils.join(_restrictedContentTypes, ","));
            customEnumerator.addChild(cTypeConf);
            
            if (_containsReferenceTable)
            {
                DefaultConfiguration excludeRefTableConf = new DefaultConfiguration("excludeReferenceTable");
                excludeRefTableConf.setValue(false);
                customEnumerator.addChild(excludeRefTableConf);
            }
            
            enumConf.addChild(customEnumerator);
            conf.addChild(enumConf);
            
            _enumeratorManager.addComponent("cms", null, ContentTypeEnumerator.class.getName() + ".ContentTypeAndMixin", ContentTypeEnumerator.class, conf);
        }
    }
    
    private void _addMixinEnumeratorComponent()
    {
        DefaultConfiguration conf = new DefaultConfiguration("criteria");
        
        DefaultConfiguration enumConf = new DefaultConfiguration("enumeration");
        
        DefaultConfiguration customEnumerator = new DefaultConfiguration("custom-enumerator");
        customEnumerator.setAttribute("class", ContentTypeEnumerator.class.getName());
        
        if (_restrictedMixins.size() > 0)
        {
            DefaultConfiguration cTypeConf = new DefaultConfiguration("strictContentTypes");
            cTypeConf.setValue(StringUtils.join(_restrictedMixins, ","));
            customEnumerator.addChild(cTypeConf);
            
            DefaultConfiguration excludeConf = new DefaultConfiguration("excludeMixin");
            excludeConf.setValue(false);
            customEnumerator.addChild(excludeConf);
            
            enumConf.addChild(customEnumerator);
            conf.addChild(enumConf);
            
            _enumeratorManager.addComponent("cms", null, ContentTypeEnumerator.class.getName() + ".Mixin", ContentTypeEnumerator.class, conf);
        }
    }

    @Override
    public Set<String> getContentTypes(Map<String, Object> contextualParameters)
    {
        return _restrictedContentTypes;
    }
    
    @Override
    public Set<String> getExcludedContentTypes(Map<String, Object> contextualParameters)
    {
        return Collections.<String>emptySet();
    }
    
    @Override
    public String getSearchUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getSearchUrl(contextualParameters);
    }

    @Override
    public String getSearchUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getSearchUrlPlugin(contextualParameters);
    }

    @Override
    public String getExportCSVUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportCSVUrl(contextualParameters);
    }

    @Override
    public String getExportCSVUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportCSVUrlPlugin(contextualParameters);
    }

    @Override
    public String getExportDOCUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportDOCUrl(contextualParameters);
    }

    @Override
    public String getExportDOCUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportDOCUrlPlugin(contextualParameters);
    }

    @Override
    public String getExportXMLUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportXMLUrl(contextualParameters);
    }

    @Override
    public String getExportXMLUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportXMLUrlPlugin(contextualParameters);
    }

    @Override
    public String getExportPDFUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportPDFUrl(contextualParameters);
    }

    @Override
    public String getExportPDFUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportPDFUrlPlugin(contextualParameters);
    }

    @Override
    public String getPrintUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getPrintUrl(contextualParameters);
    }

    @Override
    public String getPrintUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getPrintUrlPlugin(contextualParameters);
    }

    @Override
    public String getSummaryView()
    {
        return _wrappedModel.getSummaryView();
    }

    @Override
    public Map<String, SearchUICriterion> getCriteria(Map<String, Object> contextualParameters)
    {
        Map<String, SearchUICriterion> criteria = _wrappedModel.getCriteria(contextualParameters);
        
        Map<String, SearchUICriterion> wrappedCriteria = new LinkedHashMap<>(criteria.size());
        
        for (Entry<String, SearchUICriterion> entry : criteria.entrySet())
        {
            SearchUICriterion sc = entry.getValue();
            wrappedCriteria.put(entry.getKey(), wrap(sc));
        }
        
        return wrappedCriteria;
    }
    
    @Override
    public SearchUICriterion getCriterion(String id, Map<String, Object> contextualParameters)
    {
        SearchUICriterion criteria = _wrappedModel.getCriterion(id, contextualParameters);
        
        return wrap(criteria);
    }
    
    @Override
    public Map<String, SearchUICriterion> getFacetedCriteria(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getFacetedCriteria(contextualParameters);
    }
    
    @Override
    public Map<String, SearchUICriterion> getAdvancedCriteria(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getAdvancedCriteria(contextualParameters);
    }
    
    public ViewItemContainer getResultItems(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getResultItems(contextualParameters);
    }
    
    public ModelViewItem getResultItem(String itemPath, Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getResultItem(itemPath, contextualParameters);
    }
    
    @Override
    public int getPageSize(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getPageSize(contextualParameters);
    }
    
    @Override
    public String getWorkspace(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getWorkspace(contextualParameters);
    }
    
    /**
     * Wrap an existing search criterion.
     * @param criterion the search criterion to wrap.
     * @return the wrapped search criterion.
     */
    protected SearchUICriterion wrap(SearchUICriterion criterion)
    {
        try
        {
            if (criterion instanceof SystemSearchUICriterion systemSearchUICriterion
                    && !_restrictedContentTypes.isEmpty() 
                    && !systemSearchUICriterion.isJoined())
            {
                // Wrap "contentTypes" and "contentTypeOrMixin" system criteria, replacing their standard enumerator with the local one.
                Enumerator enumerator;
                switch (systemSearchUICriterion.getSystemPropertyId())
                {
                    case "contentTypes":
                        enumerator = _enumeratorManager.lookup(ContentTypeEnumerator.class.getName());
                        return new WrappedSearchUICriterion(criterion, enumerator);
                    case "contentTypeOrMixin":
                        enumerator = _enumeratorManager.lookup(ContentTypeEnumerator.class.getName() + ".ContentTypeAndMixin");
                        return new WrappedSearchUICriterion(criterion, enumerator);
                    case "mixins":
                        enumerator = _enumeratorManager.lookup(ContentTypeEnumerator.class.getName() + ".Mixin");
                        return new WrappedSearchUICriterion(criterion, enumerator);
                    default:
                        break;
                }
            }
            
            return criterion;
        }
        catch (Exception e)
        {
            _logger.error("Unable to lookup enumerator role.", e);
            throw new RuntimeException("Unable to lookup enumerator role.", e);
        }
    }
    
    /**
     * Search criteria wrapper.
     */
    protected class WrappedSearchUICriterion extends AbstractSearchUICriterion
    {
        
        /** The wrapped search criteria. */
        protected SearchUICriterion _wrappedCriterion;
        
        /**
         * Build a search criteria wrapper.
         * @param wrappedCriteria wrapped search criteria.
         * @param enumerator the new enumerator.
         */
        public WrappedSearchUICriterion(SearchUICriterion wrappedCriteria, Enumerator enumerator)
        {
            _wrappedCriterion = wrappedCriteria;
            setEnumerator(enumerator);
        }
        
        @Override
        public Enumerator getEnumerator()
        {
            return super.getEnumerator();
        }
        
        @Override
        public String getId()
        {
            return _wrappedCriterion.getId();
        }
        
        @Override
        public I18nizableText getLabel()
        {
            return _wrappedCriterion.getLabel();
        }
        
        @Override
        public I18nizableText getDescription()
        {
            return _wrappedCriterion.getDescription();
        }
        
        @Override
        public String getFieldId()
        {
            return _wrappedCriterion.getFieldId();
        }
        
        @Override
        public String getInitClassName()
        {
            return _wrappedCriterion.getInitClassName();
        }
        
        @Override
        public String getSubmitClassName()
        {
            return _wrappedCriterion.getSubmitClassName();
        }
        
        @Override
        public String getChangeClassName()
        {
            return _wrappedCriterion.getChangeClassName();
        }
        
        @Override
        public boolean isHidden()
        {
            return _wrappedCriterion.isHidden();
        }
        
        @Override
        public MetadataType getType()
        {
            return _wrappedCriterion.getType();
        }
        
        @Override
        public boolean isMultiple()
        {
            return _wrappedCriterion.isMultiple();
        }
        
        @Override
        public String getWidget()
        {
            return _wrappedCriterion.getWidget();
        }
        
//        @Override
//        public Object getValue()
//        {
//            return _wrappedCriterion.getValue();
//        }
        
        @Override
        public Map<String, I18nizableText> getWidgetParameters()
        {
            return _wrappedCriterion.getWidgetParameters();
        }
        
        @Override
        public Validator getValidator()
        {
            return _wrappedCriterion.getValidator();
        }
        
        @Override
        public Object getDefaultValue()
        {
            return _wrappedCriterion.getDefaultValue();
        }
        
        @Override
        public String getContentTypeId()
        {
            return _wrappedCriterion.getContentTypeId();
        }
        
        @Override
        public Operator getOperator()
        {
            return _wrappedCriterion.getOperator();
        }
        
        @Override
        public Query getQuery(Object value, Operator customOperator, Map<String, Object> allValues, String language, Map<String, Object> contextualParameters)
        {
            return _wrappedCriterion.getQuery(value, customOperator, allValues, language, contextualParameters);
        }
    }
}