/*
 *  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.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.apache.cocoon.ProcessingException;

import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.util.ModifiableLabelable;

/**
 * View of items
 */
public class View implements ViewItemContainer, ModifiableLabelable
{
    private String _name;
    private I18nizableText _label;
    private I18nizableText _description;
    private String _iconGlyph;
    private String _iconDecorator;
    private String _smallIcon;
    private String _mediumIcon;
    private String _largeIcon;
    private boolean _isInternal;
    
    private List<ViewItem> _items = new ArrayList<>();
    
    /**
     * Creates a {@link View} with the items of the given {@link Model}
     * @param model the model
     * @return the created {@link View}
     * @throws IllegalArgumentException if the model is <code>null</code>
     */
    public static View of(Model model) throws IllegalArgumentException
    {
        if (model == null)
        {
            throw new IllegalArgumentException("Unable to create the view from a null model");
        }
        else
        {
            return ViewHelper.createViewItemContainer(List.of(model));
        }
    }
    
    /**
     * Creates a {@link View} with the items of the given {@link Model}s
     * @param models the models
     * @return the created {@link View}
     * @throws IllegalArgumentException if the models collection is empty
     */
    public static View of(Collection<Model> models) throws IllegalArgumentException
    {
        return ViewHelper.createViewItemContainer(models);
    }
    
    /**
     * Creates a {@link View} with the given items
     * @param model the model containing items definitions
     * @param itemPaths the paths of the items to put in the view
     * @return the created {@link View}
     * @throws IllegalArgumentException if the model is <code>null</code> or if an item path is <code>null</code>, empty, or is not defined in the given models
     * @throws BadItemTypeException if a segment in a path (but not the last) does not represent a group item
     */
    public static View of(Model model, String... itemPaths) throws IllegalArgumentException, BadItemTypeException
    {
        if (model == null)
        {
            throw new IllegalArgumentException("Unable to create the view from a null model");
        }
        else
        {
            return ViewHelper.createViewItemContainer(List.of(model), itemPaths);
        }
    }
    
    /**
     * Creates a {@link View} with the given items
     * @param models the models containing items definitions
     * @param itemPaths the paths of the items to put in the view
     * @return the created {@link View}
     * @throws IllegalArgumentException if the models collection is empty or if an item path is <code>null</code>, empty, or is not defined in the given models
     * @throws BadItemTypeException if a segment in a path (but not the last) does not represent a group item
     */
    public static View of(Collection<Model> models, String... itemPaths) throws IllegalArgumentException, BadItemTypeException
    {
        return ViewHelper.createViewItemContainer(models, itemPaths);
    }
    
    /**
     * Creates a {@link View} with the given items. If the items are in a group, the hierarchy will be kept and the corresponding containers will be created
     * @param modelItems the items to put in the view
     * @return the created {@link View}
     */
    public static View of(ModelItem... modelItems)
    {
        View view = new View();
        
        for (ModelItem modelItem : modelItems)
        {
            ViewHelper.addViewItem(modelItem.getPath(), view, modelItem.getModel());
        }
        
        return view;
    }

    public String getName()
    {
        return _name;
    }

    public void setName(String name)
    {
        _name = name;
    }
    
    public I18nizableText getLabel()
    {
        return _label;
    }

    public void setLabel(I18nizableText label)
    {
        _label = label;
    }
    
    public I18nizableText getDescription()
    {
        return _description;
    }
    
    public void setDescription(I18nizableText description)
    {
        _description = description;
    }
    
    /**
     * Retrieves the CSS class to use for glyph icon
     * @return the glyph name.
     */
    public String getIconGlyph()
    {
        return _iconGlyph;
    }
    
    /**
     * Set the CSS class to use for glyph icon
     * @param iconGlyph the glyph name.
     */
    public void setIconGlyph(String iconGlyph)
    {
        _iconGlyph = iconGlyph;
    }
    
    /**
     * Retrieves the CSS class to use for decorator above the main icon
     * @return the glyph name.
     */
    public String getIconDecorator()
    {
        return _iconDecorator;
    }
    
    /**
     * Set the CSS class to use for decorator above the main icon
     * @param iconDecorator the glyph name.
     */
    public void setIconDecorator(String iconDecorator)
    {
        _iconDecorator = iconDecorator;
    }
    
    /**
     * Retrieves the URL of the small icon without the context path.
     * @return the icon URL for the small image 16x16.
     */
    public String getSmallIcon()
    {
        return _smallIcon;
    }
    
    /**
     * Set the URL of the small icon.
     * @param smallIcon the URL of the small icon, without the context path.
     */
    public void setSmallIcon(String smallIcon)
    {
        _smallIcon = smallIcon;
    }
    
    /**
     * Retrieves the URL of the small icon without the context path.
     * @return the icon URL for the medium sized image 32x32.
     */
    public String getMediumIcon()
    {
        return _mediumIcon;
    }
    
    /**
     * Set the URL of the medium icon.
     * @param mediumIcon the URL of the medium icon, without the context path.
     */
    public void setMediumIcon(String mediumIcon)
    {
        _mediumIcon = mediumIcon;
    }
    
    /**
     * Retrieves the URL of the small icon without the context path.
     * @return the icon URL for the large image 48x48.
     */
    public String getLargeIcon()
    {
        return _largeIcon;
    }
    
    /**
     * Set the URL of the large icon.
     * @param largeIcon the URL of the large icon, without the context path.
     */
    public void setLargeIcon(String largeIcon)
    {
        _largeIcon = largeIcon;
    }
    
    /**
     * Determines if the view is for internal use only
     * @return <code>true</code> if the view is for internal use only, <code>false</code> otherwise
     */
    public boolean isInternal()
    {
        return _isInternal;
    }

    /**
     * Set the internal status
     * @param isInternal <code>true</code> to make the view for internal use only, <code>false</code> otherwise
     */
    public void setIsInternal(boolean isInternal)
    {
        _isInternal = isInternal;
    }
    
    public List<ViewItem> getViewItems()
    {
        return Collections.unmodifiableList(this._items);
    }
    
    public void addViewItem(ViewItem item)
    {
        _items.add(item);
    }
    
    public void insertViewItem(ViewItem item, int index)
    {
        if (index >= 0 && index < _items.size())
        {
            _items.add(index, item);
        }
        else
        {
            throw new IllegalArgumentException("Unable to insert an item at index " + index + ". This group contains " + _items.size() + "items.");
        }
    }

    /**
     * Converts the view in a JSON map
     * @return The view as a JSON map
     * @throws ProcessingException If an error occurs when converting the view
     */
    public Map<String, Object> toJSON() throws ProcessingException
    {
        Map<String, Object> result = new LinkedHashMap<>();
        
        result.put("name", getName());
        result.put("label", getLabel());
        result.put("description", getDescription());
        
        result.put("icon-glyph", getIconGlyph());
        result.put("icon-decorator", getIconDecorator());
        result.put("small-icon-path", getSmallIcon());
        result.put("medium-icon-path", getMediumIcon());
        result.put("large-icon-path", getLargeIcon());
    
        List<Map<String, Object>> groups = new ArrayList<>();
        for (ViewItem item : getViewItems())
        {
            if (item instanceof ViewElement)
            {
                result.putAll(item.toJSON());
            }
            else
            {
                groups.add(item.toJSON());
            }
        }
        
        if (!groups.isEmpty())
        {
            result.put("groups", groups);
        }
        
        return result;
    }
    
    /**
     * Include the given view to the current one.
     * Add the items of the view to include if they are not already present in the current view
     * @param viewToInclude the view to include
     */
    public void includeView(View viewToInclude)
    {
        ViewHelper.addViewContainerItems(this, viewToInclude, this);
    }
}