/*
 *  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.type;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Optional;

import org.apache.commons.lang3.StringUtils;

import org.ametys.runtime.model.ModelItem;

/**
 * Object that gives some context for data manipulation
 */
public class DataContext
{
    private Locale _locale;
    private List<String> _fullDataPath = new ArrayList<>();
    private List<String> _dataPath = new ArrayList<>();
    private Optional<String> _objectId = Optional.empty();
    private Optional<String> _rootObjectId = Optional.empty();
    private boolean _renderEmptyValues = true;
    private Optional<ModelItem> _modelItem = Optional.empty();

    /**
     * Creates a new instance of a {@link DataContext}
     */
    protected DataContext()
    {
        // Empty private constructor
    }
    
    /**
     * Creates a new instance of a {@link DataContext}
     * @return the created instance
     */
    public static DataContext newInstance()
    {
        return new DataContext();
    }
    
    /**
     * Creates a new instance of a {@link DataContext}, with the current context values
     * @return the created instance
     */
    public DataContext cloneContext()
    {
        DataContext clone = new DataContext();
        _cloneContextData(clone);
        return clone;
    }
    
    /**
     * Clone the data of the current context in the given one
     * @param context the clone
     */
    protected void _cloneContextData(DataContext context)
    {
        context.withLocale(getLocale())
            .withDataPath(getDataPath())
            .withFullDataPath(getFullDataPath())
            .withObjectId(getObjectId().orElse(null))
            .withRootObjectId(getRootObjectId().orElse(null))
            .withEmptyValues(renderEmptyValues())
            .withModelItem(getModelItem().orElse(null));
    }
    
    /**
     * Retrieves the locale to use for localized data
     * @return the locale, or null if no local has been set
     */
    public Locale getLocale()
    {
        return _locale;
    }
    
    /**
     * Sets the locale to use for localized data.
     * Do not set {@link Locale} to use all existing ones.
     * @param locale the locale to set
     * @return the current {@link DataContext}
     */
    public DataContext withLocale(Locale locale)
    {
        _locale = locale;
        return this;
    }
    
    /**
     * Retrieves the data path
     * @return the dataPath
     */
    public String getDataPath()
    {
        return StringUtils.join(_dataPath, ModelItem.ITEM_PATH_SEPARATOR);
    }
    
    /**
     * Retrieves the last segment of the data path
     * @return the last segment of the data path
     */
    public String getDataPathLastSegment()
    {
        return _dataPath.get(_dataPath.size() - 1);
    }
    
    /**
     * Sets the data path
     * @param dataPath the data path to set
     * @return the current {@link DataContext}
     */
    public DataContext withDataPath(String dataPath)
    {
        _dataPath = new ArrayList<>();
        if (StringUtils.isNotEmpty(dataPath))
        {
            _dataPath.add(dataPath);
            _fullDataPath.add(dataPath);
        }
        return this;
    }
    
    /**
     * Retrieves the full data path
     * @return the fullDataPath
     */
    public String getFullDataPath()
    {
        return StringUtils.join(_fullDataPath, ModelItem.ITEM_PATH_SEPARATOR);
    }
    
    /**
     * Sets the full data path
     * @param fullDataPath the full data path to set
     * @return the current {@link DataContext}
     */
    public DataContext withFullDataPath(String fullDataPath)
    {
        _fullDataPath = new ArrayList<>();
        if (StringUtils.isNotEmpty(fullDataPath))
        {
            _fullDataPath.add(fullDataPath);
        }
        return this;
    }
    
    /**
     * Add a segment to the data path
     * @param segment the segment to add to the data path
     * @return the current {@link DataContext}
     */
    public DataContext addSegmentToDataPath(String segment)
    {
        _dataPath.add(segment);
        _fullDataPath.add(segment);
        return this;
    }
    
    /**
     * Add a suffix to the last segment of the data path
     * @param suffix the suffix to add to the last segment
     * @return the current {@link DataContext}
     */
    public DataContext addSuffixToLastSegment(String suffix)
    {
        int segmentIndex = _dataPath.size() - 1;
        _dataPath.set(segmentIndex, _dataPath.get(segmentIndex) + suffix);
        
        segmentIndex = _fullDataPath.size() - 1;
        _fullDataPath.set(segmentIndex, _fullDataPath.get(segmentIndex) + suffix);
        
        return this;
    }
    
    /**
     * Retrieves the identifier of the object from which the data path is computed
     * @return the object identifier
     */
    public Optional<String> getObjectId()
    {
        return _objectId;
    }
    
    /**
     * Set the identifier of the object from which the data path is computed
     * @param objectId the object identifier to set
     * @return the current {@link DataContext}
     */
    public DataContext withObjectId(String objectId)
    {
        _objectId = Optional.ofNullable(objectId)
                .filter(StringUtils::isNotEmpty);
        if (_rootObjectId.isEmpty())
        {
            _rootObjectId = _objectId;
        }
        return this;
    }

    /**
     * Retrieves the identifier of the object from which the full data path is computed
     * @return the root object identifier
     */
    public Optional<String> getRootObjectId()
    {
        return _rootObjectId;
    }
    
    /**
     * Set the identifier of the object from which the full data path is computed
     * @param rootObjectId the root object identifier to set
     * @return the current {@link DataContext}
     */
    public DataContext withRootObjectId(String rootObjectId)
    {
        _rootObjectId = Optional.ofNullable(rootObjectId)
                .filter(StringUtils::isNotEmpty);
        return this;
    }
    
    /**
     * Determines if the empty values have to be rendered
     * @return <code>true</code> if empty values must be rendered (default), <code>false</code> otherwise
     */
    public boolean renderEmptyValues()
    {
        return _renderEmptyValues;
    }
    
    /**
     * Set to <code>false</code> to not render empty values (default to <code>true</code>) 
     * @param renderEmptyValues <code>true</code> to render the empty values, <code>false</code> otherwise
     * @return the current {@link DataContext}
     */
    public DataContext withEmptyValues(boolean renderEmptyValues)
    {
        _renderEmptyValues = renderEmptyValues;
        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 DataContext}
     */
    public DataContext withModelItem(ModelItem modelItem)
    {
        _modelItem = Optional.ofNullable(modelItem);
        return this;
    }
}