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

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.xml.AttributesImpl;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.core.model.ModelItemHelper;
import org.ametys.core.util.XMLUtils;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.checker.ItemCheckerDescriptor;
import org.ametys.runtime.model.disableconditions.DisableCondition;
import org.ametys.runtime.model.disableconditions.DisableConditions;

/**
 * Abstract class for model items
 */
public abstract class AbstractModelItem implements ModelItem
{
    /** The service manager */
    protected static ServiceManager __serviceManager;
    
    /** The cocoon context */
    protected static Context __context;
    
    private ModelItemHelper _modelItemHelper;
    
    private String _name;
    private String _pluginName;
    private I18nizableText _label;
    private I18nizableText _description;
    private Set<ItemCheckerDescriptor> _itemCheckers = new HashSet<>();
    private String _widget;
    private Map<String, I18nizableText> _widgetParams = new HashMap<>();
    private DisableConditions _disableConditions;

    private Model _model;
    private ModelItemGroup _parent;
    
    private String _path;

    /**
     * Default constructor.
     */
    public AbstractModelItem()
    {
        // Empty constructor
    }
    
    /**
     * Constructor used to create simple models and items 
     * @param name the name of the item
     */
    public AbstractModelItem(String name)
    {
        _name = name;
    }

    /**
     * Constructor by copying an existing {@link AbstractModelItem}.
     * @param modelItemToCopy The {@link AbstractModelItem} to copy
     */
    public AbstractModelItem(ModelItem modelItemToCopy)
    {
        setName(modelItemToCopy.getName());
        setPluginName(modelItemToCopy.getPluginName());
        setLabel(modelItemToCopy.getLabel());
        setDescription(modelItemToCopy.getDescription());
        for (ItemCheckerDescriptor itemChecker : modelItemToCopy.getItemCheckers())
        {
            addItemChecker(itemChecker);
        }
        setModel(modelItemToCopy.getModel());
        setParent(modelItemToCopy.getParent());
        
        // Widget
        setWidget(modelItemToCopy.getWidget());
        setWidgetParameters(modelItemToCopy.getWidgetParameters());
        
        setDisableConditions(modelItemToCopy.getDisableConditions());
    }
    
    public String getName()
    {
        return _name;
    }
    
    public void setName(String name)
    {
        _name = name;
        _path = null;
    }
    
    public String getPluginName()
    {
        return _pluginName;
    }

    public void setPluginName(String pluginName)
    {
        _pluginName = pluginName;
    }
    
    public I18nizableText getLabel()
    {
        return _label;
    }

    public void setLabel(I18nizableText label)
    {
        _label = label;
    }

    public I18nizableText getDescription()
    {
        return _description;
    }

    public void setDescription(I18nizableText description)
    {
        _description = description;
    }
    
    public void addItemChecker(ItemCheckerDescriptor itemChecker)
    {
        _itemCheckers.add(itemChecker);
    }
    
    public Set<ItemCheckerDescriptor> getItemCheckers()
    {
        return Collections.unmodifiableSet(_itemCheckers);
    }
    

    public String getWidget()
    {
        return _widget;
    }

    public void setWidget(String widget)
    {
        _widget = widget;
    }
    
    public Map<String, I18nizableText> getWidgetParameters()
    {
        return _widgetParams;
    }
    
    public void setWidgetParameters (Map<String, I18nizableText> params)
    {
        _widgetParams = params;
    }
    
    public DisableConditions getDisableConditions()
    {
        return _disableConditions;
    }

    public void setDisableConditions(DisableConditions disableConditions)
    {
        _disableConditions = disableConditions;
    }

    public String getPath()
    {
        if (_path != null)
        {
            return _path;
        }
        
        if (getName() == null)
        {
            return null;
        }
        
        StringBuilder path = new StringBuilder();
        
        ModelItemGroup parent = getParent();
        if (parent != null && parent.getPath() != null)
        {
            path.append(parent.getPath()).append(ITEM_PATH_SEPARATOR);
        }
        
        path.append(getName());
        _path =  path.toString();
        return _path;
    }

    public Model getModel()
    {
        return _model;
    }
    
    public void setModel(Model model)
    {
        _model = model;
    }

    public ModelItemGroup getParent()
    {
        return _parent;
    }
    
    public void setParent(ModelItemGroup parent)
    {
        _parent = parent;
    }
    
    public Map<String, Object> toJSON(DefinitionContext context)
    {
        if (_shouldJSONBeEmpty(context))
        {
            return Map.of();
        }
        else
        {
            return _toJSON(context);
        }
    }
    
    /**
     * Converts the model item in a JSON map
     * @param context the context of the definition
     * @return The model item as a JSON map
     */
    protected Map<String, Object> _toJSON(DefinitionContext context)
    {
        Map<String, Object> result = new HashMap<>();
        
        DefinitionContext newContext = context.cloneContext()
                                              .withModelItem(this);
        
        result.put("name", getName());
        result.put("plugin", getPluginName());
        result.put("label", getLabel());
        result.put("description", getDescription());
        result.put("path", getPath());
        
        if (!getItemCheckers().isEmpty())
        {
            List<Map<String, Object>> checkers2json = new ArrayList<>();
            for (ItemCheckerDescriptor paramChecker : getItemCheckers())
            {
                checkers2json.add(paramChecker.toJSON());
            }
            
            result.put("field-checker", checkers2json);
        }
        
        result.putAll(_widgetToJSON(newContext));
        
        if (ModelHelper.hasDisableConditions(this))
        {
            result.put("disableCondition", disableConditionsToJSON(newContext));
        }
        
        return result;
    }
    
    /**
     * Converts the model item's widget in a JSON map
     * @param context the context of the definition
     * @return The model item's widget as a JSON map
     */
    protected Map<String, Object> _widgetToJSON(DefinitionContext context)
    {
        Map<String, Object> result = new HashMap<>();
        
        result.put("widget", getWidget());
        
        Map<String, I18nizableText> widgetParameters = getWidgetParameters();
        if (widgetParameters != null && !widgetParameters.isEmpty())
        {
            result.put("widget-params", widgetParameters);
        }
        
        return result;
    }
    
    /**
     * Converts the definition's disable conditions in a JSON map
     * @param context the definition context
     * @return The definition's disable conditions as a JSON map
     */
    protected Map<String, Object> disableConditionsToJSON(DefinitionContext context)
    {
        return _getModelItemHelper().disableConditionsToJSON(this, context);
    }

    /**
     * Checks if the current definition JSON conversion should return an empty map
     * @param context the context of the definition
     * @return <code>true</code> if the JSON conversion should return an empty map, <code>false</code> otherwise
     */
    protected boolean _shouldJSONBeEmpty(DefinitionContext context)
    {
        return false;
    }
    
    @SuppressWarnings("static-access")
    public void toSAX(ContentHandler contentHandler, DefinitionContext context) throws SAXException
    {
        if (!getItemCheckers().isEmpty())
        {
            for (ItemCheckerDescriptor paramChecker : getItemCheckers())
            {
                XMLUtils.startElement(contentHandler, "field-checker");
                paramChecker.toSAX(contentHandler);
                XMLUtils.endElement(contentHandler, "field-checker");
            }
        }
        
        _widgetToSAX(contentHandler, context);

        if (getDisableConditions() != null)
        {
            _disableConditionsToSAX(contentHandler, getDisableConditions());
        }
    }

    /**
     * Generates SAX events for the model item's widget
     * @param contentHandler the {@link ContentHandler} that will receive the SAX events 
     * @param context the context of the definition
     * @throws SAXException if an error occurs during the SAX events generation
     */
    @SuppressWarnings("static-access")
    protected void _widgetToSAX(ContentHandler contentHandler, DefinitionContext context) throws SAXException
    {
        XMLUtils.createElementIfNotNull(contentHandler, "widget", getWidget());
        
        Map<String, I18nizableText> widgetParameters = getWidgetParameters();
        if (widgetParameters != null && !widgetParameters.isEmpty())
        {
            XMLUtils.startElement(contentHandler, "widget-params");
            
            for (Map.Entry<String, I18nizableText> param : widgetParameters.entrySet())
            {
                _widgetParameterToSAX(contentHandler, param.getKey(), param.getValue(), context);
            }
            
            XMLUtils.endElement(contentHandler, "widget-params");
        }
    }

    /**
     * Generates SAX events for the given widget parameter
     * @param contentHandler the {@link ContentHandler} that will receive the SAX events 
     * @param parameterName the name of the parameter
     * @param parameterValue the value of the parameter
     * @param context the context of the definition
     * @throws SAXException if an error occurs during the SAX events generation
     */
    @SuppressWarnings("static-access")
    protected void _widgetParameterToSAX(ContentHandler contentHandler, String parameterName, I18nizableText parameterValue, DefinitionContext context) throws SAXException
    {
        AttributesImpl paramAttributes = new AttributesImpl();
        paramAttributes.addCDATAAttribute("name", parameterName);

        XMLUtils.startElement(contentHandler, "param", paramAttributes);
        parameterValue.toSAX(contentHandler);
        XMLUtils.endElement(contentHandler, "param");
    }
    
    @SuppressWarnings("static-access")
    private void _disableConditionsToSAX(ContentHandler contentHandler, DisableConditions disableConditions) throws SAXException
    {
        AttributesImpl attributes = new AttributesImpl();
        attributes.addCDATAAttribute("type", disableConditions.getAssociationType().toString().toLowerCase());
        XMLUtils.startElement(contentHandler, "disable-conditions", attributes);
        
        // Handle simple conditions
        XMLUtils.startElement(contentHandler, "conditions");
        for (DisableCondition disableCondition : disableConditions.getConditions())
        {
            _disableConditionToSAX(contentHandler, disableCondition);
        }
        XMLUtils.endElement(contentHandler, "conditions");

        // Handle nested conditions
        XMLUtils.startElement(contentHandler, "nested-conditions");
        for (DisableConditions subDisableConditions : disableConditions.getSubConditions())
        {
            _disableConditionsToSAX(contentHandler, subDisableConditions);
        }
        XMLUtils.endElement(contentHandler, "nested-conditions");
        
        XMLUtils.endElement(contentHandler, "disable-conditions");
    }
    
    @SuppressWarnings("static-access")
    private void _disableConditionToSAX(ContentHandler contentHandler, DisableCondition disableCondition) throws SAXException
    {
        AttributesImpl attributes = new AttributesImpl();
        attributes.addCDATAAttribute("id", disableCondition.getName());
        attributes.addCDATAAttribute("operator", disableCondition.getOperator().toString().toLowerCase());
        
        XMLUtils.createElement(contentHandler, "condition", attributes, disableCondition.getValue());
    }
    
    public int compareTo(ModelItem item)
    {
        if (item == null)
        {
            return 1;
        }
        
        String name = getName();
        if (name != null)
        {
            return name.compareTo(item.getName());
        }
        
        I18nizableText label = getLabel();
        if (label != null)
        {
            I18nizableText otherLabel = item.getLabel();
            if (otherLabel == null)
            {
                return 1;
            }
            
            return label.toString().compareTo(otherLabel.toString());
        }
        
        return 0;
    }
    
    @Override
    public boolean equals(Object obj)
    {
        if (obj == null || !getClass().equals(obj.getClass()))
        {
            return false;
        }
        
        ModelItem item = (ModelItem) obj;
        
        // The item's model can be null
        if (getModel() != item.getModel())
        {
            if (getModel() == null ^ item.getModel() == null)
            {
                return false;
            }
            
            if (!Objects.equals(getModel().getFamilyId(), item.getModel().getFamilyId()) || !Objects.equals(getModel().getId(), item.getModel().getId()))
            {
                return false;
            }
        }
        
        if (getPath() != null || item.getPath() != null)
        {
            return Objects.equals(getPath(), item.getPath());
        }
        
        if (getLabel() != null || item.getLabel() != null)
        {
            return Objects.equals(getLabel(), item.getLabel());
        }
        
        return false;
    }

    @Override
    public int hashCode()
    {
        if (getPath() != null)
        {
            return getPath().hashCode();
        }
        
        return getLabel().hashCode();
    }
    
    @Override
    public String toString()
    {
        if (getPath() != null)
        {
            return getPath();
        }
        
        return getLabel().toString();
    }
    
    /**
     * Retrieves the {@link ModelItemHelper} 
     * @return the {@link ModelItemHelper}
     */
    protected ModelItemHelper _getModelItemHelper()
    {
        if (_modelItemHelper == null)
        {
            try
            {
                _modelItemHelper = (ModelItemHelper) __serviceManager.lookup(ModelItemHelper.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException("Unable to lookup after the model item helper", e);
            }
        }
        
        return _modelItemHelper;
    }
    
    /**
     * Set the service manager
     * The {@link ServiceManager} is used in the model items creation methods to get the model item type.
     * {@link ModelItem} is not a {@link Component} and can't have a {@link ServiceManager} itself. Another {@link Component} has to set it
     * @param manager the service manager to set
     */
    public static void setServiceManager(ServiceManager manager)
    {
        __serviceManager = manager;
    }
    
    /**
     * Set the cocoon context
     * {@link ModelItem} is not a {@link Component} and can't have a {@link Context} itself. Another {@link Component} has to set it
     * @param context the cocoon context to set
     */
    public static void setContext(Context context)
    {
        __context = context;
    }
}