/*
 *  Copyright 2023 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.runtime.model;

import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.commons.lang3.StringUtils;

import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ItemParserHelper.ConfigurationAndPluginName;
import org.ametys.runtime.model.ModelViewItem.DisabledItemRendering;
import org.ametys.runtime.model.ViewHelper.InsertMode;
import org.ametys.runtime.model.exception.UndefinedItemPathException;

/**
 * Abstract component that parses view's configuration
 */
public abstract class AbstractViewParser extends AbstractLogEnabled implements ViewParser
{
    /** The regex to remove view references in model item references */
    protected static final String __VIEW_REFERENCE_REGEX = "\\[(.+)\\]";
    /** The pattern to find view references in model item references */
    protected static final Pattern __VIEW_REFERENCE_PATTERN = Pattern.compile("^[^\\[]+" + __VIEW_REFERENCE_REGEX + "$");
    
    public View parseView(ConfigurationAndPluginName viewConfiguration, ViewParserContext context) throws ConfigurationException
    {
        View view = new View();
        view.setName(_parseViewName(viewConfiguration));
        
        // Get the model
        Collection<? extends Model> model = _getModel();
        
        // Parse general information of the view Configuration
        _fillViewGeneralInformation(viewConfiguration, view, view, model);
        
        // Parse the view items of the view Configuration
        for (Configuration itemConfiguration : viewConfiguration.configuration().getChildren())
        {
            _parseViewChild(new ConfigurationAndPluginName(itemConfiguration, viewConfiguration.pluginName(), viewConfiguration.defaultI18nCatalog()), view, model, false, context);
        }

        return view;
    }
    
    /**
     * Parses the name of the view
     * @param viewConfiguration the view's configuration 
     * @return the view's name
     * @throws ConfigurationException if an error occurs while parsing the view's name
     */
    protected String _parseViewName(ConfigurationAndPluginName viewConfiguration) throws ConfigurationException
    {
        return viewConfiguration.configuration().getAttribute("name");
    }
    
    public View overrideView(ConfigurationAndPluginName viewConfiguration, View existingView, ViewParserContext context) throws ConfigurationException
    {
        View view = new View();
        view.setName(existingView.getName());
        
        // Get the model
        Collection<? extends Model> model = _getModel();
        
        // Parse general information of the view Configuration
        _fillViewGeneralInformation(viewConfiguration, view, existingView, model);
        
        // Parse the view items of the view Configuration
        view.addViewItems(existingView.getViewItems());
        for (Configuration itemConfiguration : viewConfiguration.configuration().getChildren())
        {
            _parseViewChild(new ConfigurationAndPluginName(itemConfiguration, viewConfiguration.pluginName(), viewConfiguration.defaultI18nCatalog()), view, model, true, context);
        }

        return view;
    }
    
    /**
     * Retrieves the model corresponding to the view to parse
     * @return the model
     */
    protected abstract Collection<? extends Model> _getModel();
    
    /**
     * Fill the general information of the given view (label, description, ...)
     * @param viewConfiguration the configuration of the view to fill
     * @param view the view to fill
     * @param existingView the existing view, that may already contain general information
     * @param model The model of the view
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected void _fillViewGeneralInformation(ConfigurationAndPluginName viewConfiguration, View view, View existingView, Collection<? extends Model> model) throws ConfigurationException
    {
        // Internal
        view.setInternal(viewConfiguration.configuration().getAttributeAsBoolean("internal", existingView.isInternal()));
        
        // Label
        I18nizableText label = existingView.getLabel() == null
                ? ItemParserHelper.parseI18nizableText(viewConfiguration, "label", existingView.getName())
                : ItemParserHelper.parseI18nizableText(viewConfiguration, "label", existingView.getLabel());  // Case of override, use the existing view as default value
        view.setLabel(label);
        
        // Description
        I18nizableText description = existingView.getDescription() == null
                ? ItemParserHelper.parseI18nizableText(viewConfiguration, "description") // default value is an empty string
                : ItemParserHelper.parseI18nizableText(viewConfiguration, "description", existingView.getDescription());  // Case of override, use the existing view as default value
        view.setDescription(description);
    }
    
    /**
     * Parses the item with the given configuration and add the item to the given view
     * @param itemConfiguration the configuration of the item to parse
     * @param view the view
     * @param model The model containing the parsed item
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected void _parseViewChild(ConfigurationAndPluginName itemConfiguration, View view, Collection<? extends Model> model, boolean override, ViewParserContext context) throws ConfigurationException
    {
        if (_isAddingItemConfiguration(itemConfiguration.configuration()))
        {
            _parseModelViewItem(itemConfiguration, view, model, view, override, context);
        }
        else if (_isRemovingItemConfiguration(itemConfiguration.configuration()))
        {
            _removeViewItemFromView(view, itemConfiguration.configuration());
        }
        else if (_isAddingGroupConfiguration(itemConfiguration.configuration()))
        {
            _parseSimpleViewItemGroup(itemConfiguration, ViewItemGroup.TAB_ROLE, view, model, view, override, context);
        }
    }
    
    /**
     * Checks if the given item configuration is an adding item configuration
     * @param itemConfiguration the item configuration
     * @return <code>true</code> if the given item configuration is an adding item configuration, <code>false</code> otherwise
     */
    protected boolean _isAddingItemConfiguration(Configuration itemConfiguration)
    {
        String itemConfigurationName = itemConfiguration.getName();
        return ADD_ITEM_TAG_NAME.equals(itemConfigurationName);
    }
    
    /**
     * Checks if the given item configuration is a removing item configuration
     * @param itemConfiguration the item configuration
     * @return <code>true</code> if the given item configuration is a removing item configuration, <code>false</code> otherwise
     */
    protected boolean _isRemovingItemConfiguration(Configuration itemConfiguration)
    {
        String itemConfigurationName = itemConfiguration.getName();
        return REMOVE_ITEM_TAG_NAME.equals(itemConfigurationName);
    }
    
    /**
     * Checks if the given item configuration is an adding group configuration
     * @param itemConfiguration the item configuration
     * @return <code>true</code> if the given item configuration is an adding group configuration, <code>false</code> otherwise
     */
    protected boolean _isAddingGroupConfiguration(Configuration itemConfiguration)
    {
        String itemConfigurationName = itemConfiguration.getName();
        return ADD_GROUP_TAG_NAME.equals(itemConfigurationName);
    }
    
    /**
     * Parses a model view item and add it to its parent view item accessor
     * @param itemConfiguration configuration of the model view item
     * @param parentViewItemAccessor the parent view item accessor of the model view item to parse
     * @param parentModelItemAccessors the parents model item accessors of the model item corresponding to the model view item to parse
     * @param referenceView view that references the item
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected void _parseModelViewItem(ConfigurationAndPluginName itemConfiguration, ViewItemAccessor parentViewItemAccessor, Collection<? extends ModelItemAccessor> parentModelItemAccessors, View referenceView, boolean override, ViewParserContext context) throws ConfigurationException
    {
        String modelItemReference = _getModelItemReference(itemConfiguration.configuration());
        
        Matcher viewReferenceMatcher = __VIEW_REFERENCE_PATTERN.matcher(modelItemReference);
        boolean hasViewReference = viewReferenceMatcher.matches();
        
        String modelItemPath = hasViewReference ? modelItemReference.replaceAll(__VIEW_REFERENCE_REGEX, StringUtils.EMPTY) : modelItemReference; // Remove potential view reference
        
        int lastIndexOfItemPathSeparator = !hasViewReference
                // Resolve model item reference and initialize parents if the reference is a path
                ? modelItemPath.lastIndexOf(ModelItem.ITEM_PATH_SEPARATOR)
                // For view references, the model item is created as a parent view item accessor
                : modelItemPath.length();
        
        
        ViewItemAccessor finalParentViewItemAccessor = parentViewItemAccessor;
        Collection<? extends ModelItemAccessor> finalParentModelItemAccessors = parentModelItemAccessors;
        
        String modelItemName = modelItemPath;
        
        if (lastIndexOfItemPathSeparator > -1)
        {
            // Get or create the view item accessors associated to the model item path prefix
            String parentRelativePath = modelItemPath.substring(0, lastIndexOfItemPathSeparator);
            finalParentViewItemAccessor = _createViewItemAccessor(itemConfiguration.configuration(), parentRelativePath, parentViewItemAccessor, parentModelItemAccessors, referenceView, override);
            finalParentModelItemAccessors = List.of((ModelItemAccessor) ((ModelViewItem) finalParentViewItemAccessor).getDefinition());

            modelItemName = !hasViewReference ? modelItemPath.substring(lastIndexOfItemPathSeparator + ModelItem.ITEM_PATH_SEPARATOR.length()) : StringUtils.EMPTY;
        }
        
        if (hasViewReference)
        {
            String viewName = viewReferenceMatcher.group(1);
            _parseViewReference(viewName, finalParentViewItemAccessor, finalParentModelItemAccessors.iterator().next());
        }
        else if (ALL_ITEMS_REFERENCE.equals(modelItemName))
        {
            parseAllModelViewItems(itemConfiguration, finalParentViewItemAccessor, finalParentModelItemAccessors, referenceView, override, context);
        }
        else
        {
            // Get the model item
            ModelItem modelItem  = _getModelItem(itemConfiguration, modelItemName, finalParentModelItemAccessors);
            
            // Create the view item corresponding to the model item
            ModelViewItem viewItem = createModelViewItem(itemConfiguration, modelItem, referenceView, override, context);
    
            // Add the view item to its parent
            _addItemToViewItemAccessor(finalParentViewItemAccessor, viewItem, itemConfiguration.configuration(), referenceView, override);
        }
    }
    
    /**
     * Parses the view reference to add items of the view to the given item accessor
     * @param viewName the name of the referenced view
     * @param viewItemAccessor the view item accessor referencing the view
     * @param definition the definition of the model item containing the referenced view
     * @throws ConfigurationException if the configuration is not valid
     */
    protected abstract void _parseViewReference(String viewName, ViewItemAccessor viewItemAccessor, ModelItemAccessor definition) throws ConfigurationException;

    /**
     * Parses all the model view items of the given parents
     * @param itemConfiguration the item configuration
     * @param parentViewItemAccessor the parent view item accessor
     * @param parentModelItemAccessors the parent model item accorssors
     * @param referenceView view that references the item
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected void parseAllModelViewItems(ConfigurationAndPluginName itemConfiguration, ViewItemAccessor parentViewItemAccessor, Collection<? extends ModelItemAccessor> parentModelItemAccessors, View referenceView, boolean override, ViewParserContext context) throws ConfigurationException
    {
        // For all accessors' items 
        for (ModelItem modelItem : ModelHelper.getModelItems(parentModelItemAccessors))
        {
            // Create the view item corresponding to the model item
            ModelViewItem viewItem = createModelViewItemForAllItemsReference(itemConfiguration, modelItem, referenceView, override, context);
      
            // Add the view item to its parent
            _addItemToViewItemAccessor(parentViewItemAccessor, viewItem, itemConfiguration.configuration(), referenceView, override);
            
            // Recursively add all item's children
            if (modelItem instanceof ModelItemContainer modelItemContainer && viewItem instanceof ViewItemContainer viewItemContainer)
            {
                parseAllModelViewItems(itemConfiguration, viewItemContainer, List.of(modelItemContainer), referenceView, override, context);
            }
        }
    }
    
    /**
     * Creates the model view item corresponding to the given configuration, in cas of all items references
     * @param itemConfiguration configuration of the model view item
     * @param modelItem the model item
     * @param referenceView view that references the item
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @return the created model view item
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected ModelViewItem createModelViewItemForAllItemsReference(ConfigurationAndPluginName itemConfiguration, ModelItem modelItem, View referenceView, boolean override, ViewParserContext context) throws ConfigurationException
    {
        return createModelViewItem(itemConfiguration, modelItem, referenceView, override, context);
    }

    /**
     * Creates the model view item corresponding to the given configuration
     * @param itemConfiguration configuration of the model view item
     * @param modelItem the model item
     * @param referenceView view that references the item
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @return the created model view item
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected ModelViewItem createModelViewItem(ConfigurationAndPluginName itemConfiguration, ModelItem modelItem, View referenceView, boolean override, ViewParserContext context) throws ConfigurationException
    {
        ModelViewItem viewItem;
        if (modelItem instanceof ModelItemGroup modelItemGroup)
        {
            viewItem = _createLeafModelViewItemInstance(modelItemGroup);
            for (Configuration childConfiguration : itemConfiguration.configuration().getChildren())
            {
                _parseViewItemAccessorChild(new ConfigurationAndPluginName(childConfiguration, itemConfiguration.pluginName(), itemConfiguration.defaultI18nCatalog()), (ViewItemAccessor) viewItem, modelItemGroup, referenceView, override, context);
            }
        }
        else
        {
            viewItem = _parseViewElement(itemConfiguration, (ElementDefinition) modelItem, referenceView, override, context);
        }
        
        // Parse label and description
        if (itemConfiguration.configuration().getChild("label", false) != null)
        {
            viewItem.setLabel(ItemParserHelper.parseI18nizableText(itemConfiguration, "label"));
        }
        if (itemConfiguration.configuration().getChild("description", false) != null)
        {
            viewItem.setDescription(ItemParserHelper.parseI18nizableText(itemConfiguration, "description"));
        }
        
        // Parse disabled item rendering
        Optional.of(itemConfiguration)
                .map(ConfigurationAndPluginName::configuration)
                .map(config -> config.getAttribute("disabled", DisabledItemRendering.DEFAULT.name()))
                .map(String::toUpperCase)
                .map(DisabledItemRendering::valueOf)
                .ifPresent(viewItem::setDisabledItemRendering);
        
        return viewItem;
    }
    
    /**
     * Creates view items corresponding to the given path.
     * @param itemConfiguration the configuration containing the model item reference
     * @param modelItemAccessorPath The path of the model item accessor to retrieve 
     * @param viewItemAccessor the view item accessor relative to the given path 
     * @param modelItemAccessors the model item accessor relative to the given path
     * @param referenceView the reference view for includes
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @return the found or created view item accessor
     * @throws ConfigurationException if the given path does not correspond to a model item accessor
     */
    protected ViewItemAccessor _createViewItemAccessor(Configuration itemConfiguration, String modelItemAccessorPath, ViewItemAccessor viewItemAccessor, Collection<? extends ModelItemAccessor> modelItemAccessors, View referenceView, boolean override) throws ConfigurationException
    {
        int firstIndexOfItemPathSeparator = modelItemAccessorPath.indexOf(ModelItem.ITEM_PATH_SEPARATOR);
        String firstPathSegment = firstIndexOfItemPathSeparator > -1 ? modelItemAccessorPath.substring(0, modelItemAccessorPath.indexOf(ModelItem.ITEM_PATH_SEPARATOR)) : modelItemAccessorPath;
        
        ModelItem modelItem = ModelHelper.getModelItem(firstPathSegment, modelItemAccessors);
        
        if (modelItem instanceof ModelItemAccessor)
        {
            // Create the view item and add it to the current view item accessor
            ModelViewItem viewItem = _createModelViewItemInstance(modelItem);
            
            // Add the view item to its parent
            _addItemToViewItemAccessor(viewItemAccessor, viewItem, itemConfiguration, referenceView, override);
            
            if (firstIndexOfItemPathSeparator > -1)
            {
                // Only the first segment of the path has been processed, now recursively process the next ones
                String subPath = modelItemAccessorPath.substring(firstIndexOfItemPathSeparator + 1);
                return _createViewItemAccessor(itemConfiguration, subPath, (ViewItemAccessor) viewItem, List.of((ModelItemAccessor) modelItem), referenceView, override);
            }
            else
            {
                return (ViewItemAccessor) viewItem;
            }
        }
        else
        {
            throw new ConfigurationException("Unable to get or create a view item accessor, the given path '" + modelItemAccessorPath + "' refers to a model item that is not an accessor");
        }
    }
    
    /**
     * Retrieves the model item with the given name
     * @param itemConfiguration configuration of the model view item
     * @param modelItemName the model item name
     * @param parents the accessors containing the model item
     * @return the model item
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected ModelItem _getModelItem(ConfigurationAndPluginName itemConfiguration, String modelItemName, Collection<? extends ModelItemAccessor> parents) throws ConfigurationException
    {
        try
        {
            return ModelHelper.getModelItem(modelItemName, parents);
        }
        catch (IllegalArgumentException | UndefinedItemPathException e)
        {
            throw new ConfigurationException("The item '" + modelItemName + "' is not defined in model.", itemConfiguration.configuration(), e);
        }
    }
    
    /**
     * Retrieves the model item reference from the given item configuration
     * @param itemConfiguration the item configuration
     * @return the model item reference
     * @throws ConfigurationException if an error occurs while parsing the model item reference
     */
    protected String _getModelItemReference(Configuration itemConfiguration) throws ConfigurationException
    {
        return itemConfiguration.getAttribute(ITEM_REFERENCE_ATTRIBUTE_NAME);
    }
    
    /**
     * Retrieves the child configuration to add items to the current accessor
     * @param accessorConfiguration the accessor configuration
     * @return the child configuration to add items to the current accessor
     */
    protected Configuration _getAddItemChildConfiguration(Configuration accessorConfiguration)
    {
        return accessorConfiguration.getChild(ADD_ITEM_TAG_NAME, false);
    }
    
    /**
     * Parses the view element 
     * @param itemConfiguration configuration of the view item
     * @param definition definition of the element
     * @param referenceView view that references the item
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @return the view item
     * @throws ConfigurationException if the configuration is not valid
     */
    protected ViewElement _parseViewElement(ConfigurationAndPluginName itemConfiguration, ElementDefinition definition, View referenceView, boolean override, ViewParserContext context) throws ConfigurationException
    {
        return (ViewElement) _createLeafModelViewItemInstance(definition);
    }
    
    /**
     * Creates an instance of {@link ModelViewItem} due to the given {@link ModelItem}
     * @param modelItem the model item corresponding to the view item to create
     * @return the created view item
     */
    @SuppressWarnings("unchecked")
    protected ModelViewItem _createModelViewItemInstance(ModelItem modelItem)
    {
        ModelViewItem modelViewItem = ViewHelper.createModelViewItemInstance(modelItem);
        modelViewItem.setDefinition(modelItem);
        
        return modelViewItem;
    }
    
    /**
     * Creates an instance of {@link ModelViewItem} due to the given {@link ModelItem}. The view item is a leaf of the view
     * @param modelItem the model item corresponding to the view item to create
     * @return the created view item
     */
    protected ModelViewItem _createLeafModelViewItemInstance(ModelItem modelItem)
    {
        return _createModelViewItemInstance(modelItem);
    }
    
    /**
     * Parses the item with the given configuration and add the item to the given view item accessor
     * @param itemConfiguration the configuration of the item to parse
     * @param viewItemAccessor the {@link ViewItemAccessor} that will access to the parsed items
     * @param modelItemAccessor the {@link ModelItemAccessor} corresponding to the given view item accessor
     * @param referenceView The view that references the item
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @throws ConfigurationException if the configuration is not valid
     */
    protected void _parseViewItemAccessorChild(ConfigurationAndPluginName itemConfiguration, ViewItemAccessor viewItemAccessor, ModelItemAccessor modelItemAccessor, View referenceView, boolean override, ViewParserContext context) throws ConfigurationException
    {
        if (_isAddingItemConfiguration(itemConfiguration.configuration()))
        {
            _parseModelViewItem(itemConfiguration, viewItemAccessor, List.of(modelItemAccessor), referenceView, override, context);
        }
        else if (_isAddingGroupConfiguration(itemConfiguration.configuration()))
        {
            _parseSimpleViewItemGroup(itemConfiguration, ViewItemGroup.FIELDSET_ROLE, viewItemAccessor, List.of(modelItemAccessor), referenceView, override, context);
        }
    }
    
    /**
     * Parses a simple view item group and add it to its parent
     * @param itemConfiguration configuration of the simple view item group
     * @param role the role of the view group
     * @param parent the parent view item accessor
     * @param modelItemAccessors the current parent model item accessors
     * @param referenceView the reference view for includes
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected void _parseSimpleViewItemGroup(ConfigurationAndPluginName itemConfiguration, String role, ViewItemAccessor parent, Collection<? extends ModelItemAccessor> modelItemAccessors, View referenceView, boolean override, ViewParserContext context) throws ConfigurationException
    {
        SimpleViewItemGroup group = new SimpleViewItemGroup();
        group.setRole(itemConfiguration.configuration().getAttribute("role", role));
        group.setName(itemConfiguration.configuration().getAttribute("name", null));
        
        group.setLabel(ItemParserHelper.parseI18nizableText(itemConfiguration, "label"));
        group.setDescription(ItemParserHelper.parseI18nizableText(itemConfiguration, "description"));

        for (Configuration childConfiguration : itemConfiguration.configuration().getChildren())
        {
            _parseSimpleViewItemGroupChild(new ConfigurationAndPluginName(childConfiguration, itemConfiguration.pluginName(), itemConfiguration.defaultI18nCatalog()), group, modelItemAccessors, referenceView, override, context);
        }
        
        // Add the group to its parent
        _addItemToViewItemAccessor(parent, group, itemConfiguration.configuration(), referenceView, override);
    }
    
    /**
     * Parses the item with the given configuration and add the item to the given group
     * @param itemConfiguration configuration of the group's child
     * @param group the simple view item group
     * @param modelItemAccessors the current parent model item accessors
     * @param referenceView the reference view for includes
     * @param override <code>true</code> if the configuration is an override, <code>false</code> otherwise
     * @param context the context of the view parsing
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected void _parseSimpleViewItemGroupChild(ConfigurationAndPluginName itemConfiguration, SimpleViewItemGroup group, Collection<? extends ModelItemAccessor> modelItemAccessors, View referenceView, boolean override, ViewParserContext context) throws ConfigurationException
    {
        if (_isAddingItemConfiguration(itemConfiguration.configuration()))
        {
            _parseModelViewItem(itemConfiguration, group, modelItemAccessors, referenceView, override, context);
        }
        else if (_isAddingGroupConfiguration(itemConfiguration.configuration()))
        {
            _parseSimpleViewItemGroup(itemConfiguration, ViewItemGroup.FIELDSET_ROLE, group, modelItemAccessors, referenceView, override, context);
        }
    }
    
    /**
     * Add an item to a view or to an overridden view
     * @param viewItemAccessor The view 
     * @param viewItem The view item to add
     * @param itemConfiguration The item's configurations
     * @param referenceView the reference view for includes
     * @param override <code>true</code> if the view is an override, <code>false</code> otherwise
     * @throws ConfigurationException If an error occurs
     */
    protected void _addItemToViewItemAccessor(ViewItemAccessor viewItemAccessor, ViewItem viewItem, Configuration itemConfiguration, View referenceView, boolean override) throws ConfigurationException 
    {
        // Check already existing view items
        if (getLogger().isWarnEnabled() && viewItem instanceof ModelViewItem modelViewItem && (viewItemAccessor.hasModelViewItem(modelViewItem) || referenceView.hasModelViewItem(modelViewItem)))
        {
            String itemPath = modelViewItem.getDefinition().getPath();
            getLogger().warn("The item '" + itemPath + "' is already referenced by the view '" + referenceView.getName() + "'.");
        }
        
        if (viewItemAccessor instanceof View view && override)
        {
            _addItemToOverriddenView(view, viewItem, itemConfiguration);
        }
        else
        {
            viewItemAccessor.addViewItem(viewItem);
        }
    }
    
    /**
     * Add the viewItem to the view or in a location inside the view (in a group or before/after another view item)
     * @param view The view in which to insert the new Item
     * @param viewItem The viewItem to insert
     * @param itemConfiguration The configuration of the viewItem
     * @throws ConfigurationException If an error occurs
     */
    protected void _addItemToOverriddenView(View view, ViewItem viewItem, Configuration itemConfiguration) throws ConfigurationException 
    {
        String group = itemConfiguration.getAttribute("group", null);
        ViewItemAccessor viewItemAccessor = view;
        
        if (group != null)
        {
            try
            {
                viewItemAccessor = ViewHelper.getSimpleViewItemGroup(view, group);
            }
            catch (IllegalArgumentException e)
            {
                throw new ConfigurationException("The path to the requested group where to add the view item " + viewItem.getName() + " in the initial view " + view.getName() + " is empty.", itemConfiguration, e);
            }
            catch (UndefinedItemPathException e)
            {
                getLogger().warn("The group requested " + group + " does not exist in the initial view " + view.getName() + ". The item '" + viewItem.getName() + "' will be inserted at the end of the view", e);
            }
        }
        
        _insertItemInViewItemAccessor(viewItemAccessor, viewItem, itemConfiguration);
    }
    
    /**
     * Insert an item in the given {@link ViewItemAccessor}
     * @param viewItemAccessor The view item accessor in which to insert the new Item
     * @param viewItem The viewItem to insert
     * @param itemConfiguration The configuration of the viewItem
     * @throws ConfigurationException If an error occurs
     */
    protected void _insertItemInViewItemAccessor(ViewItemAccessor viewItemAccessor, ViewItem viewItem, Configuration itemConfiguration) throws ConfigurationException
    {
        String before = itemConfiguration.getAttribute("order-before", null);
        String after = itemConfiguration.getAttribute("order-after", null);
        
        // An attribute cannot be before an attribute and after at the same time
        if (after != null && before != null)
        {
            throw new ConfigurationException("The item " + viewItem.getName() + " cannot be added both after and before attributes", itemConfiguration);
        }
        
        if (after != null || before != null)
        {
            InsertMode insertMode = after != null ? InsertMode.AFTER : InsertMode.BEFORE;
            String insertAfterOrBefore = after != null ? after : before;

            try
            {
                ViewHelper.insertItemAfterOrBefore(viewItemAccessor, viewItem, insertAfterOrBefore, insertMode);
            }
            catch (IllegalArgumentException e)
            {
                throw new ConfigurationException("Unable to insert view item " + viewItem.getName() + " " + insertMode + " the specified view item. The name is empty or is a path.", itemConfiguration, e);
            }
            catch (UndefinedItemPathException e)
            {
                if (getLogger().isWarnEnabled())
                {
                    String viewItemAccessorName = viewItemAccessor instanceof View view
                            ? view.getName() 
                            : viewItemAccessor instanceof ViewItem vI
                                ? vI.getName()
                                : viewItemAccessor.toString();
                    getLogger().warn("Unable to insert view item " + viewItem.getName() + " " + insertMode + " the view item named " + insertAfterOrBefore + ". No view item has been found with this name. This item will be inserted at the end of the view item accessor '" + viewItemAccessorName + "'.", e);
                }
                
                // Add the item at the end of the view item accessor
                viewItemAccessor.addViewItem(viewItem);
            }
        }
        else
        {
            viewItemAccessor.addViewItem(viewItem);
        }
    }
    
    /**
     * Removes a view item from the view
     * @param view The view from which we want to remove an item
     * @param itemConfiguration The configuration of the view item to remove
     * @throws ConfigurationException If there is an error whil parsing the item configuration
     */
    protected void _removeViewItemFromView(View view, Configuration itemConfiguration) throws ConfigurationException
    {
        String viewItemPath = itemConfiguration.getAttribute(ITEM_REFERENCE_ATTRIBUTE_NAME);

        try
        {
            ViewItem viewItem = ViewHelper.getViewItem(view, viewItemPath);
            ViewItemAccessor parent = viewItem.getParent();
            parent.removeViewItem(viewItem);
        }
        catch (Exception e)
        {
            // Just log the warning, do not throw exceptions
            getLogger().warn("[View Item removal] Unable to remove " + viewItemPath + " from " + view.getName(), e);
        } 
    }
}