/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package org.openide.util.lookup;

import java.lang.ref.Reference;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.IdentityHashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.swing.event.EventListenerList;

import org.openide.util.Lookup;

import org.openide.util.LookupEvent;

import org.openide.util.LookupListener;

import org.openide.util.Utilities;

/** Implementation of lookup that can delegate to others.

 *

 * @author  Jaroslav Tulach

 * @since 1.9

 */

public class ProxyLookup extends Lookup {

    /** empty array of lookups for potential use */

    static final Lookup[] EMPTY_ARR = new Lookup[0];

    /** lookups to delegate to (either Lookup or array of Lookups) */

    private Object lookups;

    /** data representing the state of the lookup */

    private ImmutableInternalData data;

    /** Create a proxy to some other lookups.

     * @param lookups the initial delegates

     */

    public ProxyLookup(Lookup... lookups) {

        this.setLookupsNoFire(lookups);

    }

    /**

     * Create a lookup initially proxying to no others.

     * Permits serializable subclasses.

     * @since 3.27

     */

    protected ProxyLookup() {

        this(EMPTY_ARR);

    }

    @Override

    public String toString() {

        return "ProxyLookup(class=" + getClass() + ")->" + Arrays.asList(getLookups(false)); // NOI18N

    }

    /** Getter for the delegates.

    * @return the array of lookups we delegate to

    * @since 1.19

    */

    protected final Lookup[] getLookups() {

        synchronized (ProxyLookup.this) {

            return getLookups(true);

        }

    }

    /** getter for the delegates, that can but need not do a clone.

     * @param clone true if clone of internal array is requested

     */

    private final Lookup[] getLookups(boolean clone) {

        assert Thread.holdsLock(ProxyLookup.this);

        Object l = this.lookups;

        if (l instanceof Lookup) {

            return new Lookup[] { (Lookup)l };

        } else {

            Lookup[] arr = (Lookup[])l;

            if (clone) {

                arr = arr.clone();

            }

            return arr;

        }

    }

    private Set<Lookup> identityHashSet(Collection<Lookup> current) {

        Map<Lookup,Void> map = new IdentityHashMap<Lookup, Void>();

        for (Lookup lookup : current) {

            map.put(lookup, null);

        }

        return map.keySet();

    }

    /** Called from setLookups and constructor. 

     * @param lookups the lookups to setup

     */

    private void setLookupsNoFire(Lookup[] lookups) {

        if (lookups.length == 1) {

            this.lookups = lookups[0];

            assert this.lookups != null : "Cannot assign null delegate";

        } else {

            if (lookups.length == 0) {

                this.lookups = EMPTY_ARR;

            } else {

                this.lookups = lookups.clone();

            }

        }

    }

    /**

     * Changes the delegates.

     *

     * @param lookups the new lookups to delegate to

     * @since 1.19 protected

     */

    protected final void setLookups(Lookup... lookups) {

        Collection<Reference<R>> arr;

        Set<Lookup> newL;

        Set<Lookup> current;

        Lookup[] old;

        Map<Result,LookupListener> toRemove = new IdentityHashMap<Lookup.Result, LookupListener>();

        Map<Result,LookupListener> toAdd = new IdentityHashMap<Lookup.Result, LookupListener>();

        synchronized (ProxyLookup.this) {

            old = getLookups(false);

            current = identityHashSet(Arrays.asList(old));

            newL = identityHashSet(Arrays.asList(lookups));

            setLookupsNoFire(lookups);

            if (getData() == null) {

                // no affected results => exit

                return;

            }

            arr = getData().references();

            Set<Lookup> removed = identityHashSet(current);

            removed.removeAll(newL); // current contains just those lookups that have disappeared

            newL.removeAll(current); // really new lookups

            if (removed.isEmpty() && newL.isEmpty()) {

                // no need to notify changes

                return;

            }

            for (Reference<R> ref : arr) {

                R<?> r = ref.get();

                if (r != null) {

                    r.lookupChange(newL, removed, old, lookups, toAdd, toRemove);

                }

            }

        }

        // better to do this later than in synchronized block

        for (Map.Entry<Result, LookupListener> e : toRemove.entrySet()) {

            e.getKey().removeLookupListener(e.getValue());

        }

        for (Map.Entry<Result, LookupListener> e : toAdd.entrySet()) {

            e.getKey().addLookupListener(e.getValue());

        }

        // this cannot be done from the synchronized block

        ArrayList<Object> evAndListeners = new ArrayList<Object>();

        for (Reference<R> ref : arr) {

            R<?> r = ref.get();

            if (r != null) {

                r.collectFires(evAndListeners);

            }

        }

        {

            Iterator it = evAndListeners.iterator();

            while (it.hasNext()) {

                LookupEvent ev = (LookupEvent)it.next();

                LookupListener l = (LookupListener)it.next();

                l.resultChanged(ev);

            }

        }

    }

    /** Notifies subclasses that a query is about to be processed.

     * Subclasses can update its state before the actual processing

     * begins. It is allowed to call <code>setLookups</code> method

     * to change/update the set of objects the proxy delegates to.

     *

     * @param template the template of the query

     * @since 1.31

     */

    protected void beforeLookup(Template<?> template) {

    }

    public final <T> T lookup(Class<T> clazz) {

        beforeLookup(new Template<T>(clazz));

        Lookup[] tmpLkps;

        synchronized (ProxyLookup.this) {

            tmpLkps = this.getLookups(false);

        }

        for (int i = 0; i < tmpLkps.length; i++) {

            T o = tmpLkps[i].lookup(clazz);

            if (o != null) {

                return o;

            }

        }

        return null;

    }

    @Override

    public final <T> Item<T> lookupItem(Template<T> template) {

        beforeLookup(template);

        Lookup[] tmpLkps; 

        synchronized (ProxyLookup.this) {

            tmpLkps = this.getLookups(false);

        }

        for (int i = 0; i < tmpLkps.length; i++) {

            Item<T> o = tmpLkps[i].lookupItem(template);

            if (o != null) {

                return o;

            }

        }

        return null;

    }

    @SuppressWarnings("unchecked")

    private static <T> R<T> convertResult(R r) {

        return (R<T>)r;

    }

    public final <T> Result<T> lookup(Lookup.Template<T> template) {

        synchronized (ProxyLookup.this) {

            ImmutableInternalData[] res = { data };

            R<T> newR = ImmutableInternalData.findResult(this, res, template);

            setData(res[0]);

            return newR;

        }

    }

    /** Unregisters a template from the has map.

     */

    private final void unregisterTemplate(Template<?> template) {

        synchronized (ProxyLookup.this) {

            ImmutableInternalData id = getData();

            if (id == null) {

                return;

            }

            setData(id.removeTemplate(this, template));

        }

    }

    private ImmutableInternalData getData() {

        return data;

    }

    private void setData(ImmutableInternalData data) {

        assert Thread.holdsLock(ProxyLookup.this);

        this.data = data;

    }

    /** Result of a lookup request. Allows access to single object

     * that was found (not too useful) and also to all objects found

     * (more useful).

     */

    private static final class R<T> extends WaitableResult<T> {

        /** list of listeners added */

        private javax.swing.event.EventListenerList listeners;

        /** collection of Objects */

        private Collection[] cache;

        /** weak listener & result */

        private final WeakResult<T> weakL;

        private final Lookup.Template<T> template;

        /** Constructor.

         */

        public R(ProxyLookup proxy, Lookup.Template<T> t) {

            this.weakL = new WeakResult<T>(proxy, this);

            this.template = t;

        }

        @SuppressWarnings("unchecked")

        private Result<T>[] newResults(int len) {

            return new Result[len];

        }

        /** initializes the results

         */

        private Result<T>[] initResults() {

            BIG_LOOP: for (;;) {

                Lookup[] myLkps;

                synchronized (weakL.getLock()) {

                    if (weakL.getResults() != null) {

                        return weakL.getResults();

                    }

                    myLkps = weakL.getLookups(false);

                }

                Result<T>[] arr = newResults(myLkps.length);

                for (int i = 0; i < arr.length; i++) {

                    arr[i] = myLkps[i].lookup(template);

                }

                synchronized (weakL.getLock()) {

                    Lookup[] currentLkps = weakL.getLookups(false);

                    if (currentLkps.length != myLkps.length) {

                        continue BIG_LOOP;

                    }

                    for (int i = 0; i < currentLkps.length; i++) {

                        if (currentLkps[i] != myLkps[i]) {

                            continue BIG_LOOP;

                        }

                    }

                    // some other thread might compute the result mean while. 

                    // if not finish the computation yourself

                    if (weakL.getResults() != null) {

                        return weakL.getResults();

                    }

                    for (int i = 0; i < arr.length; i++) {

                        arr[i].addLookupListener(weakL);

                    }

                    weakL.setResults(arr);

                    return arr;

                }

            }

        }

        /** Called when there is a change in the list of proxied lookups.

         * @param added set of added lookups

         * @param remove set of removed lookups

         * @param current array of current lookups

         */

        protected void lookupChange(

            Set<Lookup> added, Set<Lookup> removed, Lookup[] old, Lookup[] current, 

            Map<Result,LookupListener> toAdd, Map<Result,LookupListener> toRemove

        ) {

            synchronized (weakL.getLock()) {

                if (weakL.getResults() == null) {

                    // not computed yet, do not need to do anything

                    return;

                }

                // map (Lookup, Lookup.Result)

                Map<Lookup,Result<T>> map = new IdentityHashMap<Lookup,Result<T>>(old.length * 2);

                for (int i = 0; i < old.length; i++) {

                    if (removed.contains(old[i])) {

                        // removed lookup

                        toRemove.put(weakL.getResults()[i], weakL);

                    } else {

                        // remember the association

                        map.put(old[i], weakL.getResults()[i]);

                    }

                }

                Lookup.Result<T>[] arr = newResults(current.length);

                for (int i = 0; i < current.length; i++) {

                    if (added.contains(current[i])) {

                        // new lookup

                        arr[i] = current[i].lookup(template);

                        toAdd.put(arr[i], weakL);

                    } else {

                        // old lookup

                        arr[i] = map.get(current[i]);

                        if (arr[i] == null) {

                            // assert

                            throw new IllegalStateException();

                        }

                    }

                }

                // remember the new results

                weakL.setResults(arr);

            }

        }

        /** Just delegates.

         */

        public void addLookupListener(LookupListener l) {

            synchronized (weakL.getLock()) {

                if (listeners == null) {

                    listeners = new EventListenerList();

                }

            }

            listeners.add(LookupListener.class, l);

        }

        /** Just delegates.

         */

        public void removeLookupListener(LookupListener l) {

            if (listeners != null) {

                listeners.remove(LookupListener.class, l);

            }

        }

        /** Access to all instances in the result.

         * @return collection of all instances

         */

        @SuppressWarnings("unchecked")

        public java.util.Collection<T> allInstances() {

            return computeResult(0);

        }

        /** Classes of all results. Set of the most concreate classes

         * that are registered in the system.

         * @return set of Class objects

         */

        @SuppressWarnings("unchecked")

        @Override

        public java.util.Set<Class<? extends T>> allClasses() {

            return (java.util.Set<Class<? extends T>>) computeResult(1);

        }

        /** All registered items. The collection of all pairs of

         * ii and their classes.

         * @return collection of Lookup.Item

         */

        @SuppressWarnings("unchecked")

        @Override

        public java.util.Collection<? extends Item<T>> allItems() {

            return computeResult(2);

        }

        /** Computes results from proxied lookups.

         * @param indexToCache 0 = allInstances, 1 = allClasses, 2 = allItems

         * @return the collection or set of the objects

         */

        private java.util.Collection computeResult(int indexToCache) {

            // results to use

            Lookup.Result<T>[] arr = myBeforeLookup();

            // if the call to beforeLookup resulted in deletion of caches

            synchronized (weakL.getLock()) {

                if (getCache() != null) {

                    Collection result = getCache()[indexToCache];

                    if (result != null) {

                        return result;

                    }

                }

            }

            // initialize the collection to hold result

            Collection<Object> compute;

            Collection<Object> ret;

            if (indexToCache == 1) {

                HashSet<Object> s = new HashSet<Object>();

                compute = s;

                ret = Collections.unmodifiableSet(s);

            } else {

                List<Object> l = new ArrayList<Object>(arr.length * 2);

                compute = l;

                ret = Collections.unmodifiableList(l);

            }

            // fill the collection

            for (int i = 0; i < arr.length; i++) {

                switch (indexToCache) {

                case 0:

                    compute.addAll(arr[i].allInstances());

                    break;

                case 1:

                    compute.addAll(arr[i].allClasses());

                    break;

                case 2:

                    compute.addAll(arr[i].allItems());

                    break;

                default:

                    assert false : "Wrong index: " + indexToCache;

                }

            }

            synchronized (weakL.getLock()) {

                if (getCache() == null) {

                    // initialize the cache to indicate this result is in use

                    setCache(new Collection[3]);

                }

                if (arr == weakL.getResults()) {

                    // updates the results, if the results have not been

                    // changed during the computation of allInstances

                    getCache()[indexToCache] = ret;

                }

            }

            return ret;

        }

        /** When the result changes, fire the event.

         */

        public void resultChanged(LookupEvent ev) {

            collectFires(null);

        }

        protected void collectFires(Collection<Object> evAndListeners) {

            // clear cached instances

            Collection oldItems;

            Collection oldInstances;

            synchronized (weakL.getLock()) {

                if (getCache() == null) {

                    // nobody queried the result yet

                    return;

                }

                oldInstances = getCache()[0];

                oldItems = getCache()[2];

                if (listeners == null || listeners.getListenerCount() == 0) {

                    // clear the cache

                    setCache(new Collection[3]);

                    return;

                }

                // ignore events if they arrive as a result of call to allItems

                // or allInstances, bellow...

                setCache(null);

            }

            boolean modified = true;

            if (oldItems != null) {

                Collection newItems = allItems();

                if (oldItems.equals(newItems)) {

                    modified = false;

                }

            } else {

                if (oldInstances != null) {

                    Collection newInstances = allInstances();

                    if (oldInstances.equals(newInstances)) {

                        modified = false;

                    }

                } else {

                    synchronized (weakL.getLock()) {

                        if (getCache() == null) {

                            // we have to initialize the cache

                            // to show that the result has been initialized

                            setCache(new Collection[3]);

                        }

                    }

                }

            }

            if (modified) {

                LookupEvent ev = new LookupEvent(this);

                AbstractLookup.notifyListeners(listeners.getListenerList(), ev, evAndListeners);

            }

        }

        /** Implementation of my before lookup.

         * @return results to work on.

         */

        private Lookup.Result<T>[] myBeforeLookup() {

            weakL.proxyBefore(template);

            Lookup.Result<T>[] arr = initResults();

            // invoke update on the results

            for (int i = 0; i < arr.length; i++) {

                if (arr[i] instanceof WaitableResult) {

                    WaitableResult w = (WaitableResult) arr[i];

                    w.beforeLookup(template);

                }

            }

            return arr;

        }

        /** Used by proxy results to synchronize before lookup.

         */

        protected void beforeLookup(Lookup.Template t) {

            if (t.getType() == template.getType()) {

                myBeforeLookup();

            }

        }

        private Collection[] getCache() {

            return cache;

        }

        private void setCache(Collection[] cache) {

            assert Thread.holdsLock(weakL.getLock());

            this.cache = cache;

        }

    }

    private static final class WeakResult<T> extends WaitableResult<T> implements LookupListener, Runnable {

        /** all results */

        private Lookup.Result<T>[] results;

        private final Reference<R> result;

        private final Reference<ProxyLookup> proxy;

        public WeakResult(ProxyLookup proxy, R r) {

            this.result = new RefR(r, this);

            this.proxy = new WeakReference<ProxyLookup>(proxy);

        }

        protected void beforeLookup(Lookup.Template t) {

            R r = result.get();

            if (r != null) {

                r.beforeLookup(t);

            } else {

                removeListeners();

            }

        }

        final void unregisterTemplate() {

            ProxyLookup p = proxy.get();

            R r = result.get();

            Lookup.Template<T> template = r == null ? null : r.template;

            if (p != null && template != null) {

                p.unregisterTemplate(template);

            }

        }

        final void proxyBefore(Template template) {

            ProxyLookup p = proxy.get();

            if (p != null) {

                p.beforeLookup(template);

            }

        }

        final Object getLock() {

            ProxyLookup p = proxy.get();

            if (p != null) {

                return p;

            } else {

                // some fallback to lock on that will not change once the ProxyLookup is GCed

                return EMPTY_ARR;

            }

        }

        final Lookup[] getLookups(boolean clone) {

            ProxyLookup p = proxy.get();

            if (p != null) {

                return p.getLookups(clone);

            } else {

                return EMPTY_ARR;

            }

        }

        final void removeListeners() {

            Lookup.Result<T>[] arr = this.getResults();

            if (arr == null) {

                return;

            }

            for(int i = 0; i < arr.length; i++) {

                arr[i].removeLookupListener(this);

            }

        }

        protected void collectFires(Collection<Object> evAndListeners) {

            R<?> r = result.get();

            if (r != null) {

                r.collectFires(evAndListeners);

            } else {

                removeListeners();

            }

        }

        public void addLookupListener(LookupListener l) {

            assert false;

        }

        public void removeLookupListener(LookupListener l) {

            assert false;

        }

        public Collection<T> allInstances() {

            assert false;

            return null;

        }

        public void resultChanged(LookupEvent ev) {

            R r = result.get();

            if (r != null) {

                r.resultChanged(ev);

            } else {

                removeListeners();

            }

        }

        @Override

        public Collection<? extends Item<T>> allItems() {

            assert false;

            return null;

        }

        @Override

        public Set<Class<? extends T>> allClasses() {

            assert false;

            return null;

        }

        public void run() {

            removeListeners();

        }

        private Lookup.Result<T>[] getResults() {

            return results;

        }

        private void setResults(Lookup.Result<T>[] results) {

            this.results = results;

        }

    } // end of WeakResult

    private static final class ImmutableInternalData extends Object {

        /** map of templates to currently active results */

        private final HashMap<Template<?>,Reference<R>> results;

        public ImmutableInternalData(HashMap<Template<?>, Reference<ProxyLookup.R>> results) {

            this.results = results;

        }

        final Collection<Reference<R>> references() {

            return results.values();

        }

        final <T> ImmutableInternalData removeTemplate(ProxyLookup proxy, Template<T> template) {

            if (results.containsKey(template)) {

                HashMap<Template<?>,Reference<R>> c = new HashMap<Lookup.Template<?>, Reference<ProxyLookup.R>>(results);

                Reference<R> ref = c.remove(template);

                if (ref != null && ref.get() != null) {

                    // seems like there is a reference to a result for this template

                    // thta is still alive

                    return this;

                }

                return new ImmutableInternalData(c);

            } else {

                return this;

            }

        }

        static <T> R<T> findResult(ProxyLookup proxy, ImmutableInternalData[] oldAndNew, Template<T> template) {

            assert Thread.holdsLock(proxy);

            if (oldAndNew[0] != null) {

                Reference<R> ref = oldAndNew[0].results.get(template);

                R r = (ref == null) ? null : ref.get();

                if (r != null) {

                    return convertResult(r);

                }

            }

            HashMap<Template<?>, Reference<R>> res;

            if (oldAndNew[0] == null) {

                res = new HashMap<Template<?>, Reference<R>>();

            } else {

                res = new HashMap<Template<?>, Reference<R>>(oldAndNew[0].results);

            }

            R<T> newR = new R<T>(proxy, template);

            res.put(template, new java.lang.ref.SoftReference<R>(newR));

            oldAndNew[0] = new ImmutableInternalData(res);

            return newR;

        }

    }

    private static final class RefR extends WeakReference<R> implements Runnable {

        private WeakResult weakL;

        public RefR(R r, WeakResult weakL) {

            super(r, Utilities.activeReferenceQueue());

            this.weakL = weakL;

        }

        public void run() {

            weakL.unregisterTemplate();

        }

    }

}