/**
 *******************************************************************************
 * Copyright (C) 2001-2004, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */
package com.ibm.icu.impl;

import java.util.ArrayList;
import java.util.EventListener;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * <p>Abstract implementation of a notification facility.  Clients add
 * EventListeners with addListener and remove them with removeListener.
 * Notifiers call notifyChanged when they wish to notify listeners.
 * This queues the listener list on the notification thread, which
 * eventually dequeues the list and calls notifyListener on each
 * listener in the list.</p>
 *
 * <p>Subclasses override acceptsListener and notifyListener 
 * to add type-safe notification.  AcceptsListener should return
 * true if the listener is of the appropriate type; ICUNotifier
 * itself will ensure the listener is non-null and that the
 * identical listener is not already registered with the Notifier.
 * NotifyListener should cast the listener to the appropriate 
 * type and call the appropriate method on the listener.
 */
public abstract class ICUNotifier {
    private final Object notifyLock = new Object();
    private NotifyThread notifyThread;
    private List listeners;

    /**
     * Add a listener to be notified when notifyChanged is called.
     * The listener must not be null. AcceptsListener must return
     * true for the listener.  Attempts to concurrently
     * register the identical listener more than once will be
     * silently ignored.  
     */
    public void addListener(EventListener l) {
    if (l == null) {
        throw new NullPointerException();
    }

    if (acceptsListener(l)) {
        synchronized (notifyLock) {
        if (listeners == null) {
            listeners = new ArrayList(5);
        } else {
            // identity equality check
            Iterator iter = listeners.iterator();
            while (iter.hasNext()) {
            if (iter.next() == l) {
                return;
            }
            }
        }

        listeners.add(l);
        }
    } else {
        throw new InternalError("Listener invalid for this notifier.");
    }
    }

    /**
     * Stop notifying this listener.  The listener must
     * not be null.  Attemps to remove a listener that is
     * not registered will be silently ignored.
     */
    public void removeListener(EventListener l) {
    if (l == null) {
        throw new NullPointerException();
    }
    synchronized (notifyLock) {
        if (listeners != null) {
        // identity equality check
        Iterator iter = listeners.iterator();
        while (iter.hasNext()) {
            if (iter.next() == l) {
            iter.remove();
            if (listeners.size() == 0) {
                listeners = null;
            }
            return;
            }
        }
        }
    }
    }

    /**
     * Queue a notification on the notification thread for the current
     * listeners.  When the thread unqueues the notification, notifyListener
     * is called on each listener from the notification thread.
     */
    public void notifyChanged() {
    if (listeners != null) {
        synchronized (notifyLock) {
        if (listeners != null) {
            if (notifyThread == null) {
            notifyThread = new NotifyThread(this);
            notifyThread.setDaemon(true);
            notifyThread.start();
            }
            notifyThread.queue(listeners.toArray());
        }
        }
    }
    }

    /**
     * The notification thread.
     */
    private static class NotifyThread extends Thread {
    private final ICUNotifier notifier;
    private final List queue = new LinkedList();

    NotifyThread(ICUNotifier notifier) {
        this.notifier = notifier;
    }

    /**
     * Queue the notification on the thread.
     */
    public void queue(Object[] list) {
        synchronized (this) {
        queue.add(list);
        notify();
        }
    }

    /**
     * Wait for a notification to be queued, then notify all
     * listeners listed in the notification.
     */
    public void run() {
        Object[] list;
        while (true) {
        try {
            synchronized (this) {
            while (queue.isEmpty()) {
                wait();
            }
            list = (Object[])queue.remove(0);
            }

            for (int i = 0; i < list.length; ++i) {
            notifier.notifyListener((EventListener)list[i]);
            }
        }
        catch (InterruptedException e) {
        }
        }
    }
    }

    /**
     * Subclasses implement this to return true if the listener is
     * of the appropriate type.
     */
    protected abstract boolean acceptsListener(EventListener l);

    /**
     * Subclasses implement this to notify the listener.
     */
    protected abstract void notifyListener(EventListener l);
}