/*
 *  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.service.ServiceManager;
import org.apache.cocoon.ProcessingException;

import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.checker.ItemCheckerDescriptor;

/**
 * Abstract class for model items
 */
public abstract class AbstractModelItem implements ModelItem
{
    /** The service manager */
    protected static ServiceManager __serviceManager;
    
    private String _name;
    private I18nizableText _label;
    private I18nizableText _description;
    private Set<ItemCheckerDescriptor> _itemCheckers = new HashSet<>();
    
    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(AbstractModelItem modelItemToCopy)
    {
        setName(modelItemToCopy.getName());
        setLabel(modelItemToCopy.getLabel());
        setDescription(modelItemToCopy.getDescription());
        for (ItemCheckerDescriptor itemChecker : modelItemToCopy.getItemCheckers())
        {
            addItemChecker(itemChecker);
        }
        setModel(modelItemToCopy.getModel());
        setParent(modelItemToCopy.getParent());
    }
    
    public String getName()
    {
        return _name;
    }
    
    public void setName(String name)
    {
        _name = name;
        _path = null;
    }
    
    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 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) throws ProcessingException
    {
        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
     * @throws ProcessingException If an error occurs when converting the model item
     */
    protected Map<String, Object> _toJSON(DefinitionContext context) throws ProcessingException
    {
        Map<String, Object> result = new HashMap<>();
        
        result.put("name", getName());
        result.put("label", getLabel());
        result.put("description", getDescription());
        
        if (!getItemCheckers().isEmpty())
        {
            List<Map<String, Object>> checkers2json = new ArrayList<>();
            for (ItemCheckerDescriptor paramChecker : getItemCheckers())
            {
                checkers2json.add(paramChecker.toJSON());
            }
            
            result.put("field-checker", checkers2json);
        }
        
        return result;
    }
    
    /**
     * 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;
    }
    
    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();
    }
    
    /**
     * 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;
    }
}