/*
 *  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.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.SizeUtils.ExcludeFromSizeCalculation;
import org.ametys.core.util.XMLUtils;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.exception.BadItemTypeException;

/**
 * View reference to a group of model items 
 */
public class ModelViewItemGroup extends AbstractViewItemGroup implements ModelViewItem<ModelItemGroup>
{
    @ExcludeFromSizeCalculation
    private ModelItemGroup _definition;
    
    /**
     * Creates a {@link ModelViewItemGroup} with the items of the given {@link ModelItemGroup}
     * @param modelItem the model item group
     * @return the created {@link ModelViewItemGroup}
     * @throws IllegalArgumentException if the model item is <code>null</code>
     */
    public static ModelViewItemGroup of(ModelItemGroup modelItem) throws IllegalArgumentException
    {
        if (modelItem == null)
        {
            throw new IllegalArgumentException("Unable to create the view from a null model");
        }
        else
        {
            return ViewHelper.createViewItemAccessor(List.of(modelItem));
        }
    }
    
    /**
     * Creates a {@link ModelViewItemGroup} with the given items
     * @param modelItem the model item containing items definitions
     * @param itemPaths the paths of the items to put in the view item
     * @return the created {@link ModelViewItemGroup}
     * @throws IllegalArgumentException if the model item is <code>null</code> or if an item path is <code>null</code>, empty, or is not defined in the given model items
     * @throws BadItemTypeException if a segment in a path (but not the last) does not represent a group item
     */
    public static ModelViewItemGroup of(ModelItemGroup modelItem, String... itemPaths) throws IllegalArgumentException, BadItemTypeException
    {
        if (modelItem == null)
        {
            throw new IllegalArgumentException("Unable to create the view from a null model");
        }
        else
        {
            return ViewHelper.createViewItemAccessor(List.of(modelItem), itemPaths);
        }
    }
    
    public ModelItemGroup getDefinition()
    {
        return _definition;
    }
    
    public void setDefinition(ModelItemGroup definition)
    {
        if (definition == null)
        {
            throw new IllegalArgumentException("Try to set a null definition to the model view item group");
        }
        
        _definition = definition;
    }
    
    public String getName()
    {
        if (_definition != null)
        {
            return _definition.getName();
        }
        else
        {
            return null;
        }
    }
    
    @Override
    public I18nizableText getLabel()
    {
        I18nizableText label = super.getLabel();
        if (label != null)
        {
            return label;
        }
        
        return getDefinition().getLabel();
    }
    
    @Override
    public I18nizableText getDescription()
    {
        I18nizableText desc = super.getDescription();
        if (desc != null)
        {
            return desc;
        }
        
        return getDefinition().getDescription();
    }
    
    public Map<String, Object> toJSON(DefinitionContext context) throws ProcessingException
    {
        ModelItemGroup definition = getDefinition();
        if (definition != null)
        {
            Map<String, Object> result = definition.toJSON(context, false);
            
            // use overridden label and description if present  
            result.put("label", getLabel());
            result.put("description", getDescription());
            result.put("role", getRole());
            
            if (StringUtils.isEmpty(getName()))
            {
                result.put("unnamed-group", true);
            }
            
            List<ViewItem> viewItems = _getChildrenWithoutSwitcher();
            if (!viewItems.isEmpty())
            {
                result.put("elements", ViewHelper.viewItemsToJSON(viewItems, context));
            }
            
            return result;
        }
        
        return Map.of();
    }
    
    @SuppressWarnings("static-access")
    public void toSAX(ContentHandler contentHandler, DefinitionContext context) throws SAXException
    {
        ModelItemGroup definition = getDefinition();
        if (definition != null)
        {
            AttributesImpl attributes = new AttributesImpl();
            attributes.addCDATAAttribute("name", definition.getName());
            attributes.addCDATAAttribute("plugin", definition.getPluginName());
            attributes.addCDATAAttribute("path", definition.getPath());
            
            String typeId = definition.getType() != null ? definition.getType().getId() : ModelItemGroup.DEFAULT_TYPE_ID;
            attributes.addCDATAAttribute("type", typeId);
            
            XMLUtils.startElement(contentHandler, "metadata", attributes);
            
            XMLUtils.createElementIfNotNull(contentHandler, "role", getRole());
            XMLUtils.createI18nElementIfNotNull(contentHandler, "label", getLabel());
            XMLUtils.createI18nElementIfNotNull(contentHandler, "description", getDescription());
            
            definition.toSAX(contentHandler, context);
            
            for (ViewItem viewItem : _getChildrenWithoutSwitcher())
            {
                viewItem.toSAX(contentHandler, context);
            }
            
            XMLUtils.endElement(contentHandler, "metadata");
        }
    }
    
    private List<ViewItem> _getChildrenWithoutSwitcher()
    {
        ElementDefinition switcher = getDefinition().getSwitcher();
        if (switcher == null)
        {
            return getViewItems();
        }
        
        List<ViewItem> childrenWithoutSwitcher = new ArrayList<>();
        for (ViewItem child : getViewItems())
        {
            if (child instanceof ViewElement)
            {
                ElementDefinition childDefinitonReference = ((ViewElement) child).getDefinition();
                if (!switcher.equals(childDefinitonReference))
                {
                    childrenWithoutSwitcher.add(child);
                }
            }
        }
        
        return childrenWithoutSwitcher;
    }
    
    @Override
    public void copyTo(ViewItem item)
    {
        super.copyTo(item);
        
        assert item instanceof ModelViewItemGroup;
        ((ModelViewItemGroup) item).setDefinition(getDefinition());
    }
    
    public ModelViewItemGroup createInstance()
    {
        return new ModelViewItemGroup();
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = super.hashCode();
        result = prime * result + Objects.hash(_definition);
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (!super.equals(obj))
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        ModelViewItemGroup other = (ModelViewItemGroup) obj;
        return Objects.equals(_definition, other._definition);
    }
    
    @Override
    public String toString()
    {
        return _definition.toString() + ": " + _children.toString();
    }
}