/*
 *  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.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
    }
    
    /**
     * 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 reference view
     * @param currentAccessor the current accessor
     * @param accessorToInclude the accessor to include
     * @param referenceView the reference view
     * @param accessorPath the path of the accessor in the reference view
     */
    public static void addViewAccessorItems(ViewItemAccessor currentAccessor, ViewItemAccessor accessorToInclude, View referenceView, 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) || !referenceView.hasModelViewItem((ModelViewItem) itemToInclude, StringUtils.EMPTY, itemPath))
            {
                ViewItem copy = itemToInclude.createInstance();
                currentAccessor.addViewItem(copy);
                itemToInclude.copyTo(copy, referenceView, 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 viewItemContainer = createEmptyViewItemAccessor(modelItemAccessors);
        
        for (String itemPath : itemPaths)
        {
            if (ModelHelper.hasModelItem(itemPath, modelItemAccessors))
            {
                addViewItem(itemPath, viewItemContainer, modelItemAccessors.toArray(new ModelItemAccessor[modelItemAccessors.size()]));
            }
            else
            {
                String modelIds = StringUtils.join(modelItemAccessors.stream()
                                                         .map(modelItemContainer -> _getModelItemAccessorIdentifier(modelItemContainer))
                                                         .collect(Collectors.toList()), ", ");
                throw new IllegalArgumentException("Item '" + itemPath + "' not found in models: '" + modelIds + "'.");
            }
        }
        
        return viewItemContainer;
    }
    
    /**
     * 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
     * @param relativePath path of the item to add
     * @param viewItemAccessor the view item accessor
     * @param modelItemAccessors the corresponding model item accessors
     * @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 void addViewItem(String relativePath, ViewItemAccessor viewItemAccessor, 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 (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);
                addViewItem(subPath, (ViewItemAccessor) viewItem, (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)
        {
            // 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, (ModelItemContainer) modelItem);
            }
        }
    }
    
    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 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(_copyItems(originalView));
        return view;
    }
    
    private static List<ViewItem> _copyItems(ViewItemContainer currentOrigContainer)
    {
        List<ViewItem> copies = new ArrayList<>();
        for (ViewItem origChild : currentOrigContainer.getViewItems())
        {
            ViewItem destChild = origChild.createInstance();
            origChild.copyTo(destChild);
            
            if (origChild instanceof ViewItemContainer)
            {
                ((ViewItemContainer) destChild).addViewItems(_copyItems((ViewItemContainer) origChild));
            }
            
            copies.add(destChild);
        }
        
        return copies;
    }
    
    /**
     * Retrieves a View corresponding to the given one, where items that appears several times are merged
     * @param originalView the view to merge
     * @return the merged view
     */
    public static View mergeDuplicatedItems(View originalView)
    {
        View view = new View();
        
        _mergeDuplicatedItems(originalView, view, view, StringUtils.EMPTY);
        
        return view;
    }
    
    private static void _mergeDuplicatedItems(ViewItemAccessor currentOrigAccessor, ViewItemAccessor currentDestAccessor, View destinationView, 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(destinationView, itemPath))
                {
                    // Ignore View elements, check view item accessors
                    if (origChild instanceof ViewItemAccessor)
                    {
                        ViewItem destChild = ViewHelper.getModelViewItem(destinationView, itemPath);
                        _mergeDuplicatedItems((ViewItemAccessor) origChild, (ViewItemAccessor) destChild, destinationView, itemPath);
                    }
                }
                else
                {
                    ViewItem destChild = origChild.createInstance();
                    currentDestAccessor.addViewItem(destChild);
                    origChild.copyTo(destChild, destinationView, itemPath);
                }
            }
            else
            {
                ViewItem destChild = origChild.createInstance();
                currentDestAccessor.addViewItem(destChild);
                origChild.copyTo(destChild);
                _mergeDuplicatedItems((ViewItemAccessor) origChild, (ViewItemAccessor) destChild, destinationView, 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() + "')");
                }
            }
        }
    }
}