/*
 *  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 java.util.Objects;

import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.xml.AttributesImpl;
import org.apache.commons.lang3.StringUtils;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.core.util.XMLUtils;
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.createViewItemAccessor(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<? extends Model> models) throws IllegalArgumentException
    {
        return ViewHelper.createViewItemAccessor(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.createViewItemAccessor(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<? extends Model> models, String... itemPaths) throws IllegalArgumentException, BadItemTypeException
    {
        return ViewHelper.createViewItemAccessor(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;
    }
    
    /**
     * Copy the current view in the given one.
     * Its view items are not copied
     * @param view the copy
     */
    public void copyTo(View view)
    {
        view.setName(getName());
        view.setLabel(getLabel());
        view.setDescription(getDescription());
        view.setInternal(isInternal());
        
        view.setIconGlyph(getIconGlyph());
        view.setIconDecorator(getIconDecorator());
        view.setSmallIcon(getSmallIcon());
        view.setMediumIcon(getMediumIcon());
        view.setLargeIcon(getLargeIcon());
    }

    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 setInternal(boolean isInternal)
    {
        _isInternal = isInternal;
    }
    
    public List<ViewItem> getViewItems()
    {
        return Collections.unmodifiableList(this._items);
    }
    
    public void addViewItem(ViewItem item)
    {
        _items.add(item);
        item.setParent(this);
    }
    
    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.");
        }
    }
    
    public boolean removeViewItem(ViewItem item)
    {
        return _items.remove(item);
    }
    
    public void clear()
    {
        _items.clear();
    }

    /**
     * Converts the view in a JSON map
     * @param context the context of the definitions included in the view
     * @return The view as a JSON map
     * @throws ProcessingException If an error occurs when converting the view
     */
    public Map<String, Object> toJSON(DefinitionContext context) throws ProcessingException
    {
        Map<String, Object> result = new LinkedHashMap<>();
        
        result.put("name", getName());
        result.put("internal", isInternal());
        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());
    
        result.put("elements", ViewHelper.viewItemsToJSON(getViewItems(), context));
        
        return result;
    }

    /**
     * Generates SAX events for the view
     * @param contentHandler the {@link ContentHandler} that will receive the SAX events 
     * @param context the context of the definitions included in the view
     * @throws SAXException if an error occurs during the SAX events generation
     */
    @SuppressWarnings("static-access")
    public void toSAX(ContentHandler contentHandler, DefinitionContext context) throws SAXException
    {
        AttributesImpl attributes = new AttributesImpl();
        attributes.addCDATAAttribute("name", getName());
        attributes.addCDATAAttribute("internal", String.valueOf(isInternal()));
        
        XMLUtils.startElement(contentHandler, "view", attributes);
        
        XMLUtils.createI18nElementIfNotNull(contentHandler, "label", getLabel());
        XMLUtils.createI18nElementIfNotNull(contentHandler, "description", getDescription());
        
        XMLUtils.startElement(contentHandler, "icons");
        XMLUtils.createElementIfNotNull(contentHandler, "icon-glyph", getIconGlyph());
        XMLUtils.createElementIfNotNull(contentHandler, "icon-decorator", getIconDecorator());
        XMLUtils.createElementIfNotNull(contentHandler, "small-icon-path", getSmallIcon());
        XMLUtils.createElementIfNotNull(contentHandler, "medium-icon-path", getMediumIcon());
        XMLUtils.createElementIfNotNull(contentHandler, "large-icon-path", getLargeIcon());
        XMLUtils.endElement(contentHandler, "icons");
    
        for (ViewItem viewItem : getViewItems())
        {
            viewItem.toSAX(contentHandler, context);
        }

        XMLUtils.endElement(contentHandler, "view");
    }
    
    /**
     * 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)
    {
        View referenceView = new View();
        referenceView.addViewItems(getViewItems());
        ViewHelper.addViewAccessorItems(this, viewToInclude, referenceView, StringUtils.EMPTY);
    }

    @Override
    public int hashCode()
    {
        return Objects.hash(_items, _name);
    }
    
    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj == null)
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        View other = (View) obj;
        return Objects.equals(_items, other._items) && Objects.equals(_name, other._name);
    }

    /**
     * Indicates whether some other object is "equal to" this one.
     * @param obj the reference object with which to compare.
     * @param checkDetails <code>true</code> to check the view's details during comparison (label, description, icon, ...)
     * @return <code>true</code> if this object is the same as the given obj, <code>false</code> otherwise.
     */
    public boolean equals(Object obj, boolean checkDetails)
    {
        if (!equals(obj))
        {
            return false;
        }
        else if (checkDetails)
        {
            View other = (View) obj;
            
            for (int i = 0; i < _items.size(); i++)
            {
                ViewItem item = _items.get(i);
                ViewItem otherItem = other._items.get(i);
                
                if (!item.equals(otherItem, checkDetails))
                {
                    return false;
                }
            }
            
            return Objects.equals(_description, other._description) && Objects.equals(_iconDecorator, other._iconDecorator) && Objects.equals(_iconGlyph, other._iconGlyph)
                    && _isInternal == other._isInternal && Objects.equals(_label, other._label);
        }
        else
        {
            return true;
        }
    }
}