/******************************************************************************
 * Copyright (c) 2002, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    IBM Corporation - initial API and implementation 
 ****************************************************************************/

package org.eclipse.gmf.runtime.diagram.core.listener;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EAnnotation;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.transaction.NotificationFilter;
import org.eclipse.emf.transaction.ResourceSetChangeEvent;
import org.eclipse.emf.transaction.ResourceSetListenerImpl;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.workspace.EMFOperationCommand;
import org.eclipse.gmf.runtime.diagram.core.internal.commands.PersistViewsCommand;
import org.eclipse.gmf.runtime.diagram.core.services.DiagramEventBrokerService;
import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.View;


/**
 * A model server listener that broadcast EObject events to all registered
 * listeners.
 * 
 * @author melaasar, mmostafa, cmahoney
 */
public class DiagramEventBroker
    extends ResourceSetListenerImpl {

    private static String LISTEN_TO_ALL_FEATURES = "*"; //$NON-NLS-1$

    /** listener map */
    private final NotifierToKeyToListenersSetMap preListeners = new NotifierToKeyToListenersSetMap();

    private final NotifierToKeyToListenersSetMap postListeners = new NotifierToKeyToListenersSetMap();

    private static final Map instanceMap = new WeakHashMap();
    
    private WeakReference editingDomainRef;
    
    /**
     * returns the pre commit listeners map
     * @return pre commit listeners map
     */
    protected NotifierToKeyToListenersSetMap getPreCommitListenersMap() {
        return preListeners;
    }
    
    /**
     * returns the post commit listeners map
     * @return post commit listeners map
     */
    protected NotifierToKeyToListenersSetMap getPostCommitListenersMap() {
        return postListeners;
    }

    /**
     * Utility class representing a Map of Notifier to a Map of Keys to a Set of
     * listener
     * 
     * @author mmostafa
     */
    public final class NotifierToKeyToListenersSetMap {

        /**
         * internal map to hold the listeners
         */
        private final Map listenersMap = new WeakHashMap();

        /**
         * Adds a listener to the map
         * 
         * @param notifier
         *            the notifier the listener will listen to
         * @param key
         *            a key for the listener, this help in categorizing the
         *            listeners based on their interest
         * @param listener
         *            the listener
         */
        public void addListener(EObject notifier, Object key, Object listener) {
            Map keys = (Map) listenersMap.get(notifier);
            if (keys == null) {
                keys = new HashMap(4);
                listenersMap.put(notifier, keys);
            }
            Map listenersSet = (Map) keys.get(key);
            if (listenersSet == null) {
                listenersSet = new LinkedHashMap(4);
                keys.put(key, listenersSet);
            }
            listenersSet.put(listener,null);
        }

        /**
         * Adds a listener to the notifier; this listener is added againest a
         * generic key, <code>LISTEN_TO_ALL_FEATURES<code>
         * so it can listen to all events on the notifier 
         * @param notifier the notifier the listener will listen to
         * @param listener the listener
         */
        public void addListener(EObject notifier, Object listener) {
            addListener(notifier, LISTEN_TO_ALL_FEATURES, listener);
        }

        /**
         * removes a listener from the map
         * 
         * @param notifier
         * @param key
         * @param listener
         */
        public void removeListener(EObject notifier, Object key, Object listener) {
            Map keys = (Map) listenersMap.get(notifier);
            if (keys != null) {
                Map listenersSet = (Map) keys.get(key);
                if (listenersSet != null) {
                    listenersSet.remove(listener);
                    if (listenersSet.isEmpty()) {
                        keys.remove(key);
                    }
                }
                if (keys.isEmpty())
                    listenersMap.remove(notifier);
            }
        }

        /**
         * get listeners interested in the passed notifier and key
         * 
         * @param notifier
         * @param key
         * @return <code>Set</code> of listeners
         */
        public Set getListeners(Object notifier, Object key) {
            Map keys = (Map) listenersMap.get(notifier);
            if (keys != null) {
                Map listenersSet = (Map) keys.get(key);
                if (listenersSet != null) {
                    return listenersSet.keySet();
                }
            }
            return Collections.EMPTY_SET;
        }

        /**
         * return all listeners interested in the passed notifier
         * 
         * @param notifier
         * @return
         */
        public Set getAllListeners(Object notifier) {
            Map keys = (Map) listenersMap.get(notifier);
            if (keys == null || keys.isEmpty()) {
                return Collections.EMPTY_SET;
            }
            Set listenersCollection = new LinkedHashSet();
            Set enteries = keys.entrySet();
            for (Iterator iter = enteries.iterator(); iter.hasNext();) {
                Map.Entry entry = (Map.Entry) iter.next();
                Map listenersSet = (Map) entry.getValue();
                if (listenersSet != null && !listenersSet.isEmpty())
                    listenersCollection.addAll(listenersSet.keySet());
            }
            return listenersCollection;
        }
        
        public boolean isEmpty() {
            return listenersMap.isEmpty();
        }
    }

    /**
     * Creates a <code>DiagramEventBroker</code> that listens to all
     * <code>EObject </code> notifications for the given editing domain.
     */
    protected DiagramEventBroker() {
        super(NotificationFilter.createNotifierTypeFilter(EObject.class));
    }    
    

    /**
     * Gets the diagmam event broker instance for the editing domain passed in.
     * There is one diagram event broker per editing domain.
     * 
     * @param editingDomain
     * @return Returns the diagram event broker.
     */
    public static DiagramEventBroker getInstance(
            TransactionalEditingDomain editingDomain) {
    	
    	return initializeDiagramEventBroker(editingDomain);
    }

    /**
     * Creates a new diagram event broker instance for the editing domain passed
     * in only if the editing domain does not already have a diagram event
     * broker. There is one diagram event broker per editing domain. Adds the
     * diagram event broker instance as a listener to the editing domain.
     * 
     * @param editingDomain
     */
    public static void startListening(TransactionalEditingDomain editingDomain) {
    	initializeDiagramEventBroker(editingDomain);
    }

	private static DiagramEventBroker initializeDiagramEventBroker(TransactionalEditingDomain editingDomain) {
        WeakReference reference = (WeakReference) instanceMap.get(editingDomain);
        if (reference == null) {
            DiagramEventBroker diagramEventBroker = DiagramEventBrokerService.getInstance().createDiagramEventBroker(editingDomain);
            if (null == diagramEventBroker)
                diagramEventBroker = debFactory.createDiagramEventBroker(editingDomain);
            if (diagramEventBroker.editingDomainRef == null) {
				diagramEventBroker.editingDomainRef = new WeakReference(
					editingDomain);
			}
            editingDomain.addResourceSetListener(diagramEventBroker);
            reference = new WeakReference(diagramEventBroker);
            instanceMap.put(editingDomain, reference);
        }
        return (DiagramEventBroker) reference.get();
	}
    
    /**
     * Factory interface that can be used to create overrides of the DiagramEventBroker class
     * @author sshaw
     */
    public static interface DiagramEventBrokerFactory {
    	/**
    	 * @param editingDomain the <code>TransactionalEditingDomain</code> that is associated
    	 * with the <code>DiagramEventBroker</code> instance.
    	 * @return the <code>DiagramEventBroker</code> instance.
    	 */
    	public DiagramEventBroker createDiagramEventBroker(TransactionalEditingDomain editingDomain); 
    }
    
    private static class DiagramEventBrokerFactoryImpl implements DiagramEventBrokerFactory {
    	public DiagramEventBroker createDiagramEventBroker(TransactionalEditingDomain editingDomain) {
            DiagramEventBroker diagramEventBroker =  new DiagramEventBroker();
            diagramEventBroker.editingDomainRef = new WeakReference(
                editingDomain);
            return diagramEventBroker;
    	}
    }
    
    private static DiagramEventBrokerFactory debFactory = new DiagramEventBrokerFactoryImpl();
    
    /**
     * @param newDebFactory
     */
    public static void registerDiagramEventBrokerFactory(DiagramEventBrokerFactory newDebFactory) {
    	debFactory = newDebFactory;
    }

    /**
     * @param editingDomain
     */
    public static void stopListening(TransactionalEditingDomain editingDomain) {
        DiagramEventBroker diagramEventBroker = getInstance(editingDomain);
        if (diagramEventBroker != null) {
            editingDomain.removeResourceSetListener(diagramEventBroker);
            instanceMap.remove(editingDomain);
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.emf.transaction.ResourceSetListenerImpl#transactionAboutToCommit(org.eclipse.emf.transaction.ResourceSetChangeEvent)
     */
    public Command transactionAboutToCommit(ResourceSetChangeEvent event) {
        Set deletedObjects = NotificationUtil.getDeletedObjects(event);
        Set addedObjects = NotificationUtil.getAddedObjects(event);
        Set existingObjects = new HashSet();
        Set elementsInPersistQueue = new LinkedHashSet();
        CompoundCommand cc = new CompoundCommand();
        TransactionalEditingDomain editingDomain = (TransactionalEditingDomain) editingDomainRef
            .get();
        boolean hasPreListeners = (preListeners.isEmpty() == false);
        List viewsToPersistList = new ArrayList();
        boolean deleteElementCheckRequired = !deletedObjects.isEmpty();
        for (Iterator i = event.getNotifications().iterator(); i.hasNext();) {
            final Notification notification = (Notification) i.next();
            if (shouldIgnoreNotification(notification))
                continue;
            Object notifier = notification.getNotifier();            
            if (notifier instanceof EObject) {
                boolean deleted = false;
                if (deleteElementCheckRequired){
                    deleted = !existingObjects.contains(notifier);
                    if (deleted){
                        deleted = isDeleted(deletedObjects, (EObject)notifier);
                        if (!deleted)
                            existingObjects.add(notifier);
                    }
                }
                // see bugzilla [186637]
            	if (deleted || 
                     (addedObjects.contains(notifier) && NotationPackage.Literals.VIEW__ELEMENT.equals(notification.getFeature()))) {
                    continue;
                }
                if (editingDomain != null) {
                    View viewToPersist = getViewToPersist(notification,
                        elementsInPersistQueue);
                    if (viewToPersist != null) {
                        viewsToPersistList.add(viewToPersist);
                    }
                }
                if (hasPreListeners) {
                    Command cmd = fireTransactionAboutToCommit(notification);
                    if (cmd != null) {
                        cc.append(cmd);
                    }
                }
            }
        }

        if (viewsToPersistList.isEmpty() == false) {
            PersistViewsCommand persistCmd = new PersistViewsCommand(
                editingDomain, viewsToPersistList);
            cc.append(new EMFOperationCommand(editingDomain, persistCmd));
        }

        return cc.isEmpty() ? null
            : cc;
    }
    
    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.emf.transaction.ResourceSetListenerImpl#resourceSetChanged(org.eclipse.emf.transaction.ResourceSetChangeEvent)
     */
    public void resourceSetChanged(ResourceSetChangeEvent event) {
    	if (postListeners.isEmpty()) {
            return;
        }
        Set deletedObjects = NotificationUtil.getDeletedObjects(event);
        Set addedObjects = NotificationUtil.getAddedObjects(event);
        Set existingObjects = new HashSet();
        boolean deleteElementCheckRequired = !deletedObjects.isEmpty();
        boolean handleNotificationOnAddedElement = false;
        boolean handleNotificationOnDeletedElement = false;
        for (Iterator i = event.getNotifications().iterator(); i.hasNext();) {
            final Notification notification = (Notification) i.next();
            boolean customNotification = NotificationUtil.isCustomNotification(notification);
            if (!customNotification && shouldIgnoreNotification(notification))
                continue;
            Object notifier = notification.getNotifier();
            if (notifier instanceof EObject) {
                boolean deleted = false;
                if (deleteElementCheckRequired && !customNotification) {
                    deleted = !existingObjects.contains(notifier);
                    if (deleted) {
                        deleted = isDeleted(deletedObjects, (EObject) notifier);
                        if (!deleted)
                            existingObjects.add(notifier);
                    }
                }
                if (!customNotification) {
                    if (deleted) {
                        handleNotificationOnDeletedElement = true;
                        continue;
                    }// see bugzilla [186637]
                    else if (addedObjects.contains(notifier) && NotationPackage.Literals.VIEW__ELEMENT.equals(notification.getFeature())){
                        handleNotificationOnAddedElement = true;
                        continue;
                    }
                }
                fireNotification(notification);
            }
        }
        if (handleNotificationOnAddedElement) {
            handleNotificationOnAddedElement(event);
        }
        if (handleNotificationOnDeletedElement) {
            handleNotificationOnDeletedElement(event);
        }
    }

    /**
     * This method allows clients to customize the Diagram event broker behavior when
     * it comes to handling events on added objects.
     * The default behavior will just ignore them
     * @param event being handled
     */
    protected void handleNotificationOnAddedElement(ResourceSetChangeEvent event) {
        // default implementation does nothing
        
    }

    /**
     * This method allows clients to customize the Diagram event broker behavior when
     * it comes to handling events on deleted objects.
     * The default behavior will just ignore them
     * @param event event being handled
     */
    protected void handleNotificationOnDeletedElement(ResourceSetChangeEvent event) {
        // default implementation does nothing
        
    }


    /**
     * decide if the passed object is deleted or not; the decision is done by 
     * checking is the passed notifier or any of its ancestors exists in the passed
     * deletedObjects Set, if it find the obnject to be deleted it will add it 
     * to the deleted objects set.
     * @param deletedObjects
     * @param notifier
     * @return
     */
    protected boolean isDeleted(Set deletedObjects, EObject notifier) {
        EObject object = notifier;
        while (object!=null){
            if (deletedObjects.contains(object)){
                if (object != notifier){
                    //so we do not waste time on the second call
                    addDeletedBranch(deletedObjects,notifier);
                }
                return true;
            }
            object = object.eContainer();
        }
        return false;
    }
    
    private void addDeletedBranch(Set deletedObjects, EObject notifier) {
        EObject object = notifier;
        while (object != null){
            if (!deletedObjects.add(object)){
                break;
            }
            object = object.eContainer();
        }
        
    }


    /**
     * determine if the passed notification can be ignored or not the default
     * implementation will ignore touch event if it is not a resolve event, also
     * it will ignore the mutable feature events
     * 
     * @param notification
     *            the notification to check
     * @return true if the notification should be ignored, otherwise false
     */
    protected boolean shouldIgnoreNotification(Notification notification) {
        if ((notification.isTouch() && notification.getEventType() != Notification.RESOLVE)
            || NotationPackage.eINSTANCE.getView_Mutable().equals(
                notification.getFeature())) {
            return true;
        }
        return false;
    }

    /**
     * Forward the supplied event to all listeners listening on the supplied
     * target element.
     * <P>
     * <B> Note, for the MSL migration effort, each listener will be forwarded 2
     * events. First, a MSL complient Notification event followed by an
     * ElementEvent (for backwards compatibility). The ElementEvent will be
     * removed one the MSL migration is complete.
     */
    protected void fireNotification(Notification event) {
        Collection listenerList = getInterestedNotificationListeners(event,
        	postListeners);
        if (!listenerList.isEmpty()) {			
			for (Iterator listenerIT = listenerList.iterator(); listenerIT
				.hasNext();) {
				NotificationListener listener = (NotificationListener) listenerIT
					.next();
				listener.notifyChanged(event);
			}
		}
    }

    /**
     * Forwards the event to all interested listeners.
     * 
     * @param event
     *            the event to handle
     * @p
     */
    private Command fireTransactionAboutToCommit(Notification event) {
        Collection listenerList = getInterestedNotificationListeners(event,
            preListeners);       
        if (!listenerList.isEmpty()) {
        	 CompoundCommand cc = new CompoundCommand();            
            for (Iterator listenerIT = listenerList.iterator(); listenerIT
                .hasNext();) {
                NotificationPreCommitListener listener = (NotificationPreCommitListener) listenerIT
                    .next();
                Command cmd = listener.transactionAboutToCommit(event);
                if (cmd != null) {
                    cc.append(cmd);
                }
            }
            return cc.isEmpty() ? null
            : cc;
        }
		return null;        
    }

    private View getViewToPersist(Notification event, Set elementsInPersistQueue) {
        if (!event.isTouch()) {
            EObject elementToPersist = (EObject) event.getNotifier();
            while (elementToPersist != null
                && !(elementToPersist instanceof View)) {
                elementToPersist = elementToPersist.eContainer();
            }
            if (elementToPersist != null
                && !elementsInPersistQueue.contains(elementToPersist)
                && ViewUtil.isTransient(elementToPersist)) {
                if (!NotificationFilter.READ.matches(event)) {
                    elementsInPersistQueue.add(elementToPersist);
                    View view = (View) elementToPersist;
                    if (!view.isMutable()) {
                        // get Top view needs to get persisted
                        View viewToPersist = ViewUtil.getTopViewToPersist(view);
                        if (viewToPersist != null) {                            
                            elementsInPersistQueue.add(viewToPersist);
                            return viewToPersist;
                        }
                    }
                }
            }
        }
        return null;
    }

    /**
     * Add the supplied <tt>listener</tt> to the listener list.
     * 
     * @param target
     *            the traget to listen to
     * @param listener
     *            the listener
     */
    public void addNotificationListener(EObject target,
            NotificationPreCommitListener listener) {
        if (target != null) {
            preListeners.addListener(target, LISTEN_TO_ALL_FEATURES, listener);
        }
    }

    /**
     * Add the supplied <tt>listener</tt> to the listener list.
     * 
     * @param target
     *            the traget to listen to
     * @param listener
     *            the listener
     */
    public void addNotificationListener(EObject target,
            NotificationListener listener) {
        if (target != null) {
            postListeners.addListener(target, LISTEN_TO_ALL_FEATURES, listener);
        }
    }

    /**
     * Add the supplied <tt>listener</tt> to the listener list.
     * 
     * @param target
     *            the traget to listen to
     * @param key
     *            the key for the listener
     * @param listener
     *            the listener
     */
    public void addNotificationListener(EObject target,
            EStructuralFeature key, NotificationPreCommitListener listener) {
        if (target != null) {
            preListeners.addListener(target, key, listener);
        }
    }

    /**
     * Add the supplied <tt>listener</tt> to the listener list.
     * 
     * @param target
     *            the traget to listen to
     * @param key
     *            the key for the listener
     * @param listener
     *            the listener
     */
    public void addNotificationListener(EObject target,
            EStructuralFeature key, NotificationListener listener) {
        if (target != null) {
            postListeners.addListener(target, key, listener);
        }
    }

    /**
     * remove the supplied <tt>listener</tt> from the listener list.
     * 
     * @param target
     *            the traget to listen to
     * @param listener
     *            the listener
     */
    public void removeNotificationListener(EObject target,
            NotificationPreCommitListener listener) {
        if (target != null) {
            preListeners.removeListener(target, LISTEN_TO_ALL_FEATURES,
                listener);
        }
    }

    /**
     * remove the supplied <tt>listener</tt> from the listener list.
     * 
     * @param target
     *            the traget to listen to
     * @param listener
     *            the listener
     */
    public void removeNotificationListener(EObject target,
            NotificationListener listener) {
        if (target != null) {
            postListeners.removeListener(target, LISTEN_TO_ALL_FEATURES,
                listener);
        }
    }

    /**
     * remove the supplied <tt>listener</tt> from the listener list.
     * 
     * @param target
     *            the traget to listen to
     * @param key
     *            the key for the listener
     * @param listener
     *            the listener
     */
    public void removeNotificationListener(EObject target, Object key,
            NotificationPreCommitListener listener) {
        if (target != null) {
            preListeners.removeListener(target, key, listener);
        }
    }

    /**
     * remove the supplied <tt>listener</tt> from the listener list.
     * 
     * @param target
     *            the traget to listen to
     * @param key
     *            the key for the listener
     * @param listener
     *            the listener
     */
    public void removeNotificationListener(EObject target, Object key,
            NotificationListener listener) {
        if (target != null) {
            postListeners.removeListener(target, key, listener);
        }
    }

    private Set getNotificationListeners(Object notifier, NotifierToKeyToListenersSetMap listeners) {       
        return listeners.getListeners(notifier, LISTEN_TO_ALL_FEATURES);
    }

    /**
     * @param notifier
     * @param key
     * @param preCommit
     * @return
     */
    private Set getNotificationListeners(Object notifier, Object key,
    		NotifierToKeyToListenersSetMap listeners) {
        if (key != null) {
            if (!key.equals(LISTEN_TO_ALL_FEATURES)) {
                Set listenersSet = new LinkedHashSet();
                Collection c = listeners.getListeners(notifier, key);
                if (c != null && !c.isEmpty())
                    listenersSet.addAll(c);
                c = listeners.getListeners(notifier, LISTEN_TO_ALL_FEATURES);
                if (c != null && !c.isEmpty())
                    listenersSet.addAll(c);
                return listenersSet;
            } else if (key.equals(LISTEN_TO_ALL_FEATURES)) {
                return listeners.getAllListeners(notifier);
            }
        }
        return listeners.getAllListeners(notifier);
    }

    /**
     * gets a subset of all the registered listeners who are interested in
     * receiving the supplied event.
     * 
     * @param event
     *            the event to use
     * @return the interested listeners in the event
     */
     protected Set getInterestedNotificationListeners(Notification event,
    		NotifierToKeyToListenersSetMap listeners) {
        Set listenerSet = new LinkedHashSet();

        Collection c = getNotificationListeners(event.getNotifier(), event
            .getFeature(), listeners);
        if (c != null) {
            listenerSet.addAll(c);
        }

        EObject notifier = (EObject) event.getNotifier();
        // the Visibility Event get fired to all interested listeners in the
        // container
        if (NotationPackage.eINSTANCE.getView_Visible().equals(
            event.getFeature())
            && notifier.eContainer() != null) {
            listenerSet.addAll(getNotificationListeners(notifier.eContainer(),
            	listeners));
        } else if (notifier instanceof EAnnotation) {
            addListenersOfNotifier(listenerSet, notifier.eContainer(), event,
            	listeners);
        } else if (!(notifier instanceof View)) {
            while (notifier != null && !(notifier instanceof View)) {
                notifier = notifier.eContainer();
            }
            addListenersOfNotifier(listenerSet, notifier, event, listeners);
        }
        return listenerSet;
    }
    
    public boolean isAggregatePrecommitListener() {
    	return true;
    }
    
    /**
     * Helper method to add all the listners of the given <code>notifier</code>
     * to the list of listeners
     * 
     * @param listenerSet
     * @param notifier
     */
    private void addListenersOfNotifier(Set listenerSet, EObject notifier,
            Notification event, NotifierToKeyToListenersSetMap listeners) {
        if (notifier != null) {
            Collection c = getNotificationListeners(notifier, event
                .getFeature(), listeners);
            if (c != null) {
                if (listenerSet.isEmpty())
                    listenerSet.addAll(c);
                else {
                    Iterator i = c.iterator();
                    while (i.hasNext()) {
                        Object o = i.next();
                        listenerSet.add(o);
                    }
                }
            }
        }
    }    
    
}