/*
 *  Copyright 2019 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.frontoffice.search.metamodel.impl;

import java.util.Collection;
import java.util.Map;
import java.util.stream.Stream;

import org.apache.avalon.framework.service.ServiceException;

import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.data.ContentValue;
import org.ametys.cms.data.type.ModelItemTypeConstants;
import org.ametys.cms.model.ContentElementDefinition;
import org.ametys.cms.repository.ContentTypeExpression;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.OrExpression;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.Enumerator;
import org.ametys.runtime.model.ModelItem;
import org.ametys.web.frontoffice.search.metamodel.RestrictedEnumerator;

/**
 * {@link ReferencingSearchServiceCriterionDefinition} for a {@link ModelItemTypeConstants#CONTENT_ELEMENT_TYPE_ID} attribute.
 */
public class ContentReferencingSearchServiceCriterionDefinition extends ReferencingSearchServiceCriterionDefinition<ContentValue> implements ContentElementDefinition
{
    /** The resolver */
    protected AmetysObjectResolver _resolver;
    /** The content helper */
    protected ContentHelper _contentHelper;
    
    /**
     * Constructor used to create a FO criterion definition on a referenced item of type content
     * @param reference the item referenced by this criterion
     * @param referencePath the path of the criterion's reference
     * @param baseContentType the content type defining the reference
     */
    public ContentReferencingSearchServiceCriterionDefinition(ElementDefinition reference, String referencePath, ContentType baseContentType)
    {
        super(reference, referencePath, baseContentType);
    }
    
    @Override
    public boolean isEnumerated()
    {
        return true;
    }
    
    @Override
    public RestrictedEnumerator<ContentValue> getRestrictedEnumerator(Map<String, Object> contextualParameters)
    {
        Enumerator<ContentValue> enumerator = new ContentEnumerator(this, _getContentTypeExtensionPoint(), contextualParameters);
        return new RestrictedWrappedEnumerator<>(enumerator, getName());
    }
    
    /**
     * Gets the content type expression for retrieving enumeration of contents
     * @param parentCTypeId The parent content type id
     * @return The {@link Expression}
     */
    protected Expression getContentTypeExpression(String parentCTypeId)
    {
        Stream<String> subCTypesIds = _getContentTypeExtensionPoint().getSubTypes(parentCTypeId).stream();
        Expression[] exprs = Stream.concat(Stream.of(parentCTypeId), subCTypesIds)
                .map(cTypeId -> new ContentTypeExpression(Operator.EQ, cTypeId))
                .toArray(Expression[]::new);
        return new OrExpression(exprs);
    }
    

    /**
     * Get the order of the content id value for a search criterion definition referencing a model item of type content
     * @param contentValue the content value
     * @return the order or null if there is no order
     */
    public Long getOrder(ContentValue contentValue)
    {
        return contentValue.getContentIfExists()
                           .filter(_getContentHelper()::isReferenceTable)
                           .filter(content -> content.hasDefinition("order"))
                           .filter(content -> content.hasValue("order"))
                           .map(content -> content.<Long>getValue("order"))
                           .orElse(null);
    }
    
    @Override
    public ContentElementDefinition getReference()
    {
        return (ContentElementDefinition) super.getReference();
    }
    
    public String getContentTypeId()
    {
        return getReference().getContentTypeId();
    }
    
    public void setContentTypeId(String contentTypeId)
    {
        throw new UnsupportedOperationException("The criterion definition '" + getName() + "' references a criterion of type content. The content type id can not be set to the criterion definition.");
    }
    
    public Collection< ? extends ModelItem> getModelItems()
    {
        return getReference().getModelItems();
    }
    
    /**
     * Retrieves the {@link AmetysObjectResolver} 
     * @return the {@link AmetysObjectResolver}
     */
    protected AmetysObjectResolver _getAmetysObjectResolver()
    {
        if (_resolver == null)
        {
            try
            {
                _resolver = (AmetysObjectResolver) __serviceManager.lookup(AmetysObjectResolver.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException("Unable to lookup after the ametys object resolver", e);
            }
        }
        
        return _resolver;
    }
    
    /**
     * Retrieves the {@link ContentHelper} 
     * @return the {@link ContentHelper}
     */
    protected ContentHelper _getContentHelper()
    {
        if (_contentHelper == null)
        {
            try
            {
                _contentHelper = (ContentHelper) __serviceManager.lookup(ContentHelper.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException("Unable to lookup after the content helper", e);
            }
        }
        
        return _contentHelper;
    }
}