/*
 *  Copyright 2016 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.solr.schema;

import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;
import org.apache.solr.client.solrj.response.schema.SchemaRepresentation;

/**
 * Represents the field names of a solr schema, mainly used to track existing fields.
 */
public class SchemaFields
{
    
    /** The simple field names. */
    protected Set<String> _fieldNames;
    
    /** The dynamic field names. */
    protected Set<String> _dynFieldNames;
    
    /** The copy field ids. */
    protected Set<CopyFieldId> _copyFieldIds;
    
    /** The field type names. */
    protected Set<String> _fieldTypeNames;
    
    /**
     * Build a SchemaFields object from a {@link SchemaRepresentation}.
     * @param schemaRepresentation The schema representation.
     */
    public SchemaFields(SchemaRepresentation schemaRepresentation)
    {
        initFields(schemaRepresentation);
    }
    
    /**
     * Get the simple field names.
     * @return The simple field names.
     */
    public Set<String> getFieldNames()
    {
        return Collections.unmodifiableSet(_fieldNames);
    }
    
    /**
     * Test if the schema contains the given simple field.
     * @param name The field name to test.
     * @return true if the schema contains the given simple field.
     */
    public boolean hasField(String name)
    {
        return _fieldNames.contains(name);
    }
    
    /**
     * Add the given field name.
     * @param name the field name to add.
     */
    public void addField(String name)
    {
        _fieldNames.add(name);
    }
    
    /**
     * Get the dynamic field names.
     * @return The dynamic field names.
     */
    public Set<String> getDynamicFieldNames()
    {
        return Collections.unmodifiableSet(_dynFieldNames);
    }
    
    /**
     * Test if the schema contains the given dynamic field.
     * @param name The dynamic field name to test.
     * @return true if the schema contains the given dynamic field.
     */
    public boolean hasDynamicField(String name)
    {
        return _dynFieldNames.contains(name);
    }
    
    /**
     * Add a dynamic field name.
     * @param name the dynamic field name to add.
     */
    public void addDynamicField(String name)
    {
        _dynFieldNames.add(name);
    }
    
    /**
     * Get the copy field ids.
     * @return The copy field ids.
     */
    public Set<CopyFieldId> getCopyFieldIds()
    {
        return Collections.unmodifiableSet(_copyFieldIds);
    }
    
    /**
     * Test if the schema contains the given copy field.
     * @param source The copy field source.
     * @param destination The copy field destination.
     * @return true if the schema contains the given copy field.
     */
    public boolean hasCopyField(String source, String destination)
    {
        return _copyFieldIds.contains(new CopyFieldId(source, destination));
    }
    
    /**
     * Add the given copy field.
     * @param source The copy field source.
     * @param destination The copy field destination.
     */
    public void addCopyField(String source, String destination)
    {
        _copyFieldIds.add(new CopyFieldId(source, destination));
    }
    
    /**
     * Get the field types.
     * @return The field types.
     */
    public Set<String> getFieldTypeNames()
    {
        return Collections.unmodifiableSet(_fieldTypeNames);
    }
    
    /**
     * Test if the schema contains the given field type.
     * @param name The field type name to test.
     * @return true if the schema contains the given field type.
     */
    public boolean hasFieldType(String name)
    {
        return _fieldTypeNames.contains(name);
    }
    
    /**
     * Add the given field type name.
     * @param name the field type name to add.
     */
    public void addFieldType(String name)
    {
        _fieldTypeNames.add(name);
    }
    
    @Override
    public String toString()
    {
        StringBuilder str = new StringBuilder();
        
        str.append("types=[").append(StringUtils.join(_fieldTypeNames, ", ")).append("]\n")
           .append("fields=[").append(StringUtils.join(_fieldNames, ", ")).append("]\n")
           .append("dynamic fields=[").append(StringUtils.join(_dynFieldNames, ", ")).append("]\n")
           .append("copy fields=[").append(StringUtils.join(_copyFieldIds, ", ")).append("]\n");
        
        return str.toString();
    }
    
    /**
     * Initialize the field names from the schema representation.
     * @param schema The schema representation.
     */
    protected void initFields(SchemaRepresentation schema)
    {
        _fieldTypeNames = schema.getFieldTypes().stream().map(type -> (String) type.getAttributes().get("name")).collect(Collectors.toSet());
        _fieldNames = schema.getFields().stream().map(field -> (String) field.get("name")).collect(Collectors.toSet());
        _dynFieldNames = schema.getDynamicFields().stream().map(field -> (String) field.get("name")).collect(Collectors.toSet());
        _copyFieldIds = new HashSet<>();
        for (Map<String, Object> copyField : schema.getCopyFields())
        {
            String source = (String) copyField.get("source");
            String destination = (String) copyField.get("dest");
            _copyFieldIds.add(new CopyFieldId(source, destination));
        }
    }
    
}