/*
 *  Copyright 2012 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.Collection;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.RepositoryException;

import org.ametys.cms.content.references.OutgoingReferences;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.repository.comment.Comment;
import org.ametys.cms.repository.comment.CommentableContent;
import org.ametys.cms.repository.comment.contributor.ContributorCommentableContent;
import org.ametys.cms.trash.ContentTrashElementType;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.data.extractor.xml.XMLValuesExtractorAdditionalDataGetter;
import org.ametys.plugins.repository.data.holder.ModifiableModelLessDataHolder;
import org.ametys.plugins.repository.data.repositorydata.impl.JCRRepositoryData;
import org.ametys.plugins.repository.jcr.DublinCoreHelper;
import org.ametys.plugins.repository.jcr.JCRTraversableAmetysObject;
import org.ametys.plugins.repository.jcr.NameHelper;
import org.ametys.plugins.repository.jcr.NameHelper.NameComputationMode;
import org.ametys.plugins.repository.jcr.NodeHelper;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.tag.TaggableAmetysObjectHelper;
import org.ametys.plugins.repository.trash.TrashElement;
import org.ametys.plugins.repository.trash.TrashableAmetysObject;
import org.ametys.plugins.repository.trash.UnknownParentException;

/**
 * Default implementation of a {@link Content}, also versionable, lockable and workflow-aware.
 * @param <F> the actual type of factory.
 */
public class ModifiableDefaultContent<F extends ModifiableContentFactory> extends DefaultContent<F> implements CommentableContent, ContributorCommentableContent, LockableAmetysObject, ModifiableWorkflowAwareContent, TrashableAmetysObject/*, AnnotableContent*/ //, CopiableAmetysObject
{
    private boolean _lockAlreadyChecked;
    
    /**
     * 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 ModifiableDefaultContent(Node node, String parentPath, F factory)
    {
        super(node, parentPath, factory);
    }

    public void setTitle(String title, Locale locale) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setTitle(this, title, locale);
    }
    
    public void setTitle(String title) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setTitle(this, title);
    }
    
    public void setCreator(UserIdentity user) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setCreator(this, user);
    }
    
    public void setCreationDate(ZonedDateTime creationDate) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setCreationDate(this, creationDate);
    }
    
    public void setLastContributor(UserIdentity user)
    {
        _getFactory()._getModifiableContentHelper().setLastContributor(this, user);
    }
    
    public void setLastModified(ZonedDateTime lastModified) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setLastModified(this, lastModified);
    }
    
    public void setFirstValidator(UserIdentity user) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setFirstValidator(this, user);
    }
    
    @Override
    public void setFirstValidationDate(ZonedDateTime validationDate) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setFirstValidationDate(this, validationDate);
    }
    
    public void setLastValidator(UserIdentity user) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setLastValidator(this, user);
    }
    
    @Override
    public void setLastValidationDate(ZonedDateTime validationDate) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setLastValidationDate(this, validationDate);
    }
    
    public void setLastMajorValidator(UserIdentity user) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setLastMajorValidator(this, user);
    }
    
    @Override
    public void setLastMajorValidationDate(ZonedDateTime validationDate) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setLastMajorValidationDate(this, validationDate);
    }
    
    @Override
    public void setOutgoingReferences(Map<String, OutgoingReferences> references) throws AmetysRepositoryException
    {
        _getFactory()._getModifiableContentHelper().setOutgoingReferences(this, references);
        _outgoingReferences = references;
    }
    
    // ------------------- Tags management -------------------- //
    @Override
    public void tag(String tag) throws AmetysRepositoryException
    {
        TaggableAmetysObjectHelper.tag(this, tag);
    }
    
    @Override
    public void untag(String tag) throws AmetysRepositoryException
    {
        TaggableAmetysObjectHelper.untag(this, tag);
    }
    
    // ------------------- Workflow management -------------------- //
    @Override
    public long getWorkflowId() throws AmetysRepositoryException
    {
        return WorkflowAwareContentHelper.getWorkflowId(this);
    }
    
    @Override
    public void setWorkflowId(long workflowId) throws AmetysRepositoryException
    {
        WorkflowAwareContentHelper.setWorkflowId(this, workflowId);
    }
    
    @Override
    public long getCurrentStepId() throws AmetysRepositoryException
    {
        return WorkflowAwareContentHelper.getCurrentStepId(this);
    }
    
    @Override
    public void setCurrentStepId (long stepId) throws AmetysRepositoryException
    {
        WorkflowAwareContentHelper.setCurrentStepId(this, stepId);
    }
    
    @Override
    public ZonedDateTime getProposalDate() throws AmetysRepositoryException
    {
        return WorkflowAwareContentHelper.getProposalDate(this);
    }
    
    @Override
    public void setProposalDate(ZonedDateTime proposalDate) throws AmetysRepositoryException
    {
        WorkflowAwareContentHelper.setProposalDate(this, proposalDate);
    }
    
    // --------------------- Lock management ----------------------- //
    @Override
    public void lock() throws AmetysRepositoryException
    {
        _getFactory().getLockComponent().lock(this);
        
        // the lock component immediately detached the lock token, so we have to check it again at next usage
        _lockAlreadyChecked = false;
    }
    
    @Override
    public void unlock() throws AmetysRepositoryException
    {
        _getFactory().getLockComponent().unlock(this);
        
        // the lock component removed the lock token on unlock
        _lockAlreadyChecked = true;
    }
    
    @Override
    public void setLockInfoOnCurrentContext() throws AmetysRepositoryException
    {
        if (!_lockAlreadyChecked)
        {
            _getFactory().getLockComponent().setLockTokenOnCurrentSession(this);
            _lockAlreadyChecked = true;
        }
    }
    
    @Override
    public boolean isLocked() throws AmetysRepositoryException
    {
        return _getFactory().getLockComponent().isLocked(this);
    }
    
    @Override
    public UserIdentity getLockOwner() throws AmetysRepositoryException
    {
        return _getFactory().getLockComponent().getLockOwner(this);
    }
    
    // -------------------------- DUBLIN CORE ---------------------------- //
    @Override
    public void setDCTitle(String title) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCTitle(this, title);
    }

    @Override
    public void setDCCreator(String creator) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCCreator(this, creator);
    }

    @Override
    public void setDCSubject(String[] subject) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCSubject(this, subject);
    }

    @Override
    public void setDCDescription(String description) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCDescription(this, description);
    }

    @Override
    public void setDCPublisher(String publisher) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCPublisher(this, publisher);
    }

    @Override
    public void setDCContributor(String contributor) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCContributor(this, contributor);
    }

    @Override
    public void setDCDate(Date date) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCDate(this, date);
    }

    @Override
    public void setDCType(String type) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCType(this, type);
    }

    @Override
    public void setDCFormat(String format) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCFormat(this, format);
    }

    @Override
    public void setDCIdentifier(String identifier) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCIdentifier(this, identifier);
    }

    @Override
    public void setDCSource(String source) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCSource(this, source);
    }

    @Override
    public void setDCLanguage(String language) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCLanguage(this, language);
    }

    @Override
    public void setDCRelation(String relation) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCRelation(this, relation);
    }
    
    @Override
    public void setDCCoverage(String coverage) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCCoverage(this, coverage);
    }
    
    @Override
    public void setDCRights(String rights) throws AmetysRepositoryException
    {
        DublinCoreHelper.setDCRights(this, rights);
    }
    
    // ---------------------------- COMMENTS ------------------------------ //
    @Override
    public Comment createComment()
    {
        return new Comment(_getFactory()._getModifiableContentHelper().getCommentsDataHolder(this, true));
    }
    
    public Comment createComment(String commentId, ZonedDateTime creationDate)
    {
        return new Comment(_getFactory()._getModifiableContentHelper().getCommentsDataHolder(this, true), commentId, creationDate);
    }
    
    @Override
    public Comment getComment(String commentId) throws AmetysRepositoryException
    {
        ModifiableModelLessDataHolder commentsDataHolder = _getFactory()._getModifiableContentHelper().getCommentsDataHolder(this, false);
        return commentsDataHolder != null ? Comment.getComment(commentsDataHolder, commentId) : null;
    }
    
    @Override
    public List<Comment> getComments(boolean includeNotValidatedComments, boolean includeValidatedComments) throws AmetysRepositoryException
    {
        ModifiableModelLessDataHolder commentsDataHolder = _getFactory()._getModifiableContentHelper().getCommentsDataHolder(this, false);
        return commentsDataHolder != null ? Comment.getComments(commentsDataHolder, includeNotValidatedComments, includeValidatedComments) : List.of();
    }
    
    // ---------------------------- CONTRIBUTOR COMMENTS ------------------------------ //
    @Override
    public Comment createContributorComment()
    {
        return new Comment(_getFactory()._getModifiableContentHelper().getContributorCommentsDataHolder(this, true));
    }
    
    public Comment createContributorComment(String commentId, ZonedDateTime creationDate)
    {
        return new Comment(_getFactory()._getModifiableContentHelper().getContributorCommentsDataHolder(this, true), commentId, creationDate);
    }
    
    @Override
    public Comment getContributorComment(String commentId) throws AmetysRepositoryException
    {
        ModifiableModelLessDataHolder commentsDataHolder = _getFactory()._getModifiableContentHelper().getContributorCommentsDataHolder(this, false);
        return commentsDataHolder != null ? Comment.getComment(commentsDataHolder, commentId) : null;
    }
    
    @Override
    public List<Comment> getContributorComments() throws AmetysRepositoryException
    {
        ModifiableModelLessDataHolder commentsDataHolder = _getFactory()._getModifiableContentHelper().getContributorCommentsDataHolder(this, false);
        return commentsDataHolder != null ? Comment.getComments(commentsDataHolder, false, true) : List.of();
    }
    
    // ---------------------------- DATA HOLDER --------------------------- //
    @Override
    public ModifiableContentDataHolder getDataHolder()
    {
        // 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
        Collection<ContentType> contentTypes = _getFactory().getContentHelper().getContentTypes(this);
        return new ModifiableContentDataHolder(this, _getFactory().getContentDataHelper(), new JCRRepositoryData(getNode()), contentTypes);
    }
    
    public void fillContent(org.w3c.dom.Node node, XMLValuesExtractorAdditionalDataGetter additionalDataGetter) throws Exception
    {
        _getFactory().getContentExtractor().fillContent(this, node, additionalDataGetter);
    }
    
    public TrashElement moveToTrash() throws AmetysRepositoryException
    {
        TrashElement trashElement = _getFactory()._getTrashElementDAO().createTrashElement(this, getTitle());
        trashElement.setValue(ContentTrashElementType.CONTENT_TYPES, getTypes());
        
        // Clone the ametys object from the original session to trash session
        Node storedNode = NodeHelper.cloneNode(getNode(), trashElement.getNode());
        
        try
        {
            storedNode.setProperty("ametys-internal:path", this.getParentPath());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("failed to store the content path", e);
        }
        
        // Remove the node from the original session
        remove();
        
        return trashElement;
    }
    
    public TrashableAmetysObject restoreFromTrash() throws UnknownParentException
    {
        try
        {
            Property property = getNode().getProperty("ametys-internal:path");
            String parentPath = property.getValue().getString();
            property.remove();
            JCRTraversableAmetysObject parent = _getFactory()._getResolver().resolveByPath(parentPath);
            // Get the node name, can be adjust if another content has already the same node name
            String nodeName = NameHelper.getUniqueAmetysObjectName(parent, getName(), NameComputationMode.GENERATED_KEY, true);
            
            // Create the hashed nodes
            Node hashNode = NodeHelper.getOrCreateFinalHashNode(parent.getNode(), nodeName);
            
            // Clone the ametys object from the trash session to default session
            NodeHelper.cloneNode(getNode(), hashNode, nodeName);
            
            // Remove the node from the trash session
            remove();
            
            return parent.getChild(nodeName);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("failed to store the content path", e);
        }
    }
}