/*
 *  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.Collections;
import java.util.List;
import java.util.Optional;
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.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.contenttype.RepeaterDefinition;
import org.ametys.cms.contenttype.indexing.IndexingField;
import org.ametys.cms.contenttype.indexing.IndexingModel;
import org.ametys.cms.contenttype.indexing.MetadataIndexingField;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;

/**
 * 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();
    
    /** 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 contentType The common content type
     * @return the list of column ids with their (optional) labels.
     */
    public List<Column> getColumns(String columnsStr, Optional<String> contentType)
    {
        return _getColumns(Stream.of(StringUtils.split(columnsStr, ',')), contentType);
    }
    /**
     * From a list of string representing columns, returns the list of column ids with their (optional) labels.
     * @param columns The columns
     * @param contentType The common content type
     * @return the list of column ids with their (optional) labels.
     */
    public List<Column> getColumns(List<String> columns, Optional<String> contentType)
    {
        return _getColumns(columns.stream(), contentType);
    }
    
    private List<Column> _getColumns(Stream<String> columns, Optional<String> contentTypeId)
    {
        Optional<ContentType> contentType = contentTypeId
                .map(_cTypeEP::getExtension);
        
        ColumnTransformer columnTransformer = new ColumnTransformer(contentType, 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.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 isWildcardColumn(String path)
    {
        return "*".equals(path) || path.endsWith("/*");
    }
    
    List<String> getWildcardMetadataColumnPaths(Optional<ContentType> optCommonContentType, String metadataPath) throws IllegalArgumentException
    {
        if (!isWildcardColumn(metadataPath))
        {
            throw new IllegalArgumentException("The given metadataPath '" + metadataPath + "' does not have the correct syntax.");
        }
        
        if (metadataPath.endsWith("/*") && !optCommonContentType.isPresent())
        {
            throw new IllegalArgumentException("The given metadataPath '" + metadataPath + "' is invalid with an empty common content type (the path cannot be followed).");
        }
        
        if (!optCommonContentType.isPresent() /* here we have metadataPath == "*" */)
        {
            // If no common ancestor, only title metadata is allowed
            return Collections.singletonList("title");
        }
        ContentType commonContentType = optCommonContentType.get();
        
        return "*".equals(metadataPath)
                ? _fieldNamesFromModel(commonContentType.getIndexingModel(), "")
                : _getFieldsForPath(metadataPath, commonContentType);
    }
    
    private MetadataDefinition _getLastMetadataDefinition(String parentPath, ContentType commonContentType)
    {
        List<MetadataDefinition> pathDefinitions = _cTypeHelper.getMetadataDefinitionPath(parentPath, commonContentType);
        MetadataDefinition lastMetadataDef = pathDefinitions.isEmpty() ? null : pathDefinitions.get(pathDefinitions.size() - 1);
        return lastMetadataDef;
    }
    
    private List<String> _getFieldsForPath(String metadataPath, ContentType commonContentType)
    {
        String parentPath = StringUtils.substringBeforeLast(metadataPath, "/*");
        MetadataDefinition lastMetadataDef = _getLastMetadataDefinition(parentPath, commonContentType);
        
        if (lastMetadataDef == null)
        {
            throw new IllegalArgumentException("Invalid column definition '" + metadataPath + "' in content type '" + commonContentType.getId() + "'");
        }
        else if (lastMetadataDef.getType() == MetadataType.CONTENT)
        {
            return _getFieldsForContentMetadata(lastMetadataDef, parentPath);
        }
        else if (lastMetadataDef.getType() == MetadataType.COMPOSITE)
        {
            return _getFieldsForCompositeMetadata(lastMetadataDef, parentPath);
        }
        else
        {
            throw new IllegalArgumentException("Invalid column definition '" + metadataPath + "' in content type '" + commonContentType.getId() + "'");
        }
    }
    
    private List<String> _getFieldsForContentMetadata(MetadataDefinition lastMetadataDef, String parentPath)
    {
        Optional<ContentType> optCType = Optional.of(lastMetadataDef)
              .map(MetadataDefinition::getContentType)
              .map(_cTypeEP::getExtension);
        if (!optCType.isPresent())
        {
            return Collections.singletonList(parentPath + "/title");
        }
        else
        {
            ContentType contentMetadataContentType = optCType.get();
            IndexingModel indexingModel = contentMetadataContentType.getIndexingModel();
            return _fieldNamesFromModel(indexingModel, parentPath + "/");
        }
    }
    
    private List<String> _getFieldsForCompositeMetadata(MetadataDefinition lastMetadataDef, String parentPath)
    {
        final String prefix = parentPath + "/";
        return lastMetadataDef.getMetadataNames()
                .stream()
                .map(lastMetadataDef::getMetadataDefinition)
                .filter(this::_filterComposite)
                .map(MetadataDefinition::getName)
                .map(prefix::concat)
                .collect(Collectors.toList());
    }
    
    private List<String> _fieldNamesFromModel(IndexingModel indexingModel, String prefix)
    {
        return indexingModel.getFields()
                .stream()
                // Get only first-level metadata (ignore composites)
                .filter(this::_filterComposite)
                // Only metadata fields are displayable
                .filter(MetadataIndexingField.class::isInstance)
                .map(IndexingField::getName)
                .map(prefix::concat)
                .collect(Collectors.toList());
    }
    
    private boolean _filterComposite(IndexingField field)
    {
        if (field instanceof MetadataIndexingField)
        {
            MetadataDefinition metaDef = ((MetadataIndexingField) field).getMetadataDefinition();
            return _filterComposite(metaDef);
        }
        return true;
    }
    
    private boolean _filterComposite(MetadataDefinition metaDef)
    {
        return metaDef != null && (metaDef.getType() != MetadataType.COMPOSITE || metaDef instanceof RepeaterDefinition);
    }
    
    List<String> getWildcardSystemColumnPaths(Optional<ContentType> optCommonContentType, 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 (!optCommonContentType.isPresent())
        {
            throw new IllegalArgumentException("The given path '" + path + "' is invalid with an empty common content type (the path cannot be followed).");
        }
        else
        {
            ContentType commonContentType = optCommonContentType.get();
            String parentPath = StringUtils.substringBeforeLast(path, "/*");
            MetadataDefinition lastMetadataDef = _getLastMetadataDefinition(parentPath, commonContentType);
            if (lastMetadataDef == null)
            {
                throw new IllegalArgumentException("Invalid column definition '" + path + "' in content type '" + commonContentType.getId() + "'");
            }
            else if (lastMetadataDef.getType() == MetadataType.CONTENT)
            {
                String basePath = parentPath + "/";
                return _systemPropEP.getDisplayProperties()
                        .stream()
                        .map(prop -> basePath + prop)
                        .collect(Collectors.toList());
            }
            else if (lastMetadataDef.getType() == MetadataType.COMPOSITE && allowComposite)
            {
                return Collections.emptyList();
            }
            else
            {
                throw new IllegalArgumentException("Invalid column definition '" + path + "' in content type '" + commonContentType.getId() + "'");
            }
        }
    }
    
    static final class ColumnTransformer
    {
        private Optional<ContentType> _contentType;
        private ColumnHelper _columnHelper;

        ColumnTransformer(Optional<ContentType> contentType, ColumnHelper columnHelper)
        {
            _contentType = contentType;
            _columnHelper = columnHelper;
        }
        
        Stream<Column> transform(Column column)
        {
            String colId = column.getId();
            if (_columnHelper.isWildcardColumn(colId))
            {
                return Stream.concat(_metadataCols(colId), _systemCols(colId));
            }
            else
            {
                return Stream.of(column);
            }
        }
        
        private Stream<Column> _metadataCols(String colPath)
        {
            return _columnHelper.getWildcardMetadataColumnPaths(_contentType, colPath)
                    .stream()
                    .map(colId -> new Column(colId, null));
        }
        
        private Stream<Column> _systemCols(String colPath)
        {
            return _columnHelper.getWildcardSystemColumnPaths(_contentType, colPath, true)
                    .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;
        }
    }
}