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

import org.apache.cocoon.xml.AttributesImpl;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Strings;
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.plugins.core.ui.help.HelpLink;
import org.ametys.runtime.i18n.I18nizableText;

/**
 * View reference to an element definition
 */
public class ViewElement implements ModelViewItem<ElementDefinition>
{
    @ExcludeFromSizeCalculation
    private ElementDefinition _definition;
    
    @ExcludeFromSizeCalculation
    private ViewItemAccessor _parent;
    
    private I18nizableText _label;
    private I18nizableText _description;
    
    private DisabledItemRendering _disabledItemRendering = DisabledItemRendering.DEFAULT;
    
    public ElementDefinition getDefinition()
    {
        return _definition;
    }

    public void setDefinition(ElementDefinition definition)
    {
        if (definition == null)
        {
            throw new IllegalArgumentException("Try to set a null definition to the view element");
        }
        _definition = definition;
    }
    
    public ViewItemAccessor getParent()
    {
        return _parent;
    }
    
    public void setParent(ViewItemAccessor parent)
    {
        _parent = parent;
    }
    
    public void setLabel(I18nizableText label)
    {
        _label = label;
    }
    
    public void setDescription(I18nizableText description)
    {
        _description = description;
    }

    @Override
    public I18nizableText getLabel()
    {
        return _label != null ? _label : getDefinition().getLabel();
    }
    
    @Override
    public I18nizableText getDescription()
    {
        return _description != null ? _description : getDefinition().getDescription();
    }
    
    public DisabledItemRendering getDisabledItemRendering()
    {
        return _disabledItemRendering;
    }
    
    public void setDisabledItemRendering(DisabledItemRendering disabledItemRendering)
    {
        _disabledItemRendering = disabledItemRendering;
    }
    
    public Map<String, Object> toJSON(DefinitionContext context)
    {
        ElementDefinition definition = getDefinition();
        if (definition != null)
        {
            Map<String, Object> result = definition.toJSON(context);
            if (!result.isEmpty())
            {
                // use overridden label and description if present
                result.put("label", getLabel());
                result.put("description", getDescription());
                
                DisabledItemRendering disabledItemRendering = getDisabledItemRendering();
                if (disabledItemRendering != DisabledItemRendering.DEFAULT)
                {
                    result.put("disabledItemRendering", disabledItemRendering.name().toLowerCase());
                }
    
                Model model = definition.getModel();
                if (model != null)
                {
                    String modelId = model.getId();
                    String family = model.getFamilyId();
                    
                    String path = definition.getPath();
                    //If there is a path, and it does not starts with '/', we add one at the beginning
                    if (StringUtils.isNotBlank(path))
                    {
                        path = Strings.CS.prependIfMissing(path, ModelItem.ITEM_PATH_SEPARATOR);
                    }
                    String featureId = StringUtils.join(modelId, path);
                    //Remove the starting '/' if present
                    featureId = Strings.CS.removeStart(featureId, ModelItem.ITEM_PATH_SEPARATOR);
        
                    HelpLink help = new HelpLink(family, featureId, null);
                    result.put("help", help);
                }
                
                return result;
            }
        }
        
        return Map.of();
    }
    
    @SuppressWarnings("static-access")
    public void toSAX(ContentHandler contentHandler, DefinitionContext context) throws SAXException
    {
        ElementDefinition definition = getDefinition();
        if (definition != null)
        {
            String tagName = context.getItemTagName().orElse(DEFAULT_ITEM_TAG_NAME);
            
            AttributesImpl attributes = new AttributesImpl();
            attributes.addCDATAAttribute("name", definition.getName());
            attributes.addCDATAAttribute("plugin", definition.getPluginName());
            attributes.addCDATAAttribute("path", definition.getPath());
            attributes.addCDATAAttribute("type", definition.getType().getId());
            attributes.addCDATAAttribute("multiple", String.valueOf(definition.isMultiple()));
            
            DisabledItemRendering disabledItemRendering = getDisabledItemRendering();
            if (disabledItemRendering != DisabledItemRendering.DEFAULT)
            {
                attributes.addCDATAAttribute("disabled", disabledItemRendering.name().toLowerCase());
            }
            
            XMLUtils.startElement(contentHandler, tagName, attributes);
            
            XMLUtils.createI18nElementIfNotNull(contentHandler, "label", getLabel());
            XMLUtils.createI18nElementIfNotNull(contentHandler, "description", getDescription());
            
            definition.toSAX(contentHandler, context);
            
            XMLUtils.endElement(contentHandler, tagName);
        }
    }
    
    public void copyTo(ViewItem item)
    {
        assert item instanceof ViewElement;
        ViewElement viewElement = (ViewElement) item;

        viewElement.setDefinition(getDefinition());
        viewElement.setLabel(getLabel());
        viewElement.setDescription(getDescription());
        
        viewElement.setDisabledItemRendering(getDisabledItemRendering());
    }
    
    public ViewElement createInstance()
    {
        return new ViewElement();
    }

    @Override
    public int hashCode()
    {
        return Objects.hash(_definition);
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj == null)
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        ViewElement other = (ViewElement) obj;
        return Objects.equals(_definition, other._definition);
    }

    @Override
    public boolean equals(Object obj, boolean checkDetails)
    {
        if (!equals(obj))
        {
            return false;
        }
        else if (checkDetails)
        {
            ViewElement other = (ViewElement) obj;
            return Objects.equals(_label, other._label) && Objects.equals(_description, other._description);
        }
        else
        {
            return true;
        }
    }
    
    @Override
    public String toString()
    {
        return _definition.toString();
    }
}