/*
 *  Copyright 2019 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.cms.data;

import java.util.Collection;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;

import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.commons.collections4.CollectionUtils;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.data.type.BaseContentElementType;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.data.external.ExternalizableDataProvider.ExternalizableDataStatus;
import org.ametys.plugins.repository.data.holder.ModifiableDataHolder;
import org.ametys.plugins.repository.data.holder.ModifiableModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.ModifiableModelAwareComposite;
import org.ametys.plugins.repository.data.holder.group.ModifiableRepeater;
import org.ametys.plugins.repository.data.holder.values.SynchronizationContext;
import org.ametys.plugins.repository.data.holder.values.SynchronizationResult;
import org.ametys.plugins.repository.data.repositorydata.ModifiableRepositoryData;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelItemContainer;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.model.exception.BadDataPathCardinalityException;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ModelItemType;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.JsonIdentityReference;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;

/**
 * Content wrapper used by attributes of type content
 * @see BaseContentElementType
 */
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "contentId")
@JsonIdentityReference(alwaysAsId = true)
public class ContentValue implements ModifiableModelAwareDataHolder
{
    private AmetysObjectResolver _resolver;
    private String _contentId;
    private ModifiableContent _content;
    private Session _session;

    /**
     * Constructor of the content wrapper
     * @param content the existing content
     */
    public ContentValue(ModifiableContent content)
    {
        _content = content;
        _contentId = content.getId();
    }
    
    /**
     * Constructor of the content wrapper
     * @param resolver resolver used to get the content from its identifier
     * @param contentId content identifier
     */
    public ContentValue(AmetysObjectResolver resolver, String contentId)
    {
        this(resolver, contentId, null);
    }

    /**
     * Constructor of the content wrapper
     * @param resolver resolver used to get the content from its identifier
     * @param contentId content identifier
     * @param session the current session. If <code>null</code>, a new session will be used to retrieve the content
     */
    public ContentValue(AmetysObjectResolver resolver, String contentId, Session session)
    {
        _resolver = resolver;
        _contentId = contentId;
        _session = session;
    }
    
    /**
     * Retrieves the content's identifier
     * @return the content's identifier
     */
    public String getContentId()
    {
        return _contentId;
    }
    
    /**
     * Retrieves the content
     * @return the content
     * @throws AmetysRepositoryException if an error occurs.
     * @throws UnknownAmetysObjectException if no content exists for the identifier
     */
    public ModifiableContent getContent() throws AmetysRepositoryException, UnknownAmetysObjectException
    {
        if (_content == null)
        {
            if (_session != null)
            {
                try
                {
                    _content = _resolver.resolveById(_contentId, _session);
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException("Unable to retrieve the content with the id '" + _contentId + "'.", e);
                }
            }
            else
            {
                _content = _resolver.resolveById(_contentId);
            }
        }
        
        return _content;
    }
    
    /**
     * Retrieves an {@link Optional} describing the content, or an empty {@link Optional} if the content does not exist
     * @return an {@link Optional} describing the content
     */
    public Optional<ModifiableContent> getContentIfExists()
    {
        try
        {
            return Optional.ofNullable(getContent());
        }
        catch (AmetysRepositoryException e)
        {
            return Optional.empty();
        }
    }
    
    @Override
    public int hashCode()
    {
        return Objects.hash(_contentId);
    }

    @Override
    public boolean equals(Object obj)
    {
        if (!(obj instanceof ContentValue))
        {
            return false;
        }
        
        return Objects.equals(_contentId, ((ContentValue) obj)._contentId);
    }

    public boolean hasValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.hasValue(dataPath))
                .orElse(false);
    }
    
    public boolean hasValue(String dataPath, String dataTypeId) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.hasValue(dataPath, dataTypeId))
                .orElse(false);
    }
    
    public boolean hasLocalValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.hasLocalValue(dataPath))
                .orElse(false);
    }
    
    public boolean hasExternalValue(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.hasExternalValue(dataPath))
                .orElse(false);
    }

    public boolean hasValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.hasValueOrEmpty(dataPath))
                .orElse(false);
    }
    
    public boolean hasLocalValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.hasLocalValueOrEmpty(dataPath))
                .orElse(false);
    }
    
    public boolean hasExternalValueOrEmpty(String dataPath) throws IllegalArgumentException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.hasExternalValueOrEmpty(dataPath))
                .orElse(false);
    }
    
    public Collection<String> getDataNames()
    {
        return getContentIfExists()
                .map(c -> c.getDataNames())
                .orElse(CollectionUtils.EMPTY_COLLECTION);
    }
    
    public <T> T getValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.<T>getValue(dataPath))
                .orElse(null);
    }
    
    public <T> T getLocalValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.<T>getLocalValue(dataPath))
                .orElse(null);
    }
    
    public <T> T getExternalValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.<T>getExternalValue(dataPath))
                .orElse(null);
    }

    public <T> T getValueOrDefault(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.<T>getValueOrDefault(dataPath))
                .orElse(null);
    }
    
    public <T> T getValueOrDefault(String dataPath, T defaultValue) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.<T>getValueOrDefault(dataPath, defaultValue))
                .orElse(defaultValue);
    }
    
    public <T> T getValueOfType(String dataPath, String dataTypeId) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.<T>getValueOfType(dataPath, dataTypeId))
                .orElse(null);
    }
    
    public <T> T getValueOfTypeOrDefault(String dataPath, String dataTypeId, T defaultValue) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.<T>getValueOfTypeOrDefault(dataPath, dataTypeId, defaultValue))
                .orElse(defaultValue);
    }

    public <T> T getValueWithMultiValuedPathSegments(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.<T>getValueWithMultiValuedPathSegments(dataPath))
                .orElse(null);
    }
    
    public ExternalizableDataStatus getStatus(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getStatus(dataPath))
                .orElse(ExternalizableDataStatus.LOCAL);
    }
    
    public boolean isMultiple(String dataPath) throws IllegalArgumentException, UndefinedItemPathException
    {
        return getContentIfExists()
                .map(c -> c.isMultiple(dataPath))
                .orElse(false);
    }
    
    public boolean isMultiple(String dataPath, String dataTypeId) throws IllegalArgumentException, UndefinedItemPathException
    {
        return getContentIfExists()
                .map(c -> c.isMultiple(dataPath, dataTypeId))
                .orElse(false);
    }
    
    public <X extends ModelItemType> X getType(String dataPath) throws IllegalArgumentException, UndefinedItemPathException
    {
        return getContentIfExists()
                .map(c -> c.<X>getType(dataPath))
                .orElse(null);
    }
    
    public Collection< ? extends ModelItemContainer> getModel()
    {
        return getContentIfExists()
                .map(c -> c.getModel())
                .orElse(null);
    }

    public ModelItem getDefinition(String path) throws IllegalArgumentException, UndefinedItemPathException
    {
        return getContentIfExists()
                .map(c -> c.getDefinition(path))
                .orElse(null);
    }
    
    public boolean hasDefinition(String path) throws IllegalArgumentException
    {
        return getContentIfExists()
                .map(c -> c.hasDefinition(path))
                .orElse(null);
    }

    public ModifiableModelAwareComposite getComposite(String compositePath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getComposite(compositePath))
                .orElse(null);
    }
    
    public ModifiableModelAwareComposite getLocalComposite(String compositePath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getLocalComposite(compositePath))
                .orElse(null);
    }
    
    public ModifiableModelAwareComposite getExternalComposite(String compositePath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getExternalComposite(compositePath))
                .orElse(null);
    }

    public ModifiableRepeater getRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getRepeater(repeaterPath))
                .orElse(null);
    }
    
    public ModifiableRepeater getLocalRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getLocalRepeater(repeaterPath))
                .orElse(null);
    }
    
    public ModifiableRepeater getExternalRepeater(String repeaterPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getExternalRepeater(repeaterPath))
                .orElse(null);
    }
    
    public void copyTo(ModifiableDataHolder dataHolder) throws BadItemTypeException, UndefinedItemPathException
    {
        getContent().copyTo(dataHolder);
    }
    
    public void copyTo(ModifiableDataHolder dataHolder, DataContext context) throws BadItemTypeException, UndefinedItemPathException
    {
        getContent().copyTo(dataHolder, context);
    }

    public void dataToSAX(ContentHandler contentHandler, String dataPath, DataContext context) throws SAXException, BadItemTypeException, UndefinedItemPathException
    {
        getContent().dataToSAX(contentHandler, dataPath, context);
    }
    
    public void dataToSAX(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException
    {
        getContent().dataToSAX(contentHandler, viewItemAccessor, context);
    }
    
    public void dataToSAXForEdition(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context) throws SAXException, BadItemTypeException
    {
        getContent().dataToSAXForEdition(contentHandler, viewItemAccessor, context);
    }
    
    public Object dataToJSON(String dataPath, DataContext context) throws BadItemTypeException, UndefinedItemPathException
    {
        return getContent().dataToJSON(dataPath, context);
    }
    
    public Map<String, Object> dataToJSON(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        return getContent().dataToJSON(viewItemAccessor, context);
    }
    
    public Map<String, Object> dataToJSONForEdition(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        return getContent().dataToJSONForEdition(viewItemAccessor, context);
    }
    
    public Map<String, Object> dataToMap(ViewItemAccessor viewItemAccessor, DataContext context) throws BadItemTypeException
    {
        return getContent().dataToMap(viewItemAccessor, context);
    }
    
    public boolean hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws BadItemTypeException
    {
        return getContent().hasDifferences(viewItemAccessor, values);
    }
    
    public boolean hasDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException
    {
        return getContent().hasDifferences(viewItemAccessor, values, context);
    }
    
    public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws BadItemTypeException
    {
        return getContent().getDifferences(viewItemAccessor, values);
    }
    
    public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException
    {
        return getContent().getDifferences(viewItemAccessor, values, context);
    }
    
    public ModifiableModelAwareComposite getComposite(String compositePath, boolean createNew) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getComposite(compositePath, createNew))
                .orElse(null);
    }
    
    public ModifiableModelAwareComposite getLocalComposite(String compositePath, boolean createNew) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getLocalComposite(compositePath, createNew))
                .orElse(null);
    }
    
    public ModifiableModelAwareComposite getExternalComposite(String compositePath, boolean createNew) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getExternalComposite(compositePath, createNew))
                .orElse(null);
    }

    public ModifiableRepeater getRepeater(String repeaterPath, boolean createNew) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getRepeater(repeaterPath, createNew))
                .orElse(null);
    }
    
    public ModifiableRepeater getLocalRepeater(String repeaterPath, boolean createNew) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getLocalRepeater(repeaterPath, createNew))
                .orElse(null);
    }
    
    public ModifiableRepeater getExternalRepeater(String repeaterPath, boolean createNew) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        return getContentIfExists()
                .map(c -> c.getExternalRepeater(repeaterPath, createNew))
                .orElse(null);
    }
    
    public <T extends SynchronizationResult> T synchronizeValues(Map<String, Object> values) throws BadItemTypeException, UndefinedItemPathException
    {
        return getContent().synchronizeValues(values);
    }
    
    public <T extends SynchronizationResult> T synchronizeValues(Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException, UndefinedItemPathException
    {
        return getContent().synchronizeValues(values, context);
    }
    
    public <T extends SynchronizationResult> T synchronizeValues(ViewItemAccessor viewItemAccessor, Map<String, Object> values) throws BadItemTypeException, UndefinedItemPathException
    {
        return getContent().synchronizeValues(viewItemAccessor, values);
    }
    
    public <T extends SynchronizationResult> T synchronizeValues(ViewItemAccessor viewItemAccessor, Map<String, Object> values, SynchronizationContext context) throws BadItemTypeException, UndefinedItemPathException
    {
        return getContent().synchronizeValues(viewItemAccessor, values, context);
    }

    public void setValue(String dataPath, Object value) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().setValue(dataPath, value);
    }
    
    public void setLocalValue(String dataPath, Object localValue) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().setLocalValue(dataPath, localValue);
    }
    
    public void setExternalValue(String dataPath, Object externalValue) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().setExternalValue(dataPath, externalValue);
    }
    
    public void setValue(String dataPath, Object value, String dataTypeId) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().setValue(dataPath, value, dataTypeId);
    }
    
    public void setStatus(String dataPath, ExternalizableDataStatus status) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().setStatus(dataPath, status);
    }
    
    public void removeValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().removeValue(dataPath);
    }
    
    public void removeLocalValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().removeLocalValue(dataPath);
    }
    
    public void removeExternalValue(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().removeExternalValue(dataPath);
    }
    
    public void removeExternalizableMetadataIfExists(String dataPath) throws IllegalArgumentException, BadItemTypeException, UndefinedItemPathException, BadDataPathCardinalityException
    {
        getContent().removeExternalizableMetadataIfExists(dataPath);
    }
    
    public ModifiableRepositoryData getRepositoryData()
    {
        return getContent().getRepositoryData();
    }
    
    public Optional<? extends ModifiableModelAwareDataHolder> getParentDataHolder()
    {
        return getContent().getParentDataHolder();
    }
    
    public ModifiableModelAwareDataHolder getRootDataHolder()
    {
        return getContent().getRootDataHolder();
    }
    
    @Override
    public String toString()
    {
        return _contentId;
    }
}