/*
 *  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.Arrays;
import java.util.Collection;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.stream.Collectors;

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
    }
    
    /**
     * Add the items of the view item container to include if they are not already present in the current view item container or in the reference view
     * @param currentContainer the current container
     * @param containerToInclude the container to include
     * @param referenceView the reference view
     */
    public static void addViewContainerItems(ViewItemContainer currentContainer, ViewItemContainer containerToInclude, View referenceView)
    {
        for (ViewItem itemToCopy : containerToInclude.getViewItems())
        {
            if (itemToCopy instanceof SimpleViewItemGroup)
            {
                SimpleViewItemGroup groupToCopy = (SimpleViewItemGroup) itemToCopy;
                SimpleViewItemGroup group = new SimpleViewItemGroup();
                group.copyGroupItem(groupToCopy, referenceView);
                
                currentContainer.addViewItem(group);
            }
            else
            {
                String itemName = itemToCopy.getName();
                if (!currentContainer.hasModelViewItem(itemName) && !referenceView.hasModelViewItem(itemName))
                {
                    currentContainer.addViewItem(itemToCopy);
                }
            }
        }
    }
    
    /**
     * Creates a {@link ViewItemContainer} with the items of the given {@link ModelItemContainer}
     * @param <T> Type of the {@link ViewItemContainer} to create ({@link View} or {@link ModelViewItemGroup})
     * @param modelItemContainers the model item containers
     * @return the created {@link ViewItemContainer}
     * @throws IllegalArgumentException if the model item containers collection is empty
     */
    public static <T extends ViewItemContainer> T createViewItemContainer(Collection<? extends ModelItemContainer> modelItemContainers) throws IllegalArgumentException
    {
        T viewItemContainer = createEmptyViewItemContainer(modelItemContainers);
        
        for (ModelItemContainer modelItemContainer : modelItemContainers)
        {
            for (ModelItem modelItem : modelItemContainer.getModelItems())
            {
                addViewItem(modelItem.getName(), viewItemContainer, modelItemContainer);
            }
        }
        
        return viewItemContainer;
    }
    
    /**
     * Creates a {@link ViewItemContainer} with the given items
     * @param <T> Type of the {@link ViewItemContainer} to create ({@link View} or {@link ModelViewItemGroup})
     * @param modelItemContainers the model items containing items definitions
     * @param itemPaths the paths of the items to put in the view item container
     * @return the created {@link ViewItemContainer}
     * @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 ViewItemContainer> T createViewItemContainer(Collection<? extends ModelItemContainer> modelItemContainers, String... itemPaths) throws IllegalArgumentException, BadItemTypeException
    {
        T viewItemContainer = createEmptyViewItemContainer(modelItemContainers);
        
        for (String itemPath : itemPaths)
        {
            if (ModelHelper.hasModelItem(itemPath, modelItemContainers))
            {
                addViewItem(itemPath, viewItemContainer, modelItemContainers.toArray(new ModelItemContainer[modelItemContainers.size()]));
            }
            else
            {
                String modelIds = StringUtils.join(modelItemContainers.stream()
                                                         .map(modelItemContainer -> _getModelItemContainerIdentifier(modelItemContainer))
                                                         .collect(Collectors.toList()), ", ");
                throw new IllegalArgumentException("Item '" + itemPath + "' not found in models: '" + modelIds + "'.");
            }
        }
        
        return viewItemContainer;
    }
    
    /**
     * Creates an empty {@link ViewItemContainer}
     * The created container can be a {@link View} or a {@link ModelViewItemGroup}, according to the given {@link ModelItemContainer}s.
     * @param <T> The type of the created container
     * @param modelItemContainers the model items containing items definitions  
     * @return the created {@link ViewItemContainer}
     * @throws IllegalArgumentException if the model item containers collection is empty
     */
    @SuppressWarnings("unchecked")
    public static <T extends ViewItemContainer> T createEmptyViewItemContainer(Collection<? extends ModelItemContainer> modelItemContainers) throws IllegalArgumentException
    {
        if (modelItemContainers.isEmpty())
        {
            throw new IllegalArgumentException("The model is needed to create a view item container");
        }
        else
        {
            ModelItemContainer firstModelItemContainer = modelItemContainers.iterator().next();
            if (firstModelItemContainer instanceof ModelItemGroup)
            {
                ModelViewItemGroup viewItemContainer = new ModelViewItemGroup();
                viewItemContainer.setDefinition((ModelItemGroup) firstModelItemContainer);
                return (T) viewItemContainer;
            }
            else
            {
                return (T) new View();
            }
        }
    }
    
    /**
     * Add a view item in the given container
     * @param relativePath path of the item to add
     * @param viewItemContainer the view item container
     * @param modelItemContainers the corresponding model item containers
     * @throws IllegalArgumentException if the path is <code>null</code> or empty
     * @throws UndefinedItemPathException if the path 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
     */
    @SuppressWarnings("unchecked")
    public static void addViewItem(String relativePath, ViewItemContainer viewItemContainer, ModelItemContainer... modelItemContainers) throws IllegalArgumentException, UndefinedItemPathException, BadItemTypeException
    {
        int firstIndexOfItemPathSeparator = relativePath.indexOf(ModelItem.ITEM_PATH_SEPARATOR);
        String fisrtPathSegment = firstIndexOfItemPathSeparator > -1 ? relativePath.substring(0, relativePath.indexOf(ModelItem.ITEM_PATH_SEPARATOR)) : relativePath;
        
        ModelItem modelItem = ModelHelper.getModelItem(fisrtPathSegment, Arrays.asList(modelItemContainers));
        
        // Find the view item in the current view item container
        ModelViewItem viewItem = viewItemContainer.getModelViewItem(fisrtPathSegment);
        if (viewItem == null)
        {
            // If the view item does not exist, then create it...
            viewItem = modelItem instanceof ModelItemGroup ? new ModelViewItemGroup() : new ViewElement();
            viewItem.setDefinition(modelItem);
            
            // ... and add it to the current view item container
            viewItemContainer.addViewItem(viewItem);
        }
        
        if (viewItem instanceof ViewItemContainer)
        {
            // If the view item is a container, the model item is a container too
            ModelItemContainer newModelItemContainer = (ModelItemContainer) modelItem;
            
            if (firstIndexOfItemPathSeparator > -1)
            {
                // Only the first segment of the path has been processed, now recursively process the next ones
                String subPath = relativePath.substring(firstIndexOfItemPathSeparator + 1);
                addViewItem(subPath, (ViewItemContainer) viewItem, newModelItemContainer);
            }
            else
            {
                // The last segment is a group, add all its children in the current view item container
                for (ModelItem child : newModelItemContainer.getModelItems())
                {
                    String newRelativePath = StringUtils.removeStart(child.getPath(), modelItem.getPath() + ModelItem.ITEM_PATH_SEPARATOR);
                    addViewItem(newRelativePath, (ViewItemContainer) viewItem, newModelItemContainer);
                }
            }
        }
        else if (firstIndexOfItemPathSeparator > -1)
        {
            // The path has several segments but the first one is not a view item container
            throw new BadItemTypeException("The segments inside the items' paths can only refer to a group. The path '" + relativePath + "' refers to the item '" + modelItem.getPath() + "' that is not a group");
        }
    }
    
    private static Optional<String> _getModelItemContainerIdentifier(ModelItemContainer container)
    {
        if (container instanceof Model)
        {
            return Optional.ofNullable(((Model) container).getId());
        }
        else if (container instanceof ModelItem)
        {
            return Optional.ofNullable(((ModelItem) container).getName());
        }
        else
        {
            return Optional.empty();
        }
    }
    
    /**
     * 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;
    }
    
    /**
     * Gets the {@link ModelViewItem} from the {@link ViewItemContainer} 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 itemContainer The container 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(ViewItemContainer itemContainer, String itemPath) throws UndefinedItemPathException, BadItemTypeException
    {
        return new ViewItemGetter(itemContainer).getViewItem(itemPath);
    }
    
    /**
     * Gets the {@link ViewElement} from the {@link ViewItemContainer} 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 itemContainer The container 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(ViewItemContainer itemContainer, String itemPath) throws UndefinedItemPathException, BadItemTypeException
    {
        return new ViewItemGetter(itemContainer).getModelViewItem(itemPath);
    }
    
    /**
     * Gets the {@link ModelViewItemGroup} from the {@link ViewItemContainer} 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 itemContainer The container 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(ViewItemContainer itemContainer, String itemPath) throws UndefinedItemPathException, BadItemTypeException
    {
        return new ViewItemGetter(itemContainer).getViewItemContainer(itemPath);
    }
    
    private static class ViewItemGetter
    {
        private final ViewItemContainer _itemContainer;
        private String _wholePath;
        
        ViewItemGetter(ViewItemContainer view)
        {
            _itemContainer = view;
        }
        
        ModelViewItem getViewItem(String wholePath) throws UndefinedItemPathException, BadItemTypeException
        {
            _wholePath = wholePath;
            BiFunction<ViewItemContainer, String, ModelViewItem> lastPartGetter = (viewItemContainer, lastPart) -> _getDirectViewItem(viewItemContainer, lastPart, ModelViewItem.class);
            return _getModelViewItem(lastPartGetter);
        }
        
        ViewElement getModelViewItem(String wholePath) throws UndefinedItemPathException, BadItemTypeException
        {
            _wholePath = wholePath;
            BiFunction<ViewItemContainer, String, ViewElement> lastPartGetter = (viewItemContainer, lastPart) -> _getDirectViewItem(viewItemContainer, lastPart, ViewElement.class);
            return _getModelViewItem(lastPartGetter);
        }
        
        ModelViewItemGroup getViewItemContainer(String wholePath) throws UndefinedItemPathException, BadItemTypeException
        {
            _wholePath = wholePath;
            BiFunction<ViewItemContainer, String, ModelViewItemGroup> lastPartGetter = (viewItemContainer, lastPart) -> _getDirectViewItemContainer(viewItemContainer, lastPart);
            return _getModelViewItem(lastPartGetter);
        }
        
        private <T> T _getModelViewItem(BiFunction<ViewItemContainer, String, T> lastPartGetter) throws UndefinedItemPathException, BadItemTypeException
        {
            Deque<String> parts = new ArrayDeque<>(Arrays.asList(_wholePath.split(ModelItem.ITEM_PATH_SEPARATOR)));
            String lastPart = parts.removeLast();
            ViewItemContainer currentViewItemContainer = _itemContainer;
            while (!parts.isEmpty())
            {
                String currentPart = parts.pop();
                currentViewItemContainer =  _getDirectViewItemContainer(currentViewItemContainer, currentPart);
            }
            
            return lastPartGetter.apply(currentViewItemContainer, lastPart);
        }
        
        private ModelViewItemGroup _getDirectViewItemContainer(ViewItemContainer viewItemContainer, String itemName) throws UndefinedItemPathException, BadItemTypeException
        {
            return _getDirectViewItem(viewItemContainer, itemName, ModelViewItemGroup.class);
        }
        
        private <T> T _getDirectViewItem(ViewItemContainer viewItemContainer, String itemName, Class<T> resultClass) throws UndefinedItemPathException, BadItemTypeException
        {
            if (!viewItemContainer.hasModelViewItem(itemName))
            {
                throw new UndefinedItemPathException("For path '" + _wholePath + "', the part '" + itemName + "' is not defined");
            }
            else
            {
                ModelViewItem modelViewItem = viewItemContainer.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() + "')");
                }
            }
        }
    }
}