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

import java.util.Map;
import java.util.regex.Pattern;

import javax.jcr.ItemExistsException;
import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.Repository;
import javax.jcr.Session;
import javax.jcr.Value;
import javax.jcr.observation.Event;
import javax.jcr.observation.EventIterator;
import javax.jcr.observation.EventListener;

import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.logger.Logger;
import org.apache.commons.collections.PredicateUtils;

import org.ametys.plugins.repository.jcr.NodeTypeHelper;
import org.ametys.web.WebConstants;
import org.ametys.web.synchronization.SynchronizeComponent;

/**
 * JCR {@link EventListener} for monitoring changes in the default workspace and reflect then in the live workspace
 */
public class LiveWorkspaceListener extends AbstractLogEnabled implements EventListener
{
    /** Avalon Role */
    public static final String ROLE = LiveWorkspaceListener.class.getName();
    
    private Repository _repository;

    private SynchronizeComponent _synchroComponent;
    
    private Pattern[] _excludedPaths;
    
    /**
     * Constructor
     * @param repository the JCR Repository
     * @param synchroHelper the synchronize helper
     * @param logger logger for traces
     */
    public LiveWorkspaceListener(Repository repository, SynchronizeComponent synchroHelper, Logger logger)
    {
        this(repository, synchroHelper, logger, null);
    }
    
    /**
     * Constructor
     * @param repository the JCR Repository
     * @param synchroHelper the synchronize helper
     * @param logger logger for traces
     * @param excludedPaths The pattern of paths to exclude
     */
    public LiveWorkspaceListener(Repository repository, SynchronizeComponent synchroHelper, Logger logger, Pattern[] excludedPaths)
    {
        _repository = repository;
        _synchroComponent = synchroHelper;
        enableLogging(logger);
        _excludedPaths = excludedPaths;
    }
    
    @Override
    public void onEvent(EventIterator events)
    {
        Session session = null;
        Session liveSession = null;

        try
        {
            session = _repository.login();
            liveSession = _repository.login(WebConstants.LIVE_WORKSPACE);
            
            while (events.hasNext())
            {
                Event event = events.nextEvent();
                String path = event.getPath();
                
                if (_isValidPath(path))
                {
                    _switchOnType(session, liveSession, event, path);
                }
            }
            
            if (liveSession.hasPendingChanges())
            {
                liveSession.save();
            }
        }
        catch (Exception e)
        {
            getLogger().warn("Unable to synchronize live workspace", e);
        }
        finally
        {
            if (session != null)
            {
                session.logout();
            }
            
            if (liveSession != null)
            {
                liveSession.logout();
            }
        }
    }
    
    private boolean _isValidPath (String path)
    {
        if (_excludedPaths == null || _excludedPaths.length == 0)
        {
            return true;
        }
        
        for (Pattern pattern : _excludedPaths)
        {
            if (pattern.matcher(path).matches())
            {
                return false;
            }
        }
        
        return true;
        
    }

    private void _switchOnType(Session session, Session liveSession, Event event, String path) throws Exception
    {
        switch (event.getType())
        {
            case Event.NODE_ADDED :
                Node node = (Node) session.getItem(path);
                String parentPath = node.getParent().getPath();

                if (liveSession.itemExists(parentPath) && !liveSession.itemExists(path) && !NodeTypeHelper.getNodeTypeName(node).startsWith("oswf:") && !node.isNodeType("ametys:content"))
                {
                    // if source node exists and parent dest node also exists, copy the whole sub tree
                    // do not simply copy the node, as events may be unordered
                    Node parentNode = (Node) liveSession.getItem(parentPath);
                    
                    try
                    {
                        Node clonedNode = _synchroComponent.addNodeWithUUID(node, parentNode, node.getName());
                        _synchroComponent.cloneNodeAndPreserveUUID(node, clonedNode, PredicateUtils.truePredicate(), PredicateUtils.truePredicate());
                    }
                    catch (ItemExistsException ex)
                    {
                        // in case of moved nodes, we may receive first a "node added" event, then a "node moved" event.
                        // in that case, the addNodeWithUUID fail. Just ignore it.
                    }
                }
                
                break;
            case Event.NODE_MOVED :
                _nodeMoved(liveSession, event, path);
                break;
            case Event.NODE_REMOVED :
                if (liveSession.nodeExists(path) && !session.nodeExists(path))
                {
                    liveSession.getItem(path).remove();
                }
                break;
            case Event.PROPERTY_REMOVED :
                if (liveSession.propertyExists(path) && !session.propertyExists(path))
                {
                    liveSession.getItem(path).remove();
                }
                break;
            case Event.PROPERTY_ADDED :
            case Event.PROPERTY_CHANGED :
                Property property = (Property) session.getItem(path);
                String name = property.getName();
                String parent = property.getParent().getPath();
                
                if (liveSession.itemExists(parent) && !property.getDefinition().isProtected() && !property.getName().startsWith("oswf:"))
                {
                    if (property.isMultiple())
                    {
                        Value[] values = property.getValues();
                        ((Node) liveSession.getItem(parent)).setProperty(name, values);
                    }
                    else
                    {
                        Value value = property.getValue();
                        ((Node) liveSession.getItem(parent)).setProperty(name, value);
                    }
                }
                
                break;
            default :
                break;
        }
    }
    
    private void _nodeMoved(Session liveSession, Event event, String path) throws Exception
    {
        Map<String, String> info = event.getInfo();
        String srcChildRelPath = info.get("srcChildRelPath");
        
        if (srcChildRelPath != null)
        {
            // in case of Node.orderBefore()
            if (liveSession.nodeExists(path))
            {
                Node parentNode = liveSession.getItem(path).getParent();
                
                String destChildRelPath = info.get("destChildRelPath");
                
                if (parentNode.hasNode(srcChildRelPath))
                {
                    parentNode.orderBefore(srcChildRelPath, destChildRelPath);
                }
            }
        }
        else
        {
            // in case of Session.move() or Workspace.move()
            String srcAbsPath = info.get("srcAbsPath");
            String destAbsPath = info.get("destAbsPath");
            if (liveSession.itemExists(srcAbsPath) && !liveSession.itemExists(destAbsPath))
            {
                liveSession.move(srcAbsPath, destAbsPath);
            }
        }
    }
}