/*
 *  Copyright 2020 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.Optional;

import org.apache.commons.lang3.StringUtils;

/**
 * Object that gives some context for definitions manipulation
 */
public final class DefinitionContext
{
    private Optional<Object> _object = Optional.empty();
    private boolean _isEdition;
    private Optional<String> _itemTagName = Optional.empty();
    private Optional<ModelItem> _modelItem = Optional.empty();
    private Optional<View> _view = Optional.empty();
    private Optional<String> _conditionPrefix = Optional.empty();

    private DefinitionContext()
    {
        // Empty private constructor
    }
    
    /**
     * Creates a new instance of a {@link DefinitionContext} from another {@link DefinitionContext}
     * @param context the definition context to copy
     */
    private DefinitionContext(DefinitionContext context)
    {
        withEdition(context.isEdition());
        withObject(context.getObject().orElse(null));
        withItemTagName(context.getItemTagName().orElse(null));
        
        withModelItem(context.getModelItem().orElse(null));
        withView(context.getView().orElse(null));
        withConditionPrefix(context.getConditionPrefix().orElse(null));
    }
    
    /**
     * Creates a new instance of a {@link DefinitionContext}
     * @return the created instance
     */
    public static DefinitionContext newInstance()
    {
        return new DefinitionContext();
    }
    
    /**
     * Creates a new instance of a {@link DefinitionContext} from another {@link DefinitionContext}.
     * @param context the definition context to copy
     * @return the created instance
     */
    public static DefinitionContext newInstance(DefinitionContext context)
    {
        return new DefinitionContext(context);
    }
    
    /**
     * Creates a new instance of a {@link DefinitionContext}, with the current context values
     * @return the created instance
     */
    public DefinitionContext cloneContext()
    {
        return newInstance(this);
    }
    
    /**
     * Retrieves the context object for the definition
     * @return the context object
     */
    public Optional<Object> getObject()
    {
        return _object;
    }
    
    /**
     * Set the context object
     * @param object the context object to set
     * @return the current {@link DefinitionContext}
     */
    public DefinitionContext withObject(Object object)
    {
        _object = Optional.ofNullable(object);
        return this;
    }
    
    /**
     * Checks if the context is in edition
     * @return <code>true</code> if the context is in edition, <code>false</code> otherwise
     */
    public boolean isEdition()
    {
        return _isEdition;
    }
    
    /**
     * Set to <code>true</code> if the context is in edition (default to <code>false</code>)
     * @param isEdition <code>true</code> if the context is in edition, <code>false</code> otherwise
     * @return the current {@link DefinitionContext}
     */
    public DefinitionContext withEdition(boolean isEdition)
    {
        _isEdition = isEdition;
        return this;
    }
    
    /**
     * Retrieves the tag name to use while generating SAX events
     * @return the tag name to use while generating SAX events
     */
    public Optional<String> getItemTagName()
    {
        return _itemTagName;
    }
    
    /**
     * Set the tag name to use while generating SAX events
     * @param itemTagName the tag name to set
     * @return the current {@link DefinitionContext}
     */
    public DefinitionContext withItemTagName(String itemTagName)
    {
        _itemTagName = Optional.ofNullable(itemTagName)
                               .filter(StringUtils::isNotEmpty);
        return this;
    }
    
    /**
     * Retrieves the model item
     * @return the model item
     */
    public Optional<ModelItem> getModelItem()
    {
        return _modelItem;
    }
    
    /**
     * Sets the model item
     * @param modelItem the model item to set
     * @return the current {@link DefinitionContext}
     */
    public DefinitionContext withModelItem(ModelItem modelItem)
    {
        _modelItem = Optional.ofNullable(modelItem);
        return this;
    }
    
    /**
     * Retrieves the view
     * @return the view
     */
    public Optional<View> getView()
    {
        return _view;
    }
    
    /**
     * Set the view
     * @param view the view to set
     * @return the current {@link DefinitionContext}
     */
    public DefinitionContext withView(View view)
    {
        _view = Optional.ofNullable(view);
        return this;
    }
    
    /**
     * Get the disable condition prefix
     * @return the disable condition prefix
     */
    public Optional<String> getConditionPrefix()
    {
        return _conditionPrefix;
    }
    
    /**
     * Set the disable condition prefix
     * @param conditionPrefix the disable condition prefix to set
     * @return the current {@link DefinitionContext}
     */
    public DefinitionContext withConditionPrefix(String conditionPrefix)
    {
        _conditionPrefix = Optional.ofNullable(conditionPrefix);
        return this;
    }
}