/*
 *  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.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.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 List<ViewItem> _items = new ArrayList<>();
    
    /**
     * Default constructor
     */
    public View()
    {
    }
    
    /**
     * Creates a view with the given items
     * @param model the model containing items definitions
     * @param itemPaths the paths of the items to put in the view
     */
    public View(Model model, String... itemPaths)
    {
        this(model, true, itemPaths);
    }
    
    /**
     * Creates a view with the given items
     * @param model the model containing items definitions
     * @param recursive if true, will create view items for groups children
     * @param itemPaths the paths of the items to put in the view
     */
    public View(Model model, boolean recursive, String... itemPaths)
    {
        for (String itemPath : itemPaths)
        {
            if (model.hasModelItem(itemPath))
            {
                ModelItem definition = model.getModelItem(itemPath);
                addViewItem(_getViewItemFromDefinition(definition, recursive));
            }
            else
            {
                throw new IllegalArgumentException("Item " + itemPath + "not found in " + model.getClass() + " model: " + model.toString());
            }
        }
    }

    private ViewItem _getViewItemFromDefinition(ModelItem definition, Boolean recursive)
    {
        if (definition instanceof ModelItemGroup)
        {
            ModelViewItemGroup modelViewItemGroup = new ModelViewItemGroup();
            modelViewItemGroup.setDefinition((ModelItemGroup) definition);
            
            if (recursive)
            {
                List<ModelItem> children = ((ModelItemGroup) definition).getChildren();
                for (ModelItem child : children)
                {
                    modelViewItemGroup.addViewItem(_getViewItemFromDefinition(child, recursive));
                }
            }
            
            return modelViewItemGroup;
        }
        
        ViewElement viewElement = new ViewElement();
        viewElement.setDefinition((ElementDefinition) definition);
        return viewElement;
    }

    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;
    }
    
    public List<ViewItem> getViewItems()
    {
        return Collections.unmodifiableList(this._items);
    }
    
    public boolean hasViewItem(String itemName)
    {
        return ViewHelper.hasViewItem(this, itemName);
    }
    
    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);
    }
}