package org.webslinger.io;

 import java.io.IOException;

 import java.util.HashSet;

 import java.util.concurrent.ConcurrentHashMap;

 import org.webslinger.util.BinTimer;

 public abstract class AbstractMonitor<I, M extends AbstractMonitor<I, M, W, L>, W extends AbstractMonitor.Watched<I, M, W, L>, L extends Monitor.Listener<I>> implements Monitor<I, L> {

     protected final ConcurrentHashMap<I, WatchedListener<I, M, W, L>> watches = new ConcurrentHashMap<I, WatchedListener<I, M, W, L>>();

     protected AbstractMonitor() {

     }

     public void add(I item, L listener) throws IOException {

         WatchedListener<I, M, W, L> oldWl, newWl;

         do {

             oldWl = watches.get(item);

             if (oldWl == null) {

                 W watched = createWatched(item);

                 newWl = new WatchedListener<I, M, W, L>(watched, listener);

                 if (watches.putIfAbsent(item, newWl) != null) continue;

                 activate(watched);

                 break;

             }

             newWl = oldWl.add(listener);

         } while (!watches.replace(item, oldWl, newWl));

     }

     public void remove(I item, L listener) throws IOException {

         WatchedListener<I, M, W, L> oldWl, newWl;

         do {

             oldWl = watches.get(item);

             if (oldWl == null) break;

             newWl = oldWl.remove(listener);

             if (newWl == oldWl) break;

             if (newWl == null) {

                 if (!watches.remove(item, oldWl)) continue;

                 deactivate(oldWl.watched);

                 break;

             }

         } while (!watches.replace(item, oldWl, newWl));

     }

     protected W getWatched(I item) {

         WatchedListener<I, M, W, L> wl = watches.get(item);

         return wl != null ? wl.watched : null;

     }

     protected void fireEvent(I item, Listener.Event event) {

         WatchedListener<I, M, W, L> wl = watches.get(item);

         if (wl == null) return;

         for (L listener: wl.listeners) listener.acceptEvent(item, event);

     }

     protected abstract void activate(W watched) throws IOException;

     protected abstract void deactivate(W watched) throws IOException;

     protected abstract W createWatched(I item) throws IOException;

     public static class WatchedListener<I, M extends AbstractMonitor<I, M, W, L>, W extends Watched<I, M, W, L>, L extends Listener<I>> {

         protected final W watched;

         protected final HashSet<L> listeners;

         protected WatchedListener(W watched, L listener) throws IOException {

             this.watched = watched;

             watched.init();

             listeners = new HashSet<L>();

             listeners.add(listener);

         }

         protected WatchedListener(W watched, HashSet<L> listeners) {

             this.watched = watched;

             this.listeners = listeners;

         }

         protected WatchedListener<I, M, W, L> add(L listener) {

             if (listeners.contains(listener)) return this;

             HashSet<L> newListeners = new HashSet<L>(listeners);

             newListeners.add(listener);

             return new WatchedListener<I, M, W, L>(watched, newListeners);

         }

         protected WatchedListener<I, M, W, L> remove(Listener<I> listener) {

             if (!listeners.contains(listener)) return this;

             HashSet<L> newListeners = new HashSet<L>(listeners);

             newListeners.remove(listener);

             if (newListeners.isEmpty()) return null;

             return new WatchedListener<I, M, W, L>(watched, newListeners);

         }

     }

     public static abstract class Watched<I, M extends AbstractMonitor<I, M, W, L>, W extends Watched<I, M, W, L>, L extends Listener<I>> {

         protected final M monitor;

         protected Watched(M monitor) {

             this.monitor = monitor;

         }

         protected void init() throws IOException {

         }

     }

 }