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

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.contenttype.ContentAttributeDefinition;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.repository.Content;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.plugins.repository.model.CompositeDefinition;
import org.ametys.plugins.repository.model.ViewHelper;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ModelHelper;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelItemAccessor;
import org.ametys.runtime.model.ModelItemContainer;
import org.ametys.runtime.model.ModelItemGroup;
import org.ametys.runtime.model.ModelViewItem;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemAccessor;

/**
 * Component providing methods to manipulate {@link Column columns} for search models.
 */
public class ColumnHelper implements Component, Serviceable
{
    /** The Avalon role */
    public static final String ROLE = ColumnHelper.class.getName();

    private static final String __VIEW_REFERENCE_REGEX = "\\[(.+)\\]";
    private static final Pattern __VIEW_REFERENCE_PATTERN = Pattern.compile("^[^\\[]+" + __VIEW_REFERENCE_REGEX + "$");
    
    /** The content type extension point */
    protected ContentTypeExtensionPoint _cTypeEP;
    
    /** The content type helper. */
    protected ContentTypesHelper _cTypeHelper;
    
    /** The system property extension point. */
    protected SystemPropertyExtensionPoint _systemPropEP;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _cTypeHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _systemPropEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
    }
    
    /**
     * From a string representing columns, returns the list of column ids with their (optional) labels.
     * @param columnsStr The columns as a string
     * @param contentTypeIds The common content type
     * @return the list of column ids with their (optional) labels.
     */
    public List<Column> getColumns(String columnsStr, Set<String> contentTypeIds)
    {
        return _getColumns(List.of(StringUtils.split(columnsStr, ',')), contentTypeIds);
    }
    /**
     * From a list of string representing columns, returns the list of column ids with their (optional) labels.
     * @param columns The columns
     * @param contentTypeIds The common content type
     * @return the list of column ids with their (optional) labels.
     */
    public List<Column> getColumns(List<String> columns, Set<String> contentTypeIds)
    {
        return _getColumns(columns, contentTypeIds);
    }
    
    private List<Column> _getColumns(List<String> columns, Set<String> contentTypeIds)
    {
        Set<ContentType> contentTypes = contentTypeIds.stream()
                .map(_cTypeEP::getExtension)
                .collect(Collectors.toSet());
        
        ColumnTransformer columnTransformer = new ColumnTransformer(contentTypes, this);
        
        // in StringUtils.split, adjacent separators are treated as one separator, so col cannot be empty
        // but it still can be whitespaces only, just ignore them silently
        return columns.stream()
                      .filter(StringUtils::isNotBlank)
                      .map(this::_leftTrim) // because we do not want a column named " as " to be split then, the "as" should be considered as the column id
                      .map(col -> col.split("(?i) AS ", 2))
                      .map(arr ->
                      {
                          // col is never empty, so arr.length cannot be 0
                          String colId = arr[0].trim().replace('.', '/');
                          if (arr.length == 2)
                          {
                              return new Column(colId, arr[1].trim());
                          }
                          else
                          {
                              return new Column(colId, null);
                          }
                      })
                      .flatMap(columnTransformer::transform)
                      .distinct()
                      .collect(Collectors.toList());
    }
    
    private String _leftTrim(String s)
    {
        return s.replaceAll("^\\s+", "");
    }
    
    boolean isViewReference(String path)
    {
        Matcher matcher = __VIEW_REFERENCE_PATTERN.matcher(path);
        return matcher.matches();
    }
    
    List<String> getViewReferenceColumnPaths(Set<ContentType> commonContentTypes, String attributePath)
    {
        if (commonContentTypes.isEmpty())
        {
            throw new IllegalArgumentException("The given attribute path '" + attributePath + "' is invalid with an empty common content type (the path cannot be followed).");
        }
        
        Matcher matcher = __VIEW_REFERENCE_PATTERN.matcher(attributePath);
        if (!matcher.matches())
        {
            throw new IllegalArgumentException("The given attribute path '" + attributePath + "' does not have the correct syntax.");
        }
        String viewName = matcher.group(1);
        
        // Get the attribute without the view reference
        String path = attributePath.replaceAll(__VIEW_REFERENCE_REGEX, StringUtils.EMPTY);
        if (!ModelHelper.hasModelItem(path, commonContentTypes))
        {
            throw new IllegalArgumentException("The given attribute path '" + path + "' is not defined in content types '" + _getJoinedContentTypeIds(commonContentTypes) + "'.");
        }
        
        ModelItem modelItem = ModelHelper.getModelItem(path, commonContentTypes);
        if (!(modelItem instanceof ContentAttributeDefinition))
        {
            throw new IllegalArgumentException("The given attribute path '" + path + "' type is not content in content types '" + _getJoinedContentTypeIds(commonContentTypes) + "'.");
        }
        
        ContentAttributeDefinition definition = (ContentAttributeDefinition) modelItem;
        String contentTypeId = definition.getContentTypeId();
        if (StringUtils.isEmpty(contentTypeId))
        {
            throw new IllegalArgumentException("The attribute at path '" + path + "' in content types '" + _getJoinedContentTypeIds(commonContentTypes) + "' does not specify any content type.");
        }
        
        ContentType contentType = _cTypeEP.getExtension(contentTypeId);
        View referencedView = contentType.getView(viewName);
        if (referencedView == null)
        {
            throw new IllegalArgumentException("The view '" + viewName + "' does not exist in content type '" + contentTypeId + "'.");
        }
        
        // Build the list of paths from the referenced view
        return _getColumnPathsFromViewItemAccessor(referencedView, path + ModelItem.ITEM_PATH_SEPARATOR);
    }
    
    private List<String> _getColumnPathsFromViewItemAccessor(ViewItemAccessor viewItemAccessor, String prefix)
    {
        List<String> columnPaths = new ArrayList<>();
        
        ViewHelper.visitView(viewItemAccessor, 
            (element, definition) -> {
                // simple element
                String columnPath = prefix + definition.getName();
                
                if (element instanceof ViewItemAccessor accessor && !accessor.getViewItems().isEmpty())
                {
                    String newPrefix = columnPath + ModelItem.ITEM_PATH_SEPARATOR;
                    columnPaths.addAll(_getColumnPathsFromViewItemAccessor(accessor, newPrefix));
                }
                else
                {
                    columnPaths.add(columnPath);
                }
            }, 
            (group, definition) -> {
                // composite
                if (!group.getViewItems().isEmpty())
                {
                    String newPrefix = prefix + definition.getName() + ModelItem.ITEM_PATH_SEPARATOR;
                    columnPaths.addAll(_getColumnPathsFromViewItemAccessor(group, newPrefix));
                }
            }, 
            (group, definition) -> {
                // repeater
                columnPaths.add(prefix + definition.getName());
            }, 
            group -> columnPaths.addAll(_getColumnPathsFromViewItemAccessor(group, prefix)));
        
        return columnPaths;
    }
    
    boolean isWildcardColumn(String path)
    {
        return "*".equals(path) || path.endsWith("/*");
    }
    
    List<String> getWildcardAttributeColumnPaths(Set<ContentType> commonContentTypes, String attributePath) throws IllegalArgumentException
    {
        if (!isWildcardColumn(attributePath))
        {
            throw new IllegalArgumentException("The given attribute path '" + attributePath + "' does not have the correct syntax.");
        }
        
        if (attributePath.endsWith("/*") && commonContentTypes.isEmpty())
        {
            throw new IllegalArgumentException("The given attribute path '" + attributePath + "' is invalid with an empty common content type (the path cannot be followed).");
        }
        
        if (commonContentTypes.isEmpty() /* here we have itemPath == "*" */)
        {
            // If no common ancestor, only title attribute is allowed
            return List.of(Content.ATTRIBUTE_TITLE);
        }
        
        if ("*".equals(attributePath))
        {
            return _fieldNamesFromContentTypes(commonContentTypes);
        }
        else
        {
            return _getFieldsForPath(attributePath, commonContentTypes);
        }
    }
    
    private List<String> _getFieldsForPath(String attributePath, Set<ContentType> commonContentTypes)
    {
        String parentPath = StringUtils.substringBeforeLast(attributePath, "/*");
        ModelItem lastModelItem = ModelHelper.getModelItem(parentPath, commonContentTypes);
        
        if (lastModelItem instanceof ContentAttributeDefinition contentAttributeDefinition)
        {
            return _getFieldsForContentAttribute(contentAttributeDefinition, parentPath);
        }
        else if (lastModelItem instanceof ModelItemGroup modelItemGroup)
        {
            return _fieldNamesFromModelItemContainer(modelItemGroup, parentPath + "/");
        }
        else
        {
            throw new IllegalArgumentException("Invalid column definition '" + attributePath + "' in content types '" + _getJoinedContentTypeIds(commonContentTypes) + "'");
        }
    }
    
    private List<String> _getFieldsForContentAttribute(ContentAttributeDefinition contentAttributeDefinition, String parentPath)
    {
        return Optional.of(contentAttributeDefinition)
              .map(ContentAttributeDefinition::getContentTypeId)
              .filter(_cTypeEP::hasExtension)
              .map(_cTypeEP::getExtension)
              .map(contentType -> _fieldNamesFromModelItemContainer(contentType, parentPath + ModelItem.ITEM_PATH_SEPARATOR))
              .orElse(List.of(parentPath + "/" + Content.ATTRIBUTE_TITLE));
    }
    
    private List<String> _fieldNamesFromContentTypes(Collection<ContentType> contentTypes)
    {
        List<String> filedNames = new ArrayList<>();
        
        for (ContentType contentType : contentTypes)
        {
            List<String> fieldNamesFromContentType = _fieldNamesFromModelItemContainer(contentType, StringUtils.EMPTY);
            filedNames.addAll(fieldNamesFromContentType);
        }
        
        return filedNames;
    }
    
    private List<String> _fieldNamesFromModelItemContainer(ModelItemContainer modelItemContainer, String prefix)
    {
        List<String> fieldNames = new ArrayList<>();
        
        for (ModelItem modelItem : modelItemContainer.getModelItems())
        {
            String fieldName = prefix + modelItem.getName();
            if (modelItem instanceof CompositeDefinition compositeDefinition)
            {
                fieldNames.addAll(_fieldNamesFromModelItemContainer(compositeDefinition, fieldName + ModelItem.ITEM_PATH_SEPARATOR));
            }
            else
            {
                fieldNames.add(fieldName);
            }
        }
        
        return fieldNames;
    }
    
    List<String> getWildcardSystemColumnPaths(Set<ContentType> commonContentTypes, String path, boolean allowComposite)
    {
        if (!isWildcardColumn(path))
        {
            throw new IllegalArgumentException("The given path '" + path + "' does not have the correct syntax.");
        }
        
        if ("*".equals(path))
        {
            return _systemPropEP.getDisplayProperties();
        }
        else if (commonContentTypes.isEmpty())
        {
            throw new IllegalArgumentException("The given path '" + path + "' is invalid with an empty common content type (the path cannot be followed).");
        }
        else
        {
            String parentPath = StringUtils.substringBeforeLast(path, "/*");
            
            if (!ModelHelper.hasModelItem(parentPath, commonContentTypes))
            {
                throw new IllegalArgumentException("Invalid column definition '" + path + "' in content types '" + _getJoinedContentTypeIds(commonContentTypes) + "'");
            }
            
            ModelItem lastModelItem = ModelHelper.getModelItem(parentPath, commonContentTypes);
            if (lastModelItem instanceof ContentAttributeDefinition)
            {
                String basePath = parentPath + "/";
                return _systemPropEP.getDisplayProperties()
                        .stream()
                        .map(prop -> basePath + prop)
                        .collect(Collectors.toList());
            }
            else if (lastModelItem instanceof ModelItemGroup && allowComposite)
            {
                return List.of();
            }
            else
            {
                throw new IllegalArgumentException("Invalid column definition '" + path + "' in content types '" + _getJoinedContentTypeIds(commonContentTypes) + "'");
            }
        }
    }

    private String _getJoinedContentTypeIds(Set<ContentType> contentTypes)
    {
        Set<String> commonContentTypeIds = contentTypes.stream()
                .map(ContentType::getId)
                .collect(Collectors.toSet());
        return StringUtils.join(commonContentTypeIds, ", ");
    }
    
    /**
     * Creates a {@link View} from the given columns
     * @param contentTypeIds the reference content type identifiers.
     * @param columns the columns
     * @param mergeContainers set to <code>true</code> to avoid to create new containers when they are already present in the given view item accessor
     * @return the created view
     */
    public View createViewFromColumns(Set<String> contentTypeIds, Collection<Column> columns, boolean mergeContainers)
    {
        View resultItems = new View();
        for (Column column : columns)
        {
            String columnId = column.getId();
            
            Collection<ContentType> contentTypes = contentTypeIds.stream()
                                                                         .map(_cTypeEP::getExtension)
                                                                         .toList();
            
            String[] pathSegments = StringUtils.split(columnId, ModelItem.ITEM_PATH_SEPARATOR);
            
            ViewItemAccessor parent = resultItems;
            Collection<? extends ModelItemAccessor> realtiveModelItemAccessors = contentTypes;
            if (pathSegments.length > 1)
            {
                // Create or get parent
                String parentPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 0, pathSegments.length - 1);
                ModelViewItem parentViewItem = org.ametys.runtime.model.ViewHelper.addViewItem(parentPath, resultItems, false, mergeContainers, contentTypes.toArray(new ContentType[contentTypes.size()]));
                
                if (parentViewItem instanceof ViewItemAccessor parentViewItemAccessor)
                {
                    parent = parentViewItemAccessor;
                    realtiveModelItemAccessors = List.of((ModelItemAccessor) parentViewItem.getDefinition());
                }
                else
                {
                    throw new IllegalArgumentException("Unable to create a column with id '" + columnId + "'. The item at path '" + parentPath + "' is not an accessor.");
                }
            }
            
            ViewItem viewItem = _createViewItem(pathSegments[pathSegments.length - 1], column.getLabel(), realtiveModelItemAccessors);
            parent.addViewItem(viewItem);
        }
        return resultItems;
    }
    
    /**
     * Creates the {@link ViewItem} with the given name. Retrieves the created view item
     * @param viewItemName the view item name
     * @param columnLabel the label of the column, to put to the view item
     * @param modelItemAccessors the accessors containing the model item with the given name
     * @return the created view item
     */
    private ViewItem _createViewItem(String viewItemName, Optional<String> columnLabel, Collection<? extends ModelItemAccessor> modelItemAccessors)
    {
        ModelItem modelItem = ModelHelper.hasModelItem(viewItemName, modelItemAccessors)
                ? ModelHelper.getModelItem(viewItemName, modelItemAccessors)
                : Content.ATTRIBUTE_TITLE.equals(viewItemName)
                    ? _cTypeHelper.getTitleAttributeDefinition()
                    : _systemPropEP.hasExtension(viewItemName)
                            ? _systemPropEP.getExtension(viewItemName)
                            : null;
        
        if (modelItem == null)
        {
            throw new IllegalArgumentException("Unable to create a column with name '" + viewItemName + "'. There is no corresponding model item in model.");
        }
        
        // The viewItem is the leaf, create an UI column and add label if needed
        ModelViewItem viewItem = SearchUIColumnHelper.createModelItemColumn(modelItem);
        columnLabel.map(I18nizableText::new)
                   .ifPresent(viewItem::setLabel);
        
        return viewItem;
    }
    
    static final class ColumnTransformer
    {
        private Set<ContentType> _contentTypeIds;
        private ColumnHelper _columnHelper;

        ColumnTransformer(Set<ContentType> contentTypeIds, ColumnHelper columnHelper)
        {
            _contentTypeIds = contentTypeIds;
            _columnHelper = columnHelper;
        }
        
        Stream<Column> transform(Column column)
        {
            String colId = column.getId();
            if (_columnHelper.isWildcardColumn(colId))
            {
                return Stream.concat(_attributeCols(colId), _systemCols(colId));
            }
            else if (_columnHelper.isViewReference(colId))
            {
                return _viewRefs(colId);
            }
            else
            {
                return Stream.of(column);
            }
        }
        
        private Stream<Column> _attributeCols(String colPath)
        {
            return _columnHelper.getWildcardAttributeColumnPaths(_contentTypeIds, colPath)
                    .stream()
                    .map(colId -> new Column(colId, null));
        }
        
        private Stream<Column> _systemCols(String colPath)
        {
            return _columnHelper.getWildcardSystemColumnPaths(_contentTypeIds, colPath, true)
                    .stream()
                    .map(colId -> new Column(colId, null));
        }
        
        private Stream<Column> _viewRefs(String colPath)
        {
            return _columnHelper.getViewReferenceColumnPaths(_contentTypeIds, colPath)
                    .stream()
                    .map(colId -> new Column(colId, null));
        }
    }
    
    /**
     * A column and its (optional) label
     */
    public static final class Column
    {
        private String _id;
        private Optional<String> _label;

        /**
         * Creates a {@link Column} object, wrapping a column id and its (optional) label.
         * <br>If the provided label is <code>null</code>, then a default label will be applied to the column.
         * @param columnId The id of the column
         * @param columnLabel The label of the column. Cannot contain the comma character (<b>,</b>). Can be null
         */
        public Column(String columnId, String columnLabel)
        {
            _id = columnId;
            _label = Optional.ofNullable(columnLabel);
            if (_label.filter(l -> l.contains(",")).isPresent())
            {
                throw new IllegalArgumentException("The label cannot contain a comma.");
            }
        }
        
        /**
        * Gets the id of the column
        * @return the id of the column
        */
        public String getId()
        {
            return _id;
        }
        
        /**
        * Gets the label of the column
        * @return the label of the column 
        */
        public Optional<String> getLabel()
        {
            return _label;
        }
        
        @Override
        public String toString()
        {
            return "Column<" + _id + ", \"" + _label.orElse("<NO LABEL>") + "\">";
        }

        @Override
        public int hashCode()
        {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((_id == null) ? 0 : _id.hashCode());
            return result;
        }

        // only based on the column id
        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (obj == null)
            {
                return false;
            }
            if (getClass() != obj.getClass())
            {
                return false;
            }
            Column other = (Column) obj;
            if (_id == null)
            {
                if (other._id != null)
                {
                    return false;
                }
            }
            else if (!_id.equals(other._id))
            {
                return false;
            }
            return true;
        }
    }
}