/*
 *  Copyright 2025 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.systemprop;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.solr.common.SolrInputDocument;

import org.ametys.cms.data.ametysobject.IndexableAmetysObject;
import org.ametys.cms.data.type.indexing.IndexableElementType;
import org.ametys.cms.model.CMSDataContext;
import org.ametys.cms.model.properties.AbstractIndexableStaticProperty;
import org.ametys.cms.search.solr.schema.CopyFieldDefinition;
import org.ametys.cms.search.solr.schema.FieldDefinition;
import org.ametys.cms.search.solr.schema.SchemaDefinition;

/**
 * Abstract class for single indexation aware system property
 * @param <T> type of the property values
 * @param <C> type of criterion
 * @param <X> type of ametys object supported by this property
 */
public abstract class AbstractIndexableSystemProperty<T, C, X extends IndexableAmetysObject> extends AbstractIndexableStaticProperty<T, C, X> implements IndexationAwareSystemProperty<T, X>
{
    @Override
    protected String _getNameConfigurationAttribute()
    {
        return "id";
    }
    
    @Override
    public void indexValue(SolrInputDocument document, X ametysObject, CMSDataContext context)
    {
        String solrFieldName = getSolrFieldName();
        if (solrFieldName == null)
        {
            // Nothing to index
            return;
        }
        
        String solrSortFieldName = getSolrSortFieldName();
        boolean indexSortableField = isSortable() && solrSortFieldName != null && !solrFieldName.equals(solrSortFieldName);
        
        IndexableElementType<T> type = getType();
        Object value = getValue(ametysObject);
        
        if (value == null
                || type.getManagedClassArray().isInstance(value) && type.getManagedClassArray().cast(value).length == 0)
        {
            // Add empty value in document in order to remove the value during partial indexing
            document.addField(solrFieldName, null);
            
            if (indexSortableField)
            {
                document.addField(solrSortFieldName, null);
            }
        }
        else
        {
            if (type.getManagedClass().isInstance(value))
            {
                Object valueToIndex = type.getSingleValueToIndex(type.getManagedClass().cast(value));
                document.addField(solrFieldName, valueToIndex);
            }
            else if (type.getManagedClassArray().isInstance(value))
            {
                T[] values = type.getManagedClassArray().cast(value);
                for (T singleValue : values)
                {
                    Object valueToIndex = type.getSingleValueToIndex(singleValue);
                    document.addField(solrFieldName, valueToIndex);
                }
            }
            
            // Index sort field
            Object sortValue = getSortValue(ametysObject);
            if (indexSortableField && sortValue != null)
            {
                document.setField(solrSortFieldName, sortValue);
            }
        }
    }
    
    /**
     * Get the sort value represented by this field in the given result ametys object.
     * @param ametysObject the result ametys object.
     * @return the content sort value, must be scalar (String, long, double, Date).
     */
    protected Object getSortValue(X ametysObject)
    {
        Object value = getValue(ametysObject);
        if (value == null)
        {
            return null;
        }
        
        IndexableElementType<T> type = getType();
        if (type.getManagedClassArray().isInstance(value))
        {
            T[] values = type.getManagedClassArray().cast(value);
            return values.length > 0 ? values[0] : value;
        }
        else
        {
            return value;
        }
    }
    
    public Collection<SchemaDefinition> getSchemaDefinitions()
    {
        List<SchemaDefinition> definitions = new ArrayList<>();

        String solrFieldName = getSolrFieldName();
        String sortFieldName = getSolrSortFieldName();
        String facetFieldName = getSolrFacetFieldName();
        
        boolean multiple = isMultiple();
        String type = getType().getSchemaType();
        if (solrFieldName != null && type != null)
        {
            definitions.add(new FieldDefinition(solrFieldName, type, multiple, false));

            if (sortFieldName != null && !sortFieldName.equals(solrFieldName))
            {
                definitions.add(new FieldDefinition(sortFieldName, type, false, false));
            }

            if (facetFieldName != null && !facetFieldName.equals(solrFieldName))
            {
                // By default the index value in field name will be automatically copy in facet field
                // So we do not need the index facet field manually
                definitions.add(new FieldDefinition(facetFieldName, type, multiple, true));
                definitions.add(new CopyFieldDefinition(solrFieldName, facetFieldName));
            }
        }

        return definitions;
    }
    
    /**
     * Get the value as a array of String
     * @param value The value as an object to parse
     * @return The values as a String array
     */
    protected String[] parseStringArray(Object value)
    {
        return value instanceof String
                ? new String[] {(String) value}
                : (String[]) value;
    }
}