/*
 *  Copyright 2010 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.repository;

import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Value;

import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.content.references.OutgoingReferences;
import org.ametys.cms.content.references.OutgoingReferencesHelper;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.explorer.resources.ResourceCollection;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CopiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.RepositoryIntegrityViolationException;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.data.UnknownDataException;
import org.ametys.plugins.repository.data.holder.ModifiableDataHolder;
import org.ametys.plugins.repository.data.holder.impl.DefaultModifiableDataHolder;
import org.ametys.plugins.repository.data.repositorydata.ModifiableRepositoryData;
import org.ametys.plugins.repository.data.repositorydata.RepositoryData;
import org.ametys.plugins.repository.data.repositorydata.impl.JCRRepositoryData;
import org.ametys.plugins.repository.dublincore.DCMITypes;
import org.ametys.plugins.repository.jcr.DublinCoreHelper;
import org.ametys.plugins.repository.jcr.JCRTraversableAmetysObject;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.metadata.MultilingualString;
import org.ametys.plugins.repository.tag.TaggableAmetysObjectHelper;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ModelItemTypeConstants;

/**
 * Default implementation of a {@link Content}, also versionable, lockable and workflow-aware.
 * @param <F> the actual type of factory.
 */
public class DefaultContent<F extends ContentFactory> extends DefaultIndexableAmetysObject<F> implements Content, CopiableAmetysObject, JCRTraversableAmetysObject, ReactionableObject, ReportableObject
{
    /** Constants for the root outgoing references node */
    public static final String METADATA_ROOT_OUTGOING_REFERENCES = "root-outgoing-references";
    
    /** Constants for the outgoing references node */
    public static final String METADATA_OUTGOING_REFERENCES = "outgoing-references";
    
    /** Constants for the outgoing references path property */
    public static final String METADATA_OUTGOING_REFERENCES_PATH_PROPERTY = "path";
    
    /** Constants for the outgoing reference property */
    public static final String METADATA_OUTGOING_REFERENCE_PROPERTY = "reference";
    
    /** Constants for the outgoing reference nodetype */
    public static final String METADATA_OUTGOING_REFERENCE_NODETYPE = "reference";
    
    /** Constants for language Metadata* */
    public static final String METADATA_LANGUAGE = "language";
    
    /** Constants for author Metadata* */
    public static final String METADATA_CREATOR = "creator";
    
    /** Constants for lastModified Metadata* */
    public static final String METADATA_CREATION = "creationDate";
    
    /** Constants for the first validator metadata */
    public static final String METADATA_FIRST_VALIDATOR = "firstValidator";
    
    /** Constants for firstValidationDate Metadata* */
    public static final String METADATA_FIRST_VALIDATION = "firstValidationDate";
    
    /** Constants for last validator Metadata* */
    public static final String METADATA_LAST_VALIDATOR = "lastValidator";
    
    /** Constants for lastValidationDate Metadata* */
    public static final String METADATA_LAST_VALIDATION = "lastValidationDate";
    
    /** Constants for last major validator Metadata* */
    public static final String METADATA_LAST_MAJOR_VALIDATOR = "lastMajorValidator";
    
    /** Constants for lastMajorValidationDate Metadata* */
    public static final String METADATA_LAST_MAJORVALIDATION = "lastMajorValidationDate";
    
    /** Constants for last contributor Metadata* */
    public static final String METADATA_CONTRIBUTOR = "contributor";
    
    /** Constants for lastModified Metadata* */
    public static final String METADATA_MODIFIED = "lastModified";
    
    /** Constants for contentType Metadata* */
    public static final String METADATA_CONTENTTYPE = "contentType";
    
    /** Constants for contentType Metadata* */
    public static final String METADATA_MIXINCONTENTTYPES = "mixins";
    
    /** Constant for the attachment node name. */
    public static final String ATTACHMENTS_NODE_NAME = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":attachments";
    
    /** The default locale for content */
    public static final Locale DEFAULT_CONTENT_LOCALE = Locale.ENGLISH;
    
    /** The type identifiers of this content */
    protected String[] _types;
    /** The mixin type identifiers of this content */
    protected String[] _mixins;
    
    /** Store already retrieved outgoing references, if any */
    protected Map<String, OutgoingReferences> _outgoingReferences;

    /**
     * Creates a JCR-based Content.
     * @param node the JCR Node backing this Content.
     * @param parentPath the parent path in the Ametys hierarchy.
     * @param factory the corresponding {@link ContentFactory}.
     */
    public DefaultContent(Node node, String parentPath, F factory)
    {
        super(node, parentPath, factory);
    }
    
    @Override
    public String[] getTypes()
    {
        if (_types == null)
        {
            _types = getInternalDataHolder().getValueOfTypeOrDefault(METADATA_CONTENTTYPE, ModelItemTypeConstants.STRING_TYPE_ID, new String[0]);
        }
        
        return _types;
    }
    
    @Override
    public void setType(String type)
    {
        setTypes(new String[] {type});
    }
    
    @Override
    public void setTypes(String[] types)
    {
        getInternalDataHolder().setValue(DefaultContent.METADATA_CONTENTTYPE, types, ModelItemTypeConstants.STRING_TYPE_ID);
        _types = types;
    }
    
    @Override
    public String[] getMixinTypes()
    {
        if (_mixins == null)
        {
            _mixins = getInternalDataHolder().getValueOfTypeOrDefault(METADATA_MIXINCONTENTTYPES, ModelItemTypeConstants.STRING_TYPE_ID, new String[0]);
        }
        return _mixins;
    }
    
    @Override
    public void setMixinTypes(String[] mixins)
    {
        getInternalDataHolder().setValue(DefaultContent.METADATA_MIXINCONTENTTYPES, mixins, ModelItemTypeConstants.STRING_TYPE_ID);
        _mixins = mixins;
    }
    
    @Override
    public String getLanguage()
    {
        return getInternalDataHolder().getValueOfType(METADATA_LANGUAGE, ModelItemTypeConstants.STRING_TYPE_ID);
    }
    
    @Override
    public void setLanguage(String language)
    {
        getInternalDataHolder().setValue(DefaultContent.METADATA_LANGUAGE, language, ModelItemTypeConstants.STRING_TYPE_ID);
    }
    
    public String getTitle(Locale locale) throws UnknownDataException
    {
        Object value = getValue(ATTRIBUTE_TITLE);
        if (value == null)
        {
            throw new UnknownDataException("Unknown attribute " + ATTRIBUTE_TITLE + " for content " + getId());
        }
        else if (value instanceof MultilingualString)
        {
            MultilingualString multilingual = (MultilingualString) value;
            
            if (locale != null && multilingual.hasLocale(locale))
            {
                return multilingual.getValue(locale);
            }
            else if (multilingual.hasLocale(DEFAULT_CONTENT_LOCALE))
            {
                return multilingual.getValue(DEFAULT_CONTENT_LOCALE);
            }
            else if (multilingual.getValues().isEmpty())
            {
                throw new UnknownDataException("Unknown attribute " + ATTRIBUTE_TITLE + " for content " + getId());
            }
            else
            {
                return multilingual.getValues().get(0);
            }
        }
        else
        {
            return (String) value;
        }
    }
    
    public String getTitle() throws UnknownDataException
    {
        return getTitle(null);
    }
    
    @Override
    public UserIdentity getCreator() throws UnknownDataException
    {
        UserIdentity creator = getInternalDataHolder().getValueOfType(METADATA_CREATOR, ModelItemTypeConstants.USER_ELEMENT_TYPE_ID);
        if (creator == null)
        {
            throw new UnknownDataException("Unknown metadata " + METADATA_CREATOR + " for content " + getId());
        }
            
        return creator;
    }
    
    @Override
    public ZonedDateTime getCreationDate() throws UnknownDataException
    {
        ZonedDateTime creationDate = getInternalDataHolder().getValueOfType(METADATA_CREATION, ModelItemTypeConstants.DATETIME_TYPE_ID);
        if (creationDate == null)
        {
            throw new UnknownDataException("Unknown metadata " + METADATA_CREATION + " for content " + getId());
        }
            
        return creationDate;
    }
    
    @Override
    public UserIdentity getLastContributor() throws UnknownDataException
    {
        UserIdentity lastContributor = getInternalDataHolder().getValueOfType(METADATA_CONTRIBUTOR, ModelItemTypeConstants.USER_ELEMENT_TYPE_ID);
        if (lastContributor == null)
        {
            throw new UnknownDataException("Unknown metadata " + METADATA_CONTRIBUTOR + " for content " + getId());
        }
        
        return lastContributor;
    }
    
    @Override
    public ZonedDateTime getLastModified() throws UnknownDataException
    {
        ZonedDateTime lastModified = getInternalDataHolder().getValueOfType(METADATA_MODIFIED, ModelItemTypeConstants.DATETIME_TYPE_ID);
        if (lastModified == null)
        {
            throw new UnknownDataException("Unknown metadata " + METADATA_MODIFIED + " for content " + getId());
        }
            
        return lastModified;
    }
    
    public Optional<UserIdentity> getFirstValidator()
    {
        return Optional.ofNullable(getInternalDataHolder().getValueOfType(METADATA_FIRST_VALIDATOR, ModelItemTypeConstants.USER_ELEMENT_TYPE_ID));
    }
    
    @Override
    public ZonedDateTime getFirstValidationDate()
    {
        return getInternalDataHolder().getValueOfType(METADATA_FIRST_VALIDATION, ModelItemTypeConstants.DATETIME_TYPE_ID);
    }
    
    public Optional<UserIdentity> getLastValidator()
    {
        return Optional.ofNullable(getInternalDataHolder().getValueOfType(METADATA_LAST_VALIDATOR, ModelItemTypeConstants.USER_ELEMENT_TYPE_ID));
    }
    
    @Override
    public ZonedDateTime getLastValidationDate()
    {
        return getInternalDataHolder().getValueOfType(METADATA_LAST_VALIDATION, ModelItemTypeConstants.DATETIME_TYPE_ID);
    }
    
    public Optional<UserIdentity> getLastMajorValidator()
    {
        return Optional.ofNullable(getInternalDataHolder().getValueOfType(METADATA_LAST_MAJOR_VALIDATOR, ModelItemTypeConstants.USER_ELEMENT_TYPE_ID));
    }
    
    @Override
    public ZonedDateTime getLastMajorValidationDate()
    {
        return getInternalDataHolder().getValueOfType(METADATA_LAST_MAJORVALIDATION, ModelItemTypeConstants.DATETIME_TYPE_ID);
    }
    
    // Tag management.
    @Override
    public Set<String> getTags() throws AmetysRepositoryException
    {
        return TaggableAmetysObjectHelper.getTags(this);
    }
    
    @Override
    public Map<String, OutgoingReferences> getOutgoingReferences() throws AmetysRepositoryException
    {
        // small optimization to avoid many JCR operations for outgoing references retrieval if already retrieved for the same Content instance
        if (_outgoingReferences != null)
        {
            return _outgoingReferences;
        }
        
        Map<String, OutgoingReferences> outgoingReferencesByPath = new HashMap<>();
        
        try
        {
            Node contentNode = getNode();
            if (contentNode.hasNode(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ':' + METADATA_ROOT_OUTGOING_REFERENCES))
            {
                Node rootOutgoingRefsNode = contentNode.getNode(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ':' + METADATA_ROOT_OUTGOING_REFERENCES);
                
                // Loop on outgoing ref node by (metadata) path.
                NodeIterator outgoingRefsNodeIterator = rootOutgoingRefsNode.getNodes(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ':' + METADATA_OUTGOING_REFERENCES);
                while (outgoingRefsNodeIterator.hasNext())
                {
                    Node outgoingRefsNode = outgoingRefsNodeIterator.nextNode();
                    String path = outgoingRefsNode.getProperty(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ':' + METADATA_OUTGOING_REFERENCES_PATH_PROPERTY).getString();
                    
                    // Loop on each outgoing ref node values for each reference type and collecting outgoing references.
                    OutgoingReferences outgoingReferences = new OutgoingReferences();
                    NodeIterator outgoingReferenceNodeIterator = outgoingRefsNode.getNodes();
                    while (outgoingReferenceNodeIterator.hasNext())
                    {
                        Node outgoingReferenceNode = outgoingReferenceNodeIterator.nextNode();
                        Value[] referenceValues = outgoingReferenceNode.getProperty(RepositoryConstants.NAMESPACE_PREFIX + ':' + METADATA_OUTGOING_REFERENCE_PROPERTY).getValues();
                        
                        List<String> referenceValuesAsList = new ArrayList<>(referenceValues.length);
                        for (Value value : referenceValues)
                        {
                            referenceValuesAsList.add(value.getString());
                        }
                        
                        outgoingReferences.put(outgoingReferenceNode.getName(), referenceValuesAsList);
                    }
                    
                    // Updating the outgoing references map
                    if (!outgoingReferences.isEmpty())
                    {
                        if (outgoingReferencesByPath.containsKey(path))
                        {
                            outgoingReferencesByPath.get(path).merge(outgoingReferences);
                        }
                        else
                        {
                            outgoingReferencesByPath.put(path, outgoingReferences);
                        }
                    }
                }
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
        
        _outgoingReferences = outgoingReferencesByPath;
        return outgoingReferencesByPath;
    }
    
    @Override
    public Collection<Content> getReferencingContents() throws AmetysRepositoryException
    {
        return _getReferencingContents(Long.MAX_VALUE).referencingContents();
    }
    
    private ReferencingContentsSearch _getReferencingContents(long limit) throws AmetysRepositoryException
    {
        Set<Content> contents = new LinkedHashSet<>();
        long total = 0;
        boolean hasOtherReferences = false;
        
        try
        {
            NodeIterator results = OutgoingReferencesHelper.getContentOutgoingReferences(this);
            total = results.getSize();
            
            AmetysObjectResolver resolver = _getFactory()._getAOResolver();
            while (results.hasNext() && contents.size() < limit)
            {
                Node node = results.nextNode();
                Node contentNode = node.getParent()  // go up towards node 'ametys-internal:outgoing-references
                                       .getParent()  // go up towards node 'ametys-internal:root-outgoing-references
                                       .getParent(); // go up towards node of the content
                Content content = resolver.resolve(contentNode, false);
                contents.add(content);
            }
            
            hasOtherReferences = results.hasNext();
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to resolve references for content " + getId(), e);
        }
        
        return new ReferencingContentsSearch(total, contents, hasOtherReferences);
    }
    
    @Override
    public ReferencingContentsSearch searchReferencingContents(int limit) throws AmetysRepositoryException
    {
        return _getReferencingContents(limit);
    }
    
    public boolean hasReferencingContents() throws AmetysRepositoryException
    {
        try
        {
            return OutgoingReferencesHelper.getContentOutgoingReferences(this).getSize() != 0;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("A repository exception occured: ", e);
        }
    }
    
    @Override
    public ModifiableContent copyTo(ModifiableTraversableAmetysObject parent, String name, List<String> restrictTo) throws AmetysRepositoryException
    {
        return copyTo(parent, name);
    }
    
    @Override
    public ModifiableContent copyTo(ModifiableTraversableAmetysObject parent, String name) throws AmetysRepositoryException
    {
        return copyTo(parent, name, 0, true, true);
    }
    
    /**
     * Copy the current {@link DefaultWorkflowAwareContent} to the given object. Be careful, this method save changes, but do not create a new version (checkpoint)
     * @param parent The parent of the new object. Can not be null.
     * @param name Name of the new object. Can be null. If null, the new name will be get from the copied object.
     * @param initWorkflowActionId The initial workflow action id
     * @param notifyObservers Set to false to do not fire observer events
     * @param checkpoint true to check the content in if it is versionable
     * @return the created object
     * @throws AmetysRepositoryException if an error occurs.
     */
    public ModifiableContent copyTo(ModifiableTraversableAmetysObject parent, String name, int initWorkflowActionId, boolean notifyObservers, boolean checkpoint) throws AmetysRepositoryException
    {
        return _getFactory()._getContentDAO().copy(this, parent, name, null, initWorkflowActionId, notifyObservers, checkpoint, false, false, DataContext.newInstance());
    }
    
    /**
     * Copy the current {@link DefaultWorkflowAwareContent} to the given object. Be careful, this method save changes, but do not create a new version (checkpoint)
     * @param parent The parent of the new object. Can not be null.
     * @param name Name of the new object. Can be null. If null, the new name will be get from the copied object.
     * @param lang Language of the new object. Can be null. If null, the new language will be get from the copied object.
     * @param initWorkflowActionId The initial workflow action id
     * @param notifyObservers Set to false to do not fire observer events
     * @param checkpoint true to check the content in if it is versionable
     * @param waitAsyncObservers if true, waits if necessary for the asynchronous observers to complete
     * @param copyACL true to copy ACL of source content
     * @param context The context of the data to copy
     * @return the created object
     * @throws AmetysRepositoryException if an error occurs.
     */
    public ModifiableContent copyTo(ModifiableTraversableAmetysObject parent, String name, String lang, int initWorkflowActionId, boolean notifyObservers, boolean checkpoint, boolean waitAsyncObservers, boolean copyACL, DataContext context) throws AmetysRepositoryException
    {
        return _getFactory()._getContentDAO().copy(this, parent, name, lang, initWorkflowActionId, notifyObservers, checkpoint, waitAsyncObservers, copyACL, context);
    }

    // Dublin Core metadata. //
    
    @Override
    public String getDCTitle() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCTitle(this, getTitle());
    }
    
    @Override
    public String getDCCreator() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCCreator(this, UserIdentity.userIdentityToString(getCreator()));
    }

    @Override
    public String[] getDCSubject() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCSubject(this);
    }

    @Override
    public String getDCDescription() throws AmetysRepositoryException
    {
        String seoDesc = null;
        try
        {
            RepositoryData repositoryData = new JCRRepositoryData(getNode());
            RepositoryData seoReposioryData = repositoryData.getRepositoryData("seo");
            seoDesc = seoReposioryData.getString("description");
        }
        catch (UnknownDataException me)
        {
            seoDesc = null;
        }
        
        return DublinCoreHelper.getDCDescription(this, seoDesc);
    }

    @Override
    public String getDCPublisher() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCPublisher(this, getLastValidator().map(UserIdentity::userIdentityToString).orElse(null));
    }
    
    @Override
    public String getDCContributor() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCContributor(this, UserIdentity.userIdentityToString(getLastContributor()));
    }
    
    @Override
    public Date getDCDate() throws AmetysRepositoryException
    {
        Date defaultDCDate = Optional.ofNullable(getLastValidationDate())
                                     .map(DateUtils::asDate)
                                     .orElse(null);
        return DublinCoreHelper.getDCDate(this, defaultDCDate);
        
    }
    
    @Override
    public String getDCType() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCType(this, DCMITypes.TEXT);
    }
    
    @Override
    public String getDCFormat() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCFormat(this, "text/html");
    }
    
    @Override
    public String getDCIdentifier() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCIdentifier(this, getId());
    }
    
    @Override
    public String getDCSource() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCSource(this);
    }
    
    @Override
    public String getDCLanguage() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCLanguage(this, getLanguage());
    }
    
    @Override
    public String getDCRelation() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCRelation(this);
    }
    
    @Override
    public String getDCCoverage() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCCoverage(this, getDCLanguage());
    }
    
    @Override
    public String getDCRights() throws AmetysRepositoryException
    {
        return DublinCoreHelper.getDCRights(this);
    }

    @Override
    public ResourceCollection getRootAttachments() throws AmetysRepositoryException
    {
        ResourceCollection attachments = null;
        
        if (hasChild(ATTACHMENTS_NODE_NAME))
        {
            attachments = getChild(ATTACHMENTS_NODE_NAME);
        }
        
        return attachments;
    }
    
    @Override
    public boolean hasChild(String name) throws AmetysRepositoryException
    {
        return _getFactory().hasChild(this, name);
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public <A extends AmetysObject> A createChild(String name, String type) throws AmetysRepositoryException, RepositoryIntegrityViolationException
    {
        return (A) _getFactory().createChild(this, name, type);
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public <A extends AmetysObject> A getChild(String path) throws AmetysRepositoryException, UnknownAmetysObjectException
    {
        return (A) _getFactory().getChild(this, path);
    }
    
    @Override
    public <A extends AmetysObject> AmetysObjectIterable<A> getChildren() throws AmetysRepositoryException
    {
        return _getFactory().getChildren(this);
    }

    public ModifiableDataHolder getInternalDataHolder()
    {
        // It is necessary to instantiate the repository data because of locks:
        // when the content is locked, the lock token is released to be taken by anyone
        // in repository data there is a lock checked boolean that need to be reset in order to take the token
        // this boolean is only reset at instantiation
        ModifiableRepositoryData repositoryData = new JCRRepositoryData(getNode(), RepositoryConstants.NAMESPACE_PREFIX_INTERNAL);
        Optional<LockableAmetysObject> lockableAmetysObject = Optional.of(this)
                                                                      .filter(LockableAmetysObject.class::isInstance)
                                                                      .map(LockableAmetysObject.class:: cast);
        return new DefaultModifiableDataHolder(_getFactory().getInternalDataTypesExtensionPoint(), repositoryData, lockableAmetysObject);
    }
    
    public Optional<SystemPropertyExtensionPoint> getSystemPropertyExtensionPoint()
    {
        return Optional.of(_getFactory().getSystemPropertyExtensionPoint());
    }
    
    @Override
    public void addReaction(UserIdentity user, ReactionType reactionType)
    {
        ReactionableObjectHelper.addReaction(getUnversionedDataHolder(), user, reactionType);
    }

    @Override
    public void removeReaction(UserIdentity user, ReactionType reactionType)
    {
        ReactionableObjectHelper.removeReaction(getUnversionedDataHolder(), user, reactionType);
    }

    @Override
    public List<UserIdentity> getReactionUsers(ReactionType reactionType)
    {
        return ReactionableObjectHelper.getReactionUsers(getUnversionedDataHolder(), reactionType);
    }

    public void addReport()
    {
        ReportableObjectHelper.addReport(getUnversionedDataHolder());
    }
    
    public void setReportsCount(long reportsCount)
    {
        ReportableObjectHelper.setReportsCount(getUnversionedDataHolder(), reportsCount);
    }

    public void clearReports()
    {
        ReportableObjectHelper.clearReports(getUnversionedDataHolder());
    }

    public long getReportsCount()
    {
        return ReportableObjectHelper.getReportsCount(getUnversionedDataHolder());
    }
    
    public void toSAX(ContentHandler contentHandler, Locale locale, View view, boolean saxWorkflowStep) throws SAXException
    {
        _getFactory().getContentSaxer().saxContent(this, contentHandler, locale, view, "content", saxWorkflowStep, false, false, "attributes");
    }
}