package cz.cuni.amis.utils.collections;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.LinkedList;

 import cz.cuni.amis.utils.listener.Listeners;

 /**

  * Wrapper for collections. It raises events when elements are added/removed 

  * from the collection.

  * @author Ik

  * @param <E>

  */

 public class ObservableCollection<E> implements Collection<E> {

     protected Collection<E> col = null;

     protected Listeners<CollectionEventListener> eventListeners = new Listeners<CollectionEventListener>();

     private abstract class ListenerNotifier implements Listeners.ListenerNotifier<CollectionEventListener> {

             public Collection what;

             public Collection where;

             public ListenerNotifier() {                    

             }

                 @Override

                 public Object getEvent() {

                         return what;

                 }

                 @Override

                 public abstract void notify(CollectionEventListener listener);

     }

     private ListenerNotifier preAddNotifier = new ListenerNotifier() {

                 @Override

                 public void notify(CollectionEventListener listener) {

                         listener.preAddEvent(what, where);

                 }

         };

         private ListenerNotifier postAddNotifier = new ListenerNotifier() {

                 @Override

                 public void notify(CollectionEventListener listener) {

                         listener.postAddEvent(what, where);

                 }

         };

          private ListenerNotifier preRemoveNotifier = new ListenerNotifier() {

                 @Override

                 public void notify(CollectionEventListener listener) {

                         listener.preRemoveEvent(what, where);

                 }

         };

         private ListenerNotifier postRemoveNotifier = new ListenerNotifier() {

                 @Override

                 public void notify(CollectionEventListener listener) {

                         listener.postRemoveEvent(what, where);

                 }

         };

     public void addCollectionListener(CollectionEventListener listener) {

         eventListeners.addStrongListener(listener);

     }

     public boolean removeCollectionListener(CollectionEventListener listener) {

         return eventListeners.removeListener(listener) > 0;

     }

     public ObservableCollection(Collection c) {

         col = c;

     }

     @Override

     public int size() {

         return col.size();

     }

     @Override

     public boolean isEmpty() {

         return col.isEmpty();

     }

     @Override

     public boolean contains(Object o) {

         return col.contains(o);

     }

     @Override

     public Iterator<E> iterator() {

         return col.iterator();

     }

     @Override

     public Object[] toArray() {

         return col.toArray();

     }

     @Override

     public <T> T[] toArray(T[] a) {

         return col.toArray(a);

     }

     @Override

     public boolean add(E e) {

         Collection add = Collections.singletonList(e);

         notifyPreAdd(add);

         boolean ret = col.add(e);

         notifyPostAdd(add);

         return ret;

     }

     @Override

     public boolean remove(Object o) {

         Collection rem = Collections.singletonList(o);

         notifyPreRemove(rem);

         boolean ret = col.remove(o);

         notifyPostRemove(rem);

         return ret;

     }

     @Override

     public boolean containsAll(Collection<?> c) {

         return col.containsAll(c);

     }

     @Override

     public boolean addAll(Collection<? extends E> c) {

         notifyPreAdd(c);

         boolean ret = col.addAll(c);

         notifyPostAdd(c);

         return ret;

     }

     @Override

     public boolean removeAll(Collection<?> c) {

         notifyPreRemove(c);

         boolean ret = col.removeAll(c);

         notifyPostRemove(c);

         return ret;

     }

     @Override

     public boolean retainAll(Collection<?> c) {

             // Compute difference

             Collection<Object> toRemove = new LinkedList<Object>();

             for (Object o : col) {

                     if (!c.contains(o)) {

                             toRemove.add(o);

                     }

             }

             notifyPreRemove(toRemove);

             boolean ret = col.retainAll(c);

             notifyPostRemove(toRemove);

             return ret;

     }

     @Override

     public void clear() {

             Collection<Object> copy = new ArrayList<Object>(col);

             notifyPreRemove(copy);

             col.clear();

             notifyPostRemove(copy);

     }

     protected synchronized void notifyPreAdd(Collection<? extends E> add) {

             preAddNotifier.what = add;

             preAddNotifier.where = this;

             eventListeners.notify(preAddNotifier);

     }

     protected synchronized void notifyPostAdd(Collection<? extends E> add) {

             postAddNotifier.what = add;

             postAddNotifier.where = this;

             eventListeners.notify(postAddNotifier);

     }

     protected synchronized void notifyPreRemove(Collection<?> remove) {

             preRemoveNotifier.what = remove;

             preRemoveNotifier.where = this;

             eventListeners.notify(preRemoveNotifier);

     }

     protected synchronized void notifyPostRemove(Collection<?> remove) {

             postRemoveNotifier.what = remove;

             postRemoveNotifier.where = this;

             eventListeners.notify(postRemoveNotifier);

     }

 }