/*
 *  Copyright 2018 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.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.apache.cocoon.ProcessingException;
import org.apache.commons.lang3.StringUtils;

import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.exception.UndefinedItemPathException;

/**
 * Helper class for views
 */
public final class ViewHelper
{
    private ViewHelper()
    {
        // Empty constructor
    }
    
    /**
     * The mode used to insert a view item in an existing view item accessor
     */
    public static enum InsertMode
    {
        /** Insert the view item before the referenced one */
        BEFORE (0),
        /** Insert the view item after the referenced one */
        AFTER (1);

        private final int _positionFromReferencedViewItem;

        InsertMode(int offsetFromViewItem)
        {
            this._positionFromReferencedViewItem = offsetFromViewItem;
        }

        /**
         * Retrieves the position of the item to insert compared to the referenced one
         * @return the position of the item to insert compared to the referenced one
         */
        public int getPositionFromReferencedViewItem()
        {
            return _positionFromReferencedViewItem;
        }
        
        @Override
        public String toString()
        {
            return super.toString().toLowerCase();
        }
    }
    
    /**
     * 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
     */
    public static ModelViewItem createModelViewItemInstance(ModelItem modelItem)
    {
        return modelItem instanceof ModelItemGroup
                ? new ModelViewItemGroup()
                : modelItem instanceof ModelItemAccessor
                    ? new ViewElementAccessor()
                    : new ViewElement();
    }
    
    /**
     * Retrieves the path of the given {@link ModelViewItem}. Only keep segments of the model view items, does not include groups
     * @param modelViewItem the model view item
     * @return the model view item's path
     */
    public static String getModelViewItemPath(ModelViewItem modelViewItem)
    {
        String path = modelViewItem.getName();
        ViewItemAccessor parent = modelViewItem.getParent();
        while (parent != null)
        {
            if (parent instanceof ModelViewItem parentModelViewItem)
            {
                path = parentModelViewItem.getName() + ModelItem.ITEM_PATH_SEPARATOR + path;
            }
            
            parent = parent instanceof ViewItem parentViewItem ? parentViewItem.getParent() : null;
        }
        
        return path;
    }
    
    /**
     * Copy the given view items. Also copy the children of view item accessors
     * @param viewItems the view items to copy
     * @return the view items copies
     */
    public static List<ViewItem> copyViewItems(List<ViewItem> viewItems)
    {
        return copyViewItems(viewItems, ViewHelper::createViewItemInstance);
    }
    
    /**
     * Copy the given view items. Also copy the children of view item accessors
     * @param viewItems the view items to copy
     * @param createCopyInstance the method to use to create the view item instances
     * @return the view items copies
     */
    public static List<ViewItem> copyViewItems(List<ViewItem> viewItems, Function<ViewItem, ViewItem> createCopyInstance)
    {
        List<ViewItem> copies = new ArrayList<>();
        
        for (ViewItem viewItem : viewItems)
        {
            ViewItem copy = createCopyInstance.apply(viewItem);
            viewItem.copyTo(copy);
            
            if (viewItem instanceof ViewItemAccessor viewItemAccessor)
            {
                List<ViewItem> copyChildren = copyViewItems(viewItemAccessor.getViewItems(), createCopyInstance);
                ((ViewItemAccessor) copy).addViewItems(copyChildren);
            }
            
            copies.add(copy);
        }
        
        return copies;
    }
    
    /**
     * Create an instance of {@link ViewItem} from the given one
     * @param viewItem the view item used to create the new instance of {@link ViewItem}
     * @return the created {@link ViewItem} instance
     */
    public static ViewItem createViewItemInstance(ViewItem viewItem)
    {
        return viewItem.createInstance();
    }
    
    /**
     * Add the items of the view item accessor to include if they are not already present in the current view item accessor or in the referenced one
     * @param currentAccessor the current accessor
     * @param accessorToInclude the accessor to include
     * @param referenceViewItemAccessor the reference view item accessor
     * @param accessorPath the path of the accessor relative to the reference view item accessor
     */
    public static void addViewAccessorItems(ViewItemAccessor currentAccessor, ViewItemAccessor accessorToInclude, ViewItemAccessor referenceViewItemAccessor, String accessorPath)
    {
        for (ViewItem itemToInclude : accessorToInclude.getViewItems())
        {
            String itemPath = accessorPath;
            if (itemToInclude instanceof ModelViewItem)
            {
                itemPath += StringUtils.isNotEmpty(accessorPath) ? ModelItem.ITEM_PATH_SEPARATOR + itemToInclude.getName() : itemToInclude.getName();
            }

            if (!(itemToInclude instanceof ModelViewItem) || !referenceViewItemAccessor.hasModelViewItem((ModelViewItem) itemToInclude, StringUtils.EMPTY, itemPath))
            {
                ViewItem copy = itemToInclude.createInstance();
                currentAccessor.addViewItem(copy);
                itemToInclude.copyTo(copy, referenceViewItemAccessor, itemPath);
            }
        }
    }
    
    /**
     * Creates a {@link ViewItemAccessor} with the items of the given {@link ModelItemAccessor}
     * @param <T> Type of the {@link ViewItemAccessor} to create ({@link View}, {@link ModelViewItemGroup} or {@link ViewElementAccessor})
     * @param modelItemAccessors the model item accessors
     * @return the created {@link ViewItemAccessor}
     * @throws IllegalArgumentException if the model item accessors collection is empty
     */
    public static <T extends ViewItemAccessor> T createViewItemAccessor(Collection<? extends ModelItemAccessor> modelItemAccessors) throws IllegalArgumentException
    {
        T viewItemAccessor = createEmptyViewItemAccessor(modelItemAccessors);
        
        for (ModelItemAccessor modelItemAccessor : modelItemAccessors)
        {
            for (ModelItem modelItem : modelItemAccessor.getModelItems())
            {
                if (!viewItemAccessor.hasModelViewItem(modelItem.getName()))
                {
                    addViewItem(modelItem.getName(), viewItemAccessor, modelItemAccessor);
                }
            }
        }
        
        return viewItemAccessor;
    }
    
    /**
     * Creates a {@link ViewItemAccessor} with the given items
     * @param <T> Type of the {@link ViewItemAccessor} to create ({@link View}, {@link ModelViewItemGroup} or {@link ViewElementAccessor})
     * @param modelItemAccessors the model items accessing the items definitions
     * @param itemPaths the paths of the items to put in the view item accessor
     * @return the created {@link ViewItemAccessor}
     * @throws IllegalArgumentException if the model item containers collection is empty or if an item path is <code>null</code>, empty, or is not defined in the given model item containers
     * @throws BadItemTypeException if a segment in a path (but not the last) does not represent a group item
     */
    public static <T extends ViewItemAccessor> T createViewItemAccessor(Collection<? extends ModelItemAccessor> modelItemAccessors, String... itemPaths) throws IllegalArgumentException, BadItemTypeException
    {
        T viewItemAccessor = createEmptyViewItemAccessor(modelItemAccessors);
        
        for (String itemPath : itemPaths)
        {
            if (ModelHelper.hasModelItem(itemPath, modelItemAccessors))
            {
                addViewItem(itemPath, viewItemAccessor, modelItemAccessors.toArray(new ModelItemAccessor[modelItemAccessors.size()]));
            }
            else
            {
                String modelIds = modelItemAccessors.stream()
                                                    .map(modelItemContainer -> _getModelItemAccessorIdentifier(modelItemContainer))
                                                    .flatMap(Optional::stream)
                                                    .collect(Collectors.joining(", "));
                throw new IllegalArgumentException("Item '" + itemPath + "' not found in models: '" + modelIds + "'.");
            }
        }
        
        return viewItemAccessor;
    }
    
    /**
     * Creates an empty {@link ViewItemAccessor}
     * The created container can be a {@link View}, a {@link ModelViewItemGroup} or a {@link ViewElementAccessor}, according to the given {@link ModelItemAccessor}s.
     * @param <T> The type of the created accessor
     * @param modelItemAccessors the model items accessing the items definitions
     * @return the created {@link ViewItemAccessor}
     * @throws IllegalArgumentException if the model item accessors collection is empty
     */
    @SuppressWarnings("unchecked")
    public static <T extends ViewItemAccessor> T createEmptyViewItemAccessor(Collection<? extends ModelItemAccessor> modelItemAccessors) throws IllegalArgumentException
    {
        if (modelItemAccessors.isEmpty())
        {
            throw new IllegalArgumentException("The model is needed to create a view item container");
        }
        else
        {
            ModelItemAccessor firstModelItemAccessor = modelItemAccessors.iterator().next();
            if (firstModelItemAccessor instanceof ElementDefinition)
            {
                ViewElementAccessor viewItemAccesor = new ViewElementAccessor();
                viewItemAccesor.setDefinition((ElementDefinition) firstModelItemAccessor);
                return (T) viewItemAccesor;
            }
            else if (firstModelItemAccessor instanceof ModelItemGroup)
            {
                ModelViewItemGroup viewItemAccessor = new ModelViewItemGroup();
                viewItemAccessor.setDefinition((ModelItemGroup) firstModelItemAccessor);
                return (T) viewItemAccessor;
            }
            else
            {
                return (T) new View();
            }
        }
    }
    
    /**
     * Add a view item in the given accessor.
     * Only one view item is created for a given container. All paths with the same container are added in the same view item.
     * If the last segment of the given path is a {@link ModelItemContainer}, all its children are added to the created view item
     * @param relativePath path of the item to add
     * @param viewItemAccessor the view item accessor
     * @param modelItemAccessors the corresponding model item accessors
     * @return the added view item
     * @throws IllegalArgumentException if the path is <code>null</code> or empty
     * @throws UndefinedItemPathException if the path is not defined in the given model item accessors
     * @throws BadItemTypeException if a segment in a path (but not the last) does not represent a group item
     */
    public static ModelViewItem addViewItem(String relativePath, ViewItemAccessor viewItemAccessor, ModelItemAccessor... modelItemAccessors) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException
    {
        return addViewItem(relativePath, viewItemAccessor, true, true, modelItemAccessors);
    }
    
    /**
     * Add a view item in the given accessor.
     * If mergeContainers is set to <code>true</code>, only one view item is created for a given container. All paths with the same container are added in the same view item.
     * If the last segment of the given path is a {@link ModelItemContainer} and expandContainers is set to <code>true</code>, all its children are added to the created view item
     * @param relativePath path of the item to add
     * @param viewItemAccessor the view item accessor
     * @param expandContainers set to <code>false</code> to avoid to create view items for all children of the created view item if it is a container
     * @param mergeContainers set to <code>true</code> to avoid to create new containers when they are already present in the given view item accessor
     * @param modelItemAccessors the corresponding model item accessors
     * @return the added view item
     * @throws IllegalArgumentException if the path is <code>null</code> or empty
     * @throws UndefinedItemPathException if the path is not defined in the given model item accessors
     * @throws BadItemTypeException if a segment in a path (but not the last) does not represent a group item
     */
    @SuppressWarnings("unchecked")
    public static ModelViewItem addViewItem(String relativePath, ViewItemAccessor viewItemAccessor, boolean expandContainers, boolean mergeContainers, ModelItemAccessor... modelItemAccessors) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException
    {
        int firstIndexOfItemPathSeparator = relativePath.indexOf(ModelItem.ITEM_PATH_SEPARATOR);
        String firstPathSegment = firstIndexOfItemPathSeparator > -1 ? relativePath.substring(0, relativePath.indexOf(ModelItem.ITEM_PATH_SEPARATOR)) : relativePath;
        
        ModelItem modelItem = ModelHelper.getModelItem(firstPathSegment, Arrays.asList(modelItemAccessors));
        
        // Create the view item and add it to the current view item container
        ModelViewItem viewItem = null;
        if (modelItem instanceof ModelItemAccessor)
        {
            if (mergeContainers && viewItemAccessor.hasModelViewItem(firstPathSegment))
            {
                viewItem = viewItemAccessor.getModelViewItem(firstPathSegment);
            }
            else
            {
                if (modelItem instanceof ModelItemGroup)
                {
                    viewItem = new ModelViewItemGroup();
                }
                else
                {
                    viewItem = new ViewElementAccessor();
                }
                viewItem.setDefinition(modelItem);
                viewItemAccessor.addViewItem(viewItem);
            }
        }
        else
        {
            viewItem = new ViewElement();
            viewItem.setDefinition(modelItem);
            viewItemAccessor.addViewItem(viewItem);
        }

        if (firstIndexOfItemPathSeparator > -1)
        {
            if (modelItem instanceof ModelItemAccessor)
            {
                // Only the first segment of the path has been processed, now recursively process the next ones
                String subPath = relativePath.substring(firstIndexOfItemPathSeparator + 1);
                return addViewItem(subPath, (ViewItemAccessor) viewItem, expandContainers, mergeContainers, (ModelItemAccessor) modelItem);
            }
            else
            {
                // The path has several segments but the first one is not a view item accessor
                throw new BadItemTypeException("The segments inside the items' paths can only refer to an accessor. The path '" + relativePath + "' refers to the item '" + modelItem.getPath() + "' that is not an accessor");
            }
        }
        else if (modelItem instanceof ModelItemContainer && expandContainers)
        {
            // The last segment is a container, add all its children in the current view item container
            for (ModelItem child : ((ModelItemContainer) modelItem).getModelItems())
            {
                String newRelativePath = StringUtils.removeStart(child.getPath(), modelItem.getPath() + ModelItem.ITEM_PATH_SEPARATOR);
                addViewItem(newRelativePath, (ViewItemAccessor) viewItem, expandContainers, mergeContainers, (ModelItemContainer) modelItem);
            }
        }
        
        return viewItem;
    }

    private static Optional<String> _getModelItemAccessorIdentifier(ModelItemAccessor accessor)
    {
        if (accessor instanceof Model)
        {
            return Optional.ofNullable(((Model) accessor).getId());
        }
        else if (accessor instanceof ModelItem)
        {
            return Optional.ofNullable(((ModelItem) accessor).getName());
        }
        else
        {
            return Optional.empty();
        }
    }
    
    /**
     * Retrieves the {@link SimpleViewItemGroup} at the given group path. All segments in the group path must refer to a {@link SimpleViewItemGroup} (tab, fieldset)
     * If there are more than one corresponding items, the first one is retrieved
     * @param viewItemAccessor The ViewItemAccessor in which to find the group of given path
     * @param groupPath The group path
     * @throws IllegalArgumentException if the group path is empty
     * @throws UndefinedItemPathException if no group was found at the given path
     * @return the found {@link SimpleViewItemGroup}
     */
    public static SimpleViewItemGroup getSimpleViewItemGroup(ViewItemAccessor viewItemAccessor, String groupPath)
    {
        String[] pathSegments = groupPath.split(ModelItem.ITEM_PATH_SEPARATOR);
        
        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to retrieve the group at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            String groupName = groupPath;
            return Optional.ofNullable(viewItemAccessor.getViewItem(groupName))
                                   .filter(SimpleViewItemGroup.class::isInstance)
                                   .map(SimpleViewItemGroup.class::cast)
                                   .orElseThrow(() -> new UndefinedItemPathException("Unable to retrieve the group with the name '" + groupName + "'. No group with this name has been found in view item accessor '" + _getViewItemAccessorName(viewItemAccessor) + "'"));
        }
        else
        {
            SimpleViewItemGroup simpleViewItemGroup = getSimpleViewItemGroup(viewItemAccessor, pathSegments[0]);
            String subGroupPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 1, pathSegments.length);
            return getSimpleViewItemGroup(simpleViewItemGroup, subGroupPath);
        }
    }
    
    /**
     * Retrieves the {@link ViewItem} at the given view path. If items are in groups, the names of the groups must appear in the path. All groups have to be named
     * If there are more than one corresponding items, the first one is retrieved
     * @param viewItemAccessor The ViewItemAccessor in which to find the view item of given path
     * @param viewItemPath The view item path
     * @throws IllegalArgumentException if the view item path is empty
     * @throws UndefinedItemPathException if no view item was found at the given path
     * @return the found {@link ViewItem}
     */
    public static ViewItem getViewItem(ViewItemAccessor viewItemAccessor, String viewItemPath)
    {
        String[] pathSegments = viewItemPath.split(ModelItem.ITEM_PATH_SEPARATOR);
        
        if (pathSegments == null || pathSegments.length < 1)
        {
            throw new IllegalArgumentException("Unable to retrieve the view item at the given path. This path is empty.");
        }
        else if (pathSegments.length == 1)
        {
            String viewItemName = viewItemPath;
            return Optional.ofNullable(viewItemAccessor.getViewItem(viewItemName))
                                   .orElseThrow(() -> new UndefinedItemPathException("Unable to retrieve the view item with the name '" + viewItemName + "'. No view item with this name has been found in view item accessor '" + _getViewItemAccessorName(viewItemAccessor) + "'"));
        }
        else
        {
            ViewItemAccessor newViewItemAccessor = viewItemAccessor.getViewItems().stream()
                                                                   .filter(viewItem -> pathSegments[0].equals(viewItem.getName()))
                                                                   .filter(ViewItemAccessor.class::isInstance)
                                                                   .map(ViewItemAccessor.class::cast)
                                                                   .findFirst()
                                                                   .orElseThrow(() -> new UndefinedItemPathException("Unable to retrieve the view item accessor with the name '" + pathSegments[0] + "'. No view item accessor with this name has been found in view item accessor '" + _getViewItemAccessorName(viewItemAccessor) + "'"));
            String subviewItemPath = StringUtils.join(pathSegments, ModelItem.ITEM_PATH_SEPARATOR, 1, pathSegments.length);
            return getViewItem(newViewItemAccessor, subviewItemPath);
        }
    }
    
    /**
     * Insert the given {@link ViewItem} to the view after the item at the given path
     * @param viewItemAccessor The ViewItemAccessor in which to insert the view item
     * @param viewItemToInsert The view item to insert
     * @param insertAfter The name of the view item after which the given one has to be inserted. The item with this name must appear in the given accessor
     * @throws IllegalArgumentException If the given view item path is null or empty
     * @throws UndefinedItemPathException If the given view item path is not present in the view item accessor
     */
    public static void insertViewItemAfter(ViewItemAccessor viewItemAccessor, ViewItem viewItemToInsert, String insertAfter)  throws IllegalArgumentException, UndefinedItemPathException
    {
        insertItemAfterOrBefore(viewItemAccessor, viewItemToInsert, insertAfter, InsertMode.AFTER);
    }
    
    /**
     * Insert the given {@link ViewItem} to the view before the item at the given path
     * @param viewItemAccessor The ViewItemAccessor in which to insert the item
     * @param viewItemToInsert The view item to insert
     * @param insertBefore The name of the view item before which the given one has to be inserted. The item with this name must appear in the given accessor
     * @throws IllegalArgumentException If the ModelItem "insertBefore" is null or empty
     * @throws UndefinedItemPathException If the path to the modelItem "insertBefore" is undefined
     */
    public static void insertItemBefore(ViewItemAccessor viewItemAccessor, ViewItem viewItemToInsert, String insertBefore)  throws IllegalArgumentException, UndefinedItemPathException
    {
        insertItemAfterOrBefore(viewItemAccessor, viewItemToInsert, insertBefore, InsertMode.BEFORE);
    }

    /**
     * Insert the given {@link ViewItem} to the view before or after the item at the given path
     * @param viewItemAccessor The ViewItemAccessor in which to insert the item
     * @param itemToInsert The view item to insert
     * @param insertAfterOrBefore The name of the view item before or after which the given one has to be inserted. The item with this name must appear in the given accessor
     * @param insertMode The mode of insertion (before or after)
     * @throws IllegalArgumentException If the ModelItem "insertAfterOrBefore" is null, empty, or is a path
     * @throws UndefinedItemPathException If the path to the modelItem "insertAfterOrBefore" is undefined
     */
    public static void insertItemAfterOrBefore(ViewItemAccessor viewItemAccessor, ViewItem itemToInsert, String insertAfterOrBefore, InsertMode insertMode) throws IllegalArgumentException, UndefinedItemPathException
    {
        // Checks that the given item path is not empty
        if (StringUtils.isBlank(insertAfterOrBefore))
        {
            throw new IllegalArgumentException("Unable to insert view item " + itemToInsert.getName() + " " + insertMode.toString() + " the view item with the given name. This name is empty.");
        }
        
        // Checks that the given item path is not a path
        if (insertAfterOrBefore.contains(ModelItem.ITEM_PATH_SEPARATOR))
        {
            throw new IllegalArgumentException("Unable to insert view item " + itemToInsert.getName() + " " + insertMode.toString() + " the view item with the name '" + insertAfterOrBefore + "'. This name is a path.");
        }
        
        if (!_doInsertItemAfterOrBefore(viewItemAccessor, itemToInsert, insertAfterOrBefore, insertMode))
        {
            throw new UndefinedItemPathException("Unable to insert view item " + itemToInsert.getName() + " " + insertMode.toString() + " the view item at path " + insertAfterOrBefore + ". No view item has been found at this path in view item accessor '" + _getViewItemAccessorName(viewItemAccessor) + "'");
        }
    }
    
    private static boolean _doInsertItemAfterOrBefore(ViewItemAccessor viewItemAccessor, ViewItem itemToInsert, String insertAfterOrBefore, InsertMode insertMode)
    {
        List<ViewItem> viewItems = viewItemAccessor.getViewItems();
        for (int indexInAccessor = 0; indexInAccessor < viewItems.size(); indexInAccessor++)
        {
            ViewItem viewItem = viewItems.get(indexInAccessor);
            if (insertAfterOrBefore.equals(viewItem.getName()))
            {
                // If the viewItemAccessor is a ModelViewItem, then check if the itemToInsert is a part of the viewItemAccessor's model
                if (viewItemAccessor instanceof ModelViewItem modelViewItem && !((ModelItemAccessor) modelViewItem.getDefinition()).hasModelItem(itemToInsert.getName()))
                {
                    throw new UndefinedItemPathException("Unable to insert view item " + itemToInsert.getName() + " " + insertMode.toString() + " the view item at path " + insertAfterOrBefore + ". The item to insert is not defined by the model.");
                }
                
                // Insert the view item to insert, in the view
                viewItemAccessor.insertViewItem(itemToInsert, indexInAccessor + insertMode.getPositionFromReferencedViewItem());
                return true;
            }
        }
        
        return false;
    }
    
    private static String _getViewItemAccessorName(ViewItemAccessor viewItemAccessor)
    {
        return viewItemAccessor instanceof View view
                ? view.getName()
                : viewItemAccessor instanceof ViewItem viewItem
                    ? viewItem.getName()
                    : viewItemAccessor.toString();
    }
    
    /**
     * Retrieves the paths of all model items in the given {@link View}
     * @param view the {@link View}
     * @return the paths of all items
     */
    public static Set<String> getModelItemsPathsFromView(View view)
    {
        return _getModelItemsFromViewItemContainer(view).keySet();
    }
    
    /**
     * Retrieves all model items in the given {@link View}
     * @param view the {@link View}
     * @return all model items
     */
    public static Collection<ModelItem> getModelItemsFromView(View view)
    {
        return _getModelItemsFromViewItemContainer(view).values();
    }
    
    /**
     * Retrieves all model items in the given {@link ViewItemContainer}, indexed by their paths
     * @param viewItemContainer the {@link ViewItemContainer}
     * @return all model items
     */
    private static Map<String, ModelItem> _getModelItemsFromViewItemContainer(ViewItemContainer viewItemContainer)
    {
        Map<String, ModelItem> result = new HashMap<>();
        
        for (ViewItem viewItem : viewItemContainer.getViewItems())
        {
            if (viewItem instanceof ModelViewItem)
            {
                ModelItem modelItem = ((ModelViewItem) viewItem).getDefinition();
                result.put(modelItem.getPath(), modelItem);
            }
            
            if (viewItem instanceof ViewItemContainer)
            {
                result.putAll(_getModelItemsFromViewItemContainer((ViewItemContainer) viewItem));
            }
        }
        
        return result;
    }
    
    /**
     * Checks if all the items of the given view are present only once in the view
     * Children of accessors that are not containers are not taken into account
     * @param view the view to check
     * @return <code>true</code> if all items are presents only once, <code>false</code> otherwise
     */
    public static boolean areItemsPresentsOnlyOnce(View view)
    {
        return _areItemsPresentsOnlyOnce(view, new HashSet<>());
    }
    
    private static boolean _areItemsPresentsOnlyOnce(ViewItemContainer containerToCheck, Set<String> paths)
    {
        for (ViewItem viewItem : containerToCheck.getViewItems())
        {
            if (viewItem instanceof ModelViewItem)
            {
                String viewItemPath = ((ModelViewItem) viewItem).getDefinition().getPath();
                
                if (paths.contains(viewItemPath))
                {
                    return false;
                }
                else
                {
                    paths.add(viewItemPath);
                }
            }

            if (viewItem instanceof ViewItemContainer && !_areItemsPresentsOnlyOnce((ViewItemContainer) viewItem, paths))
            {
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * Retrieves a View corresponding to the given one, avoiding the view items below the {@link ViewItemAccessor}s that are not {@link ViewItemContainer}s
     * @param originalView the view to truncate
     * @return the truncated view
     */
    public static View getTruncatedView(View originalView)
    {
        View view = new View();
        view.addViewItems(_copyItemsForTruncatedView(originalView));
        return view;
    }
    
    private static List<ViewItem> _copyItemsForTruncatedView(ViewItemContainer currentOrigContainer)
    {
        List<ViewItem> copies = new ArrayList<>();
        for (ViewItem origChild : currentOrigContainer.getViewItems())
        {
            // do not copy non editable item for the truncated view
            if (_isEditable(origChild))
            {
                ViewItem destChild = origChild.createInstance();
                origChild.copyTo(destChild);
                
                // Get children of containers, not accessors for the truncated view
                if (origChild instanceof ViewItemContainer)
                {
                    ((ViewItemContainer) destChild).addViewItems(_copyItemsForTruncatedView((ViewItemContainer) origChild));
                }
                
                copies.add(destChild);
            }
        }
        
        return copies;
    }
    
    private static boolean _isEditable(ViewItem viewItem)
    {
        return viewItem instanceof ViewElement viewElement ? viewElement.getDefinition().isEditable() : true;
    }
    
    /**
     * Retrieves a {@link ViewItemAccessor} corresponding to the given one, where items that appears several times are merged
     * @param <T> The type of {@link ViewItemAccessor} to merge
     * @param originalViewItemAccessor the {@link ViewItemAccessor} to merge
     * @return the merged {@link ViewItemAccessor}
     */
    @SuppressWarnings("unchecked")
    public static <T extends ViewItemAccessor> T mergeDuplicatedItems(T originalViewItemAccessor)
    {
        ViewItemAccessor destinationViewItemAccessor;
        if (originalViewItemAccessor instanceof View originalView)
        {
            View destinationView = new View();
            originalView.copyTo(destinationView);
            destinationViewItemAccessor = destinationView;
        }
        else
        {
            ViewItem destinationViewItem = ((ViewItem) originalViewItemAccessor).createInstance();
            ((ViewItem) originalViewItemAccessor).copyTo(destinationViewItem);
            destinationViewItemAccessor = (ViewItemAccessor) destinationViewItem;
        }
        
        _mergeDuplicatedItems(originalViewItemAccessor, destinationViewItemAccessor, destinationViewItemAccessor, StringUtils.EMPTY);
        
        return (T) destinationViewItemAccessor;
    }
    
    private static void _mergeDuplicatedItems(ViewItemAccessor currentOrigAccessor, ViewItemAccessor currentDestAccessor, ViewItemAccessor destinationViewItemAccessor, String accessorPath)
    {
        for (ViewItem origChild : currentOrigAccessor.getViewItems())
        {
            if (origChild instanceof ModelViewItem)
            {
                String itemPath = StringUtils.isNotEmpty(accessorPath) ? accessorPath + ModelItem.ITEM_PATH_SEPARATOR + origChild.getName() : origChild.getName();
                if (ViewHelper.hasModelViewItem(destinationViewItemAccessor, itemPath))
                {
                    // Ignore View elements, check view item accessors
                    if (origChild instanceof ViewItemAccessor)
                    {
                        ViewItem destChild = ViewHelper.getModelViewItem(destinationViewItemAccessor, itemPath);
                        _mergeDuplicatedItems((ViewItemAccessor) origChild, (ViewItemAccessor) destChild, destinationViewItemAccessor, itemPath);
                    }
                }
                else
                {
                    ViewItem destChild = origChild.createInstance();
                    currentDestAccessor.addViewItem(destChild);
                    
                    if (origChild instanceof ViewItemAccessor)
                    {
                        origChild.copyTo(destChild);
                        _mergeDuplicatedItems((ViewItemAccessor) origChild, (ViewItemAccessor) destChild, destinationViewItemAccessor, itemPath);
                    }
                    else
                    {
                        origChild.copyTo(destChild, destinationViewItemAccessor, itemPath);
                    }
                }
            }
            else
            {
                ViewItem destChild = origChild.createInstance();
                currentDestAccessor.addViewItem(destChild);
                origChild.copyTo(destChild);
                _mergeDuplicatedItems((ViewItemAccessor) origChild, (ViewItemAccessor) destChild, destinationViewItemAccessor, accessorPath);
            }
        }
    }
    
    /**
     * Checks if there is a {@link ModelViewItem} in the {@link ViewItemAccessor} at the given path
     * @param viewItemAccessor The accessor of the view items
     * @param itemPath The path of the item to check
     * @return <code>true</code> if there is a model view item at the given path, <code>false</code> otherwise
     */
    public static boolean hasModelViewItem(ViewItemAccessor viewItemAccessor, String itemPath)
    {
        try
        {
            getModelViewItem(viewItemAccessor, itemPath);
            // The model item can never be null. If no excpetion has been thrown, the there is a model item at this path
            return true;
        }
        catch (UndefinedItemPathException | BadItemTypeException e)
        {
            return false;
        }
    }
    
    /**
     * Converts the given view items as a JSON map
     * @param viewItems the view items to convert
     * @param context the context of the items' definitions
     * @return The view items as a JSON map
     * @throws ProcessingException If an error occurs when converting the view items
     */
    public static Map<String, Object> viewItemsToJSON(List<ViewItem> viewItems, DefinitionContext context) throws ProcessingException
    {
        Map<String, Object> elements = new LinkedHashMap<>();
        
        for (ViewItem item : viewItems)
        {
            Map<String, Object> itemAsJSON = item.toJSON(context);

            if (!itemAsJSON.isEmpty())
            {
                String itemUUID = item.getName();
                if (StringUtils.isEmpty(itemUUID))
                {
                    itemUUID = UUID.randomUUID().toString();
                }
                
                elements.put(itemUUID, itemAsJSON);
            }
        }
        
        return elements;
    }
    
    /**
     * Gets the {@link ModelViewItem} from the {@link ViewItemAccessor} at the given path.
     * <br>Unlike {@link View#getModelViewItem(String)}, this method accepts a path and not only a name, allowing to traverse composites.
     * @param viewItemAccessor The accessor of view items
     * @param itemPath The path of the item to get
     * @return The {@link ModelViewItem}. Can never be <code>null</code>
     * @throws UndefinedItemPathException If one of the parts of the given path is undefined
     * @throws BadItemTypeException If one of the parts of the given path is defined, but is not of the correct type
     */
    public static ModelViewItem getModelViewItem(ViewItemAccessor viewItemAccessor, String itemPath) throws UndefinedItemPathException, BadItemTypeException
    {
        return new ViewItemGetter(viewItemAccessor).getViewItem(itemPath);
    }
    
    /**
     * Gets the {@link ViewElement} from the {@link ViewItemAccessor} at the given path.
     * <br>Unlike {@link View#getModelViewItem(String)}, this method accepts a path and not only a name, allowing to traverse composites.
     * @param viewItemAccessor The accessor of view items
     * @param itemPath The path of the item to get
     * @return The {@link ViewElement}. Can never be <code>null</code>
     * @throws UndefinedItemPathException If one of the parts of the given path is undefined
     * @throws BadItemTypeException If one of the parts of the given path is defined, but is not of the correct type
     */
    public static ViewElement getViewElement(ViewItemAccessor viewItemAccessor, String itemPath) throws UndefinedItemPathException, BadItemTypeException
    {
        return new ViewItemGetter(viewItemAccessor).getModelViewItem(itemPath);
    }
    
    /**
     * Gets the {@link ModelViewItemGroup} from the {@link ViewItemAccessor} at the given path.
     * <br>Unlike {@link View#getModelViewItem(String)}, this method accepts a path and not only a name, allowing to traverse composites.
     * @param viewItemAccessor The accessor of view items
     * @param itemPath The path of the container to get
     * @return The {@link ModelViewItemGroup}. Can never be <code>null</code>
     * @throws UndefinedItemPathException If one of the parts of the given path is undefined
     * @throws BadItemTypeException If one of the parts of the given path is defined, but is not of the correct type
     */
    public static ModelViewItemGroup getModelViewItemGroup(ViewItemAccessor viewItemAccessor, String itemPath) throws UndefinedItemPathException, BadItemTypeException
    {
        return new ViewItemGetter(viewItemAccessor).getViewItemContainer(itemPath);
    }
    
    private static class ViewItemGetter
    {
        private final ViewItemAccessor _viewItemAccessor;
        private String _wholePath;
        
        ViewItemGetter(ViewItemAccessor viewItemAccessor)
        {
            _viewItemAccessor = viewItemAccessor;
        }
        
        ModelViewItem getViewItem(String wholePath) throws UndefinedItemPathException, BadItemTypeException
        {
            _wholePath = wholePath;
            BiFunction<ViewItemAccessor, String, ModelViewItem> lastPartGetter = (viewItemAccessor, lastPart) -> _getDirectViewItem(viewItemAccessor, lastPart, ModelViewItem.class);
            return _getModelViewItem(lastPartGetter);
        }
        
        ViewElement getModelViewItem(String wholePath) throws UndefinedItemPathException, BadItemTypeException
        {
            _wholePath = wholePath;
            BiFunction<ViewItemAccessor, String, ViewElement> lastPartGetter = (viewItemAccessor, lastPart) -> _getDirectViewItem(viewItemAccessor, lastPart, ViewElement.class);
            return _getModelViewItem(lastPartGetter);
        }
        
        ModelViewItemGroup getViewItemContainer(String wholePath) throws UndefinedItemPathException, BadItemTypeException
        {
            _wholePath = wholePath;
            BiFunction<ViewItemAccessor, String, ModelViewItemGroup> lastPartGetter = (viewItemAccessor, lastPart) -> _getDirectModelViewItemGroup(viewItemAccessor, lastPart);
            return _getModelViewItem(lastPartGetter);
        }
        
        private <T> T _getModelViewItem(BiFunction<ViewItemAccessor, String, T> lastPartGetter) throws UndefinedItemPathException, BadItemTypeException
        {
            Deque<String> parts = new ArrayDeque<>(Arrays.asList(_wholePath.split(ModelItem.ITEM_PATH_SEPARATOR)));
            String lastPart = parts.removeLast();
            ViewItemAccessor currentViewItemAccessor = _viewItemAccessor;
            while (!parts.isEmpty())
            {
                String currentPart = parts.pop();
                currentViewItemAccessor =  _getDirectViewItem(currentViewItemAccessor, currentPart, ViewItemAccessor.class);
            }
            
            return lastPartGetter.apply(currentViewItemAccessor, lastPart);
        }
        
        private ModelViewItemGroup _getDirectModelViewItemGroup(ViewItemAccessor viewItemAccessor, String itemName) throws UndefinedItemPathException, BadItemTypeException
        {
            return _getDirectViewItem(viewItemAccessor, itemName, ModelViewItemGroup.class);
        }
        
        private <T> T _getDirectViewItem(ViewItemAccessor viewItemAccessor, String itemName, Class<T> resultClass) throws UndefinedItemPathException, BadItemTypeException
        {
            if (!viewItemAccessor.hasModelViewItem(itemName))
            {
                throw new UndefinedItemPathException("For path '" + _wholePath + "', the part '" + itemName + "' is not defined");
            }
            else
            {
                ModelViewItem modelViewItem = viewItemAccessor.getModelViewItem(itemName);
                if (resultClass.isInstance(modelViewItem))
                {
                    return resultClass.cast(modelViewItem);
                }
                else
                {
                    throw new BadItemTypeException("For path '" + _wholePath + "', the part '" + itemName + "' does not point to a '" + resultClass + "' (got a '" + modelViewItem.getClass().getName() + "')");
                }
            }
        }
    }
    
    /**
     * Get the collection of model items from a view item accessor.
     * @param viewItemAccessor The view item accessor
     * @return a collection of model items
     */
    public static Collection<ModelItem> getModelItems(ViewItemAccessor viewItemAccessor)
    {
        Set<ModelItem> modelItems = new HashSet<>();
        
        for (ViewItem viewItem : viewItemAccessor.getViewItems())
        {
            if (viewItem instanceof ViewItemGroup viewItemGroup)
            {
                modelItems.addAll(getModelItems(viewItemGroup));
            }
            else if (viewItem instanceof ViewElement viewElement)
            {
                modelItems.add(viewElement.getDefinition());
            }
        }
        
        return modelItems;
    }
}