/*
 *  Copyright 2015 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.plugins.explorer.threads.actions;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.IllegalClassException;
import org.apache.excalibur.xml.sax.SAXParser;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.right.RightManager;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.explorer.ExplorerNode;
import org.ametys.plugins.explorer.ModifiableExplorerNode;
import org.ametys.plugins.explorer.ObservationConstants;
import org.ametys.plugins.explorer.resources.ModifiableResourceCollection;
import org.ametys.plugins.explorer.resources.actions.ExplorerResourcesDAO;
import org.ametys.plugins.explorer.threads.jcr.JCRPost;
import org.ametys.plugins.explorer.threads.jcr.JCRPostFactory;
import org.ametys.plugins.explorer.threads.jcr.JCRThread;
import org.ametys.plugins.explorer.threads.jcr.JCRThreadFactory;
import org.ametys.plugins.explorer.threads.jcr.PostRichTextHandler;
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.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.metadata.ModifiableRichText;
import org.ametys.runtime.parameter.ParameterHelper;

/**
 * Thread DAO
 */
public class ThreadDAO extends AbstractLogEnabled implements Serviceable, Component
{
    /** Avalon Role */
    public static final String ROLE = ThreadDAO.class.getName();

    /** Right to add a thread */
    public static final String __RIGHTS_THREAD_ADD = "Plugin_Explorer_Thread_Add";

    /** Right to edit a thread */
    public static final String __RIGHTS_THREAD_EDIT = "Plugin_Explorer_Thread_Edit";

    /** Right to delete a thread */
    public static final String __RIGHTS_THREAD_DELETE = "Plugin_Explorer_Thread_Delete";

    /** Right to add a post */
    public static final String __RIGHTS_POST_ADD = "Plugin_Explorer_Post_Add";

    /** Right to edit a post */
    public static final String __RIGHTS_POST_EDIT = "Plugin_Explorer_Post_Edit";

    /** Right to delete a post */
    public static final String __RIGHTS_POST_DELETE = "Plugin_Explorer_Post_Delete";
    
    /** Explorer resources DAO */
    protected ExplorerResourcesDAO _explorerResourcesDAO;
    
    /** Ametys resolver */
    protected AmetysObjectResolver _resolver;
    
    /** Observer manager. */
    protected ObservationManager _observationManager;
    
    /** The current user provider. */
    protected CurrentUserProvider _currentUserProvider;
    
    /** User manager */
    protected UserManager _userManager;
    
    /** The rights manager */
    protected RightManager _rightManager;
    /** The user helper */
    protected UserHelper _userHelper;
    
    private SAXParser _parser;

    public void service(ServiceManager manager) throws ServiceException
    {
        _explorerResourcesDAO = (ExplorerResourcesDAO) manager.lookup(ExplorerResourcesDAO.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _observationManager = (ObservationManager) manager.lookup(ObservationManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _userManager = (UserManager) manager.lookup(UserManager.ROLE);
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _parser = (SAXParser) manager.lookup(SAXParser.ROLE);
        _userHelper = (UserHelper) manager.lookup(UserHelper.ROLE);
    }

    
    /**
     * Get thread info
     * @param id The thread id
     * @param includeChildren True to also include children
     * @return the thread data in a map
     */
    @Callable
    public Map<String, Object> getThreadData(String id, boolean includeChildren)
    {
        JCRThread thread = (JCRThread) _resolver.resolveById(id);
        return getThreadData(thread, includeChildren);
    }
    
    /**
     * Get thread info
     * @param thread The thread
     * @param includeChildren True to also include children
     * @return the thread data in a map
     */
    public Map<String, Object> getThreadData(JCRThread thread, boolean includeChildren)
    {
        Map<String, Object> result = new HashMap<>();
        UserIdentity author = thread.getAuthor();
        
        result.put("id", thread.getId());
        result.put("title", thread.getTitle());
        result.put("description", thread.getDescription());
        result.put("author", _formatAuthor(author));
        result.put("authorLogin", author.getLogin());
        result.put("authorPopulation", author.getPopulationId());
        UserIdentity currentUser = _currentUserProvider.getUser();
        result.put("isAuthor", author.equals(currentUser));
        result.put("creationDate", ParameterHelper.valueToString(thread.getCreationDate()));
        result.put("unreadPosts", thread.getUnreadPosts(currentUser));
        
        Map<String, Object> rights = new HashMap<>();
        
        rights.put("threadEdit", _explorerResourcesDAO.getUserRight(currentUser, __RIGHTS_THREAD_EDIT, thread));
        rights.put("threadDelete", _explorerResourcesDAO.getUserRight(currentUser, __RIGHTS_THREAD_DELETE, thread));
        rights.put("postAdd", _explorerResourcesDAO.getUserRight(currentUser, __RIGHTS_POST_ADD, thread));
        result.put("rights", rights);
        
        if (includeChildren)
        {
            List<Map<String, Object>> childrenData = new LinkedList<>();
            result.put("posts", childrenData);
            
            AmetysObjectIterable<AmetysObject> children = thread.getChildren();
            for (AmetysObject child : children)
            {
                if (child instanceof JCRPost)
                {
                    JCRPost jcrPost = (JCRPost) child;
                    childrenData.add(getPostData(jcrPost, false, false));
                }
            }
        }
        
        return result;
    }
    
    /**
     * Return the author of a thread in a formatted version ready to be displayed to the end user.
     * @param userIdentity The author
     * @return The formatted string
     */
    protected String _formatAuthor(UserIdentity userIdentity)
    {
        User user = _userManager.getUser(userIdentity.getPopulationId(), userIdentity.getLogin());
        String name = user == null ? userIdentity.getLogin() : user.getFullName() + " (" + userIdentity.getLogin() + ")"; 
        return name;
    }
    
    /**
     * Get post info
     * @param ids The post ids
     * @param fullInfo true to include full info (rights, parent id, etc...)
     * @param isEdition true to get the content in edit mode
     * @return the list of post data
     */
    @Callable
    public List<Map<String, Object>> getPostsDataByIds(List<String> ids, boolean fullInfo, boolean isEdition)
    {
        List<JCRPost> posts = new LinkedList<>();
        for (String id : ids)
        {
            posts.add((JCRPost) _resolver.resolveById(id));
        }
        
        return getPostsData(posts, fullInfo, isEdition);
    }
    
    /**
     * Get post info
     * @param posts The posts
     * @param fullInfo true to include full info (rights, parent id, etc...)
     * @param isEdition true to get the content in edit mode
     * @return the list of post data
     */
    public List<Map<String, Object>> getPostsData(List<JCRPost> posts, boolean fullInfo, boolean isEdition)
    {
        List<Map<String, Object>> result = new LinkedList<>();
        
        for (JCRPost post : posts)
        {
            result.add(getPostData(post, fullInfo, isEdition));
        }
        
        return result;
    }
    
    /**
     * Get post info
     * @param id The post id
     * @param fullInfo true to include full info (rights, parent id, etc...)
     * @param isEdition true to get the content in edit mode
     * @return the post data in a map
     */
    @Callable
    public Map<String, Object> getPostDataById(String id, boolean fullInfo, boolean isEdition)
    {
        JCRPost post = (JCRPost) _resolver.resolveById(id);
        return getPostData(post, fullInfo, isEdition);
    }
    
    /**
     * Get post info
     * @param post The post
     * @param fullInfo true to include full info (rights, parent id, etc...)
     * @param isEdition true to get the content in edit mode
     * @return the post data in a map
     */
    public Map<String, Object> getPostData(JCRPost post, boolean fullInfo, boolean isEdition)
    {
        Map<String, Object> result = new HashMap<>();
        
        UserIdentity author = post.getAuthor();
        boolean isOwner = author.equals(_currentUserProvider.getUser());
        
        result.put("id", post.getId());
        result.put("content", isEdition ? getPostContentForEditing(post) : getPostContent(post));
        result.put("author", _userHelper.user2json(author));
        result.put("isOwner", isOwner);
        
        result.put("creationDate", ParameterHelper.valueToString(post.getCreationDate()));
        result.put("lastModifiedDate", ParameterHelper.valueToString(post.getLastModified()));
        
        result.put("canEdit", canEdit(post));
        result.put("canDelete", canDelete(post));
        
        if (fullInfo)
        {
            result.putAll(_getPostDataFullInfo(post));
        }
        
        return result;
    }
    
    /**
     * Determines if the post can be edited by current user
     * @param post The post
     * @return true if the post can be edited
     */
    protected boolean canEdit(JCRPost post)
    {
        boolean isOwner = post.getAuthor().equals(_currentUserProvider.getUser());
        return isOwner || _explorerResourcesDAO.getUserRight(_currentUserProvider.getUser(), __RIGHTS_POST_EDIT, post);
    }
    
    /**
     * Determines if the post can be deleted by current user
     * @param post The post
     * @return true if the post can be deleted
     */
    protected boolean canDelete(JCRPost post)
    {
        boolean isOwner = post.getAuthor().equals(_currentUserProvider.getUser());
        return isOwner || _explorerResourcesDAO.getUserRight(_currentUserProvider.getUser(), __RIGHTS_POST_DELETE, post);
    }
    
    /**
     * Convert the content of a post to a string (removing HTML tags)
     * @param post The post
     * @return the content of the post as string.
     */
    public String convertPostToString (JCRPost post)
    {
        try
        {
            PostRichTextHandler txtHandler = new PostRichTextHandler();
            _parser.parse(new InputSource(post.getContent().getInputStream()), txtHandler);
            return txtHandler.getValue().trim();
        }
        catch (IOException | SAXException e)
        {
            getLogger().error("Cannot parse inputstream", e);
            return null;
        }
    }
    
    /**
     * Retrieves the post additional info (rights, parent id, etc...)
     * @param post The post
     * @return the post additional info (rights, parent id, etc...) in a map
     */
    protected Map<String, Object> _getPostDataFullInfo(JCRPost post)
    {
        Map<String, Object> result = new HashMap<>();
        
        ExplorerNode explorerNode = post.getParent();
        ExplorerNode root = explorerNode;
        while (true)
        {
            if (root.getParent() instanceof ExplorerNode)
            {
                root = root.getParent();
            }
            else
            {
                break;
            }
        }
        result.put("rootId", root.getId());
        result.put("parentId", explorerNode.getId());
        result.put("name", post.getName());
        result.put("path", explorerNode.getExplorerPath());
        result.put("isModifiable", true);
        
        result.put("rights", _getUserRights(explorerNode));
        
        return result;
    }
    
    /**
     * Get the user rights on the resource collection
     * @param node The explorer node
     * @return The user's rights
     */
    protected Set<String> _getUserRights(ExplorerNode node)
    {
        UserIdentity user = _currentUserProvider.getUser();
        return _rightManager.getUserRights(user, node);
    }
    
    /**
     * Add a thread
     * @param id The identifier of the parent in which the thread will be added
     * @param inputName The desired name for the thread
     * @param inputDescription The thread description
     * @return The result map with id, parentId and name keys
     * @throws IllegalAccessException If the user has no sufficient rights
     */
    @Callable
    public Map<String, Object> addThread(String id, String inputName, String inputDescription) throws IllegalAccessException
    {
        Map<String, Object> result = new HashMap<>();
        
        String originalName = inputName;
        String description = inputDescription.replaceAll("\\r\\n|\\r|\\n", "<br />");
        assert id != null;
        
        AmetysObject object = _resolver.resolveById(id);
        if (!(object instanceof ModifiableResourceCollection || object instanceof JCRThread))
        {
            throw new IllegalClassException(ModifiableResourceCollection.class, object.getClass());
        }
        
        ModifiableTraversableAmetysObject parent = (ModifiableTraversableAmetysObject) object;
        
        // Check user right
        _explorerResourcesDAO.checkUserRight(object, __RIGHTS_THREAD_ADD);
        
        if (!_explorerResourcesDAO.checkLock(parent))
        {
            getLogger().warn("User '" + _currentUserProvider.getUser() + "' try to modify thread '" + object.getName() + "' but it is locked by another user");
            result.put("message", "locked");
            return result;
        }
        
        int index = 2;
        String name = originalName;
        while (parent.hasChild(name))
        {
            name = originalName + " (" + index + ")";
            index++;
        }
        
        JCRThread thread = parent.createChild(name, JCRThreadFactory.THREAD_NODETYPE);
        thread.setTitle(originalName);
        thread.setDescription(description);
        thread.setAuthor(_currentUserProvider.getUser());
        Date now = new Date();
        thread.setCreationDate(now);
        
        parent.saveChanges();
        
        result.put("id", thread.getId());
        result.put("parentId", id);
        result.put("name", name);
        
        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_ID, thread.getId());
        eventParams.put(ObservationConstants.ARGS_THREAD, thread);
        _observationManager.notify(new Event(ObservationConstants.EVENT_THREAD_CREATED, _currentUserProvider.getUser(), eventParams));
        
        return result;
    }
    
    /**
     * Edit a thread
     * @param id The identifier of the thread
     * @param inputName The new name
     * @param inputDescription The new description
     * @return The result map with id and name keys
     * @throws IllegalAccessException If the user has no sufficient rights
     */
    @Callable
    public Map<String, Object> editThread(String id, String inputName, String inputDescription) throws IllegalAccessException
    {
        Map<String, Object> result = new HashMap<>();
        
        String description = inputDescription.replaceAll("\\r\\n|\\r|\\n", "<br />");
        assert id != null;
        
        AmetysObject object = _resolver.resolveById(id);
        if (!(object instanceof JCRThread))
        {
            throw new IllegalClassException(JCRThread.class, object.getClass());
        }
        
        JCRThread thread = (JCRThread) object;
        
        // Check user right
        if (!_currentUserProvider.getUser().equals(thread.getAuthor()))
        {
            _explorerResourcesDAO.checkUserRight(object, __RIGHTS_THREAD_EDIT);
        }
        
        if (!_explorerResourcesDAO.checkLock(thread))
        {
            getLogger().warn("User '" + _currentUserProvider.getUser() + "' try to modify thread '" + object.getName() + "' but it is locked by another user");
            result.put("message", "locked");
            return result;
        }
        
        String originalName = inputName;
        String name = originalName;
        if (!name.equals(thread.getName()))
        {
            ModifiableTraversableAmetysObject parent = (ModifiableTraversableAmetysObject) thread.getParent();
            int index = 2;
            while (parent.hasChild(name))
            {
                name = originalName + " (" + index + ")";
                index++;
            }
            thread.rename(name);
        }
        
        
        thread.setTitle(name);
        if (description != null)
        {
            thread.setDescription(description);
        }
        
        thread.saveChanges();

        result.put("id", thread.getId());
        result.put("title", name);

        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_ID, thread.getId());
        eventParams.put(ObservationConstants.ARGS_THREAD, thread);
        _observationManager.notify(new Event(ObservationConstants.EVENT_THREAD_UPDATED, _currentUserProvider.getUser(), eventParams));

        return result;
    }
    
    /**
     * Rename a thread
     * @param id The id of the thread
     * @param name The thread name
     * @return The result map with id, name and message keys
     * @throws IllegalAccessException If the user has no sufficient rights
     */
    @Callable
    public Map<String, Object> renameThread(String id, String name) throws IllegalAccessException
    {
        Map<String, Object> result = new HashMap<>();

        assert id != null;
        
        AmetysObject object = _resolver.resolveById(id);
        if (!(object instanceof JCRThread))
        {
            throw new IllegalClassException(JCRThread.class, object.getClass());
        }
        
        JCRThread thread = (JCRThread) object;
        
        // Check user right
        if (!_currentUserProvider.getUser().equals(thread.getAuthor()))
        {
            _explorerResourcesDAO.checkUserRight(object, __RIGHTS_THREAD_EDIT);
        }
        
        if (!_explorerResourcesDAO.checkLock(thread))
        {
            getLogger().warn("User '" + _currentUserProvider.getUser() + "' try to modify thread '" + object.getName() + "' but it is locked by another user");
            result.put("message", "locked");
            return result;
        }
        
        if (!name.equals(thread.getName()))
        {
            ModifiableTraversableAmetysObject parent = (ModifiableTraversableAmetysObject) thread.getParent();
            if (parent.hasChild(name))
            {
                result.put("message", "already-exist");
                return result;
            }
            thread.rename(name);
        }
        
        thread.setTitle(name);
        thread.saveChanges();

        result.put("id", thread.getId());
        result.put("name", name);

        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_ID, thread.getId());
        eventParams.put(ObservationConstants.ARGS_THREAD, thread);
        _observationManager.notify(new Event(ObservationConstants.EVENT_THREAD_RENAMED, _currentUserProvider.getUser(), eventParams));

        return result;
    }
    
    /**
     * Delete a thread
     * @param id The id of the thread
     * @return The result map with id, parent id and message keys
     * @throws IllegalAccessException If the user has no sufficient rights
     */
    @Callable
    public Map<String, Object> deleteThread(String id) throws IllegalAccessException
    {
        Map<String, Object> result = new HashMap<>();

        assert id != null;
        
        AmetysObject object = _resolver.resolveById(id);
        if (!(object instanceof JCRThread))
        {
            throw new IllegalClassException(JCRThread.class, object.getClass());
        }
        
        JCRThread thread = (JCRThread) object;
        
        // Check user right
        if (!_currentUserProvider.getUser().equals(thread.getAuthor()))
        {
            _explorerResourcesDAO.checkUserRight(object, __RIGHTS_THREAD_DELETE);
        }
        
        if (!_explorerResourcesDAO.checkLock(thread))
        {
            getLogger().warn("User '" + _currentUserProvider.getUser() + "' try to modify thread '" + object.getName() + "' but it is locked by another user");
            result.put("message", "locked");
            return result;
        }
        
        ModifiableExplorerNode parent = thread.getParent();
        String parentId = parent.getId();
        String name = thread.getName();
        String path = thread.getPath();
        
        thread.remove();
        parent.saveChanges();

        result.put("id", id);
        result.put("parentId", parentId);
     
        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_ID, id);
        eventParams.put(ObservationConstants.ARGS_PARENT_ID, parentId);
        eventParams.put(ObservationConstants.ARGS_NAME, name);
        eventParams.put(ObservationConstants.ARGS_PATH, path);
        _observationManager.notify(new Event(ObservationConstants.EVENT_THREAD_DELETED, _currentUserProvider.getUser(), eventParams));
        
        return result;
    }
    
    /**
     * Add a post
     * @param threadId The identifier of the thread in which the post will be added
     * @param inputContent The post content
     * @return The result map with id, parentId and message keys
     * @throws IllegalAccessException If the user has no sufficient rights
     * @throws IOException If an error occurs
     */
    @Callable
    public Map<String, Object> addPost(String threadId, String inputContent) throws IllegalAccessException, IOException
    {
        Map<String, Object> result = new HashMap<>();
        
        String name = JCRPostFactory.POST_NODENAME;
        assert threadId != null;
        
        AmetysObject object = _resolver.resolveById(threadId);
        if (!(object instanceof JCRThread))
        {
            throw new IllegalClassException(JCRThread.class, object.getClass());
        }
        
        JCRThread parent = (JCRThread) object;
        
        // Check user right
        if (!_currentUserProvider.getUser().equals(parent.getAuthor()))
        {
            _explorerResourcesDAO.checkUserRight(object.getParent(), __RIGHTS_POST_ADD);
        }
        
        if (!_explorerResourcesDAO.checkLock(parent))
        {
            getLogger().warn("User '" + _currentUserProvider.getUser() + "' try to add a post '" + parent.getName() + "' but thread is locked by another user");
            result.put("message", "locked");
            return result;
        }
        
        JCRPost post = parent.createChild(name, JCRPostFactory.POST_NODETYPE);
        
        setPostContent(post, inputContent);
        
        post.setAuthor(_currentUserProvider.getUser());
        Date now = new Date();
        post.setCreationDate(now);
        post.setLastModified(now);
        
        parent.markAsRead(_currentUserProvider.getUser());
        
        parent.saveChanges();
        
        result.put("id", post.getId());
        result.put("parentId", threadId);
        result.put("name", name);
        
        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_ID, post.getId());
        eventParams.put(ObservationConstants.ARGS_THREAD, parent);
        eventParams.put(ObservationConstants.ARGS_POST, post);
        _observationManager.notify(new Event(ObservationConstants.EVENT_THREAD_POST_CREATED, _currentUserProvider.getUser(), eventParams));
        
        return result;
    }
    
    /**
     * Update the content of a post
     * @param post The post to update
     * @param content The content as string
     */
    protected void setPostContent(JCRPost post, String content)
    {
        try
        {
            ModifiableRichText richText = post.getContent();
            
            richText.setMimeType("text/plain");
            richText.setLastModified(new Date());
            richText.setInputStream(new ByteArrayInputStream(content.getBytes("UTF-8")));
        }
        catch (IOException e)
        {
            throw new AmetysRepositoryException("Failed to set post rich text", e);
        }
    }
    
    /**
     * Get the content of a post as a String
     * @param post the post
     * @return The content as String
     * @throws AmetysRepositoryException if failed to parse content
     */
    protected String getPostContent(JCRPost post) throws AmetysRepositoryException
    {
        try
        {
            ModifiableRichText richText = post.getContent();
            return IOUtils.toString(richText.getInputStream(), "UTF-8");
        }
        catch (IOException e)
        {
            throw new AmetysRepositoryException("Failed to get post rich text", e);
        }
    }
    
    /**
     * Get the content of a post to edit as a String
     * @param post the post
     * @return The content as String
     * @throws AmetysRepositoryException if failed to parse content
     */
    protected String getPostContentForEditing(JCRPost post) throws AmetysRepositoryException
    {
        return getPostContent(post);
    }
    
    /**
     * Edit a post
     * @param id The identifier of the post
     * @param inputContent The post content
     * @return The result map with id, parentId and message keys
     * @throws IllegalAccessException If the user has no sufficient rights
     * @throws IOException If an error occurs
     */
    @Callable
    public Map<String, Object> editPost(String id, String inputContent) throws IllegalAccessException, IOException
    {
        Map<String, Object> result = new HashMap<>();
        
        assert id != null;
        
        AmetysObject object = _resolver.resolveById(id);
        if (!(object instanceof JCRPost))
        {
            throw new IllegalClassException(JCRPost.class, object.getClass());
        }
        
        JCRPost post = (JCRPost) object;
        
        // Check user right
        if (!_currentUserProvider.getUser().equals(post.getAuthor()))
        {
            _explorerResourcesDAO.checkUserRight(object.getParent(), __RIGHTS_POST_EDIT);
        }
                
        if (!_explorerResourcesDAO.checkLock(post))
        {
            getLogger().warn("User '" + _currentUserProvider.getUser() + "' try to modify post '" + object.getName() + "' but it is locked by another user");
            result.put("message", "locked");
            return result;
        }
        
        setPostContent(post, inputContent);
        
        Date now = new Date();
        post.setLastModified(now);
        
        post.saveChanges();

        result.put("id", post.getId());
        result.put("content", getPostContent(post));
        
        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_ID, post.getId());
        eventParams.put(ObservationConstants.ARGS_THREAD, post.getParent());
        eventParams.put(ObservationConstants.ARGS_POST, post);
        _observationManager.notify(new Event(ObservationConstants.EVENT_THREAD_POST_UPDATED, _currentUserProvider.getUser(), eventParams));
        
        return result;
    }
    
    /**
     * Delete a post
     * @param id The id of the post
     * @return The result map with id, parent id and message keys
     * @throws IllegalAccessException If the user has no sufficient rights
     */
    @Callable
    public Map<String, Object> deletePost(String id) throws IllegalAccessException
    {
        Map<String, Object> result = new HashMap<>();

        assert id != null;
        
        AmetysObject object = _resolver.resolveById(id);
        if (!(object instanceof JCRPost))
        {
            throw new IllegalClassException(JCRPost.class, object.getClass());
        }
        
        JCRPost post = (JCRPost) object;
        
        // Check user right
        if (!_currentUserProvider.getUser().equals(post.getAuthor()))
        {
            _explorerResourcesDAO.checkUserRight(object.getParent(), __RIGHTS_POST_DELETE);
        }
        
        if (!_explorerResourcesDAO.checkLock(post))
        {
            getLogger().warn("User '" + _currentUserProvider.getUser() + "' try to delete thread '" + object.getName() + "' but it is locked by another user");
            result.put("message", "locked");
            return result;
        }
        
        ModifiableExplorerNode parent = post.getParent();
        String parentId = parent.getId();
        String name = post.getName();
        String path = post.getPath();
        
        post.remove();
        parent.saveChanges();

        result.put("id", id);
        result.put("parentId", parentId);
     
        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_ID, id);
        eventParams.put(ObservationConstants.ARGS_THREAD, parent);
        eventParams.put(ObservationConstants.ARGS_NAME, name);
        eventParams.put(ObservationConstants.ARGS_PATH, path);
        _observationManager.notify(new Event(ObservationConstants.EVENT_THREAD_POST_DELETED, _currentUserProvider.getUser(), eventParams));
        
        return result;
    }
    
    /**
     * Mark a thread as read by the current user
     * @param id The thread id
     * @return The result map with id, parent id and message keys
     */
    @Callable
    public Map<String, Object> markAsRead(String id)
    {
        Map<String, Object> result = new HashMap<>();
        
        assert id != null;
        
        AmetysObject object = _resolver.resolveById(id);
        if (!(object instanceof JCRThread))
        {
            throw new IllegalClassException(JCRThread.class, object.getClass());
        }
        
        JCRThread thread = (JCRThread) object;
        
        if (!_explorerResourcesDAO.checkLock(thread))
        {
            getLogger().warn("User '" + _currentUserProvider.getUser() + "' try to modify thread '" + object.getName() + "' but it is locked by another user");
            result.put("message", "locked");
            return result;
        }
        
        UserIdentity user = _currentUserProvider.getUser();
        thread.markAsRead(user);
        
        thread.saveChanges();

        result.put("id", thread.getId());
        return result;
    }
    
}