/*

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

 *

 * Copyright 1997-2009 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.util.concurrent.ExecutionException;

import java.lang.ref.WeakReference;

import java.util.*;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

import org.netbeans.junit.*;

import org.openide.util.Lookup;

import org.openide.util.lookup.AbstractLookup.Pair;

@SuppressWarnings("unchecked") // XXX ought to be corrected, just a lot of them

public class AbstractLookupTest extends AbstractLookupBaseHid implements AbstractLookupBaseHid.Impl {

    public AbstractLookupTest(java.lang.String testName) {

        super(testName, null);

    }

    //

    // Impl of AbstractLookupBaseHid.Impl

    //

    /** Creates the initial abstract lookup.

     */

    public Lookup createInstancesLookup (InstanceContent ic) {

        return new AbstractLookup (ic, new InheritanceTree ());

    }

    /** Creates an lookup for given lookup. This class just returns 

     * the object passed in, but subclasses can be different.

     * @param lookup in lookup

     * @return a lookup to use

     */

    public Lookup createLookup (Lookup lookup) {

        return lookup;

    }

    public void clearCaches () {

    }    

    public static void main(java.lang.String[] args) {

        junit.textui.TestRunner.run(new NbTestSuite(AbstractLookupTest.class));

    }

    static class LkpResultCanBeGargageCollectedAndClearsTheResult extends AbstractLookup {

        public int cleared;

        public int dirty;

        synchronized @Override boolean cleanUpResult(Template t) {

            boolean res = super.cleanUpResult (t);

            if (res) {

                cleared++;

            } else {

                dirty++;

            }

            notifyAll ();

            return res;

        }

    }

    public void testResultCanBeGargageCollectedAndClearsTheResult () throws Exception {

        LkpResultCanBeGargageCollectedAndClearsTheResult lkp = new LkpResultCanBeGargageCollectedAndClearsTheResult ();

        assertSize ("24 for AbstractLookup, 8 for two ints", 32, lkp);

        synchronized (lkp) {

            Lookup.Result res = lkp.lookup (new Lookup.Template (getClass ()));

            res.allItems();

            WeakReference ref = new WeakReference (res);

            res = null;

            assertGC ("Reference can get cleared", ref);

            // wait till we 

            while (lkp.cleared == 0 && lkp.dirty == 0) {

                lkp.wait ();

            }

            assertEquals ("No dirty cleanups", 0, lkp.dirty);

            assertEquals ("One final cleanup", 1, lkp.cleared);

        }

        //assertSize ("Everything has been cleaned to original size", 32, lkp);

    }

    public void testPairCannotBeUsedInMoreThanOneLookupAtOnce () throws Exception {

        /** Simple pair with no data */

        class EmptyPair extends AbstractLookup.Pair {

            protected boolean creatorOf(Object obj) { return false; }

            public String getDisplayName() { return "Empty"; }

            public String getId() { return "empty"; }

            public Object getInstance() { return null; }

            public Class getType() { return Object.class; }

            protected boolean instanceOf(Class c) { return c == getType (); }

        } // end of EmptyPair

        AbstractLookup.Content c1 = new AbstractLookup.Content ();

        AbstractLookup.Content c2 = new AbstractLookup.Content ();

        AbstractLookup l1 = new AbstractLookup (c1);

        AbstractLookup l2 = new AbstractLookup (c2);

        EmptyPair empty = new EmptyPair ();

        c1.addPair (empty);

        Lookup.Result res = l1.lookup (new Lookup.Template (Object.class));

        assertEquals (

            "Pair is really found", empty, 

            res.allItems ().iterator().next ()

        );

        try {

            c2.addPair (empty);

            fail ("It should not be possible to add pair to two lookups");

        } catch (IllegalStateException ex) {

            // ok, exception is fine

        }

        assertEquals (

            "L2 is still empty", Collections.EMPTY_LIST, 

            new ArrayList (l2.lookup (new Lookup.Template (Object.class)).allItems ())

        );

    }

    public void testInitializationCanBeDoneFromAnotherThread () {

        class MyLkp extends AbstractLookup implements Runnable {

            private InstanceContent ic;

            private boolean direct;

            public MyLkp (boolean direct) {

                this (direct, new InstanceContent ());

            }

            private MyLkp (boolean direct, InstanceContent ic) {

                super (ic);

                this.direct = direct;

                this.ic = ic;

            }

            protected @Override void initialize() {

                if (direct) {

                    run ();

                } else {

                    try {

                        Executors.newSingleThreadScheduledExecutor().schedule(this, 0, TimeUnit.MICROSECONDS).get();

                    } catch (InterruptedException ex) {

                        ex.printStackTrace();

                    } catch (ExecutionException ex) {

                        ex.printStackTrace();

                    }

                }

            }

            public void run () {

                ic.add (this);

                ic.remove (this);

                ic.set (Collections.nCopies(10, this), null);

                ic.set (Collections.EMPTY_LIST, null);

                ic.add (AbstractLookupTest.this);

            }

        }

        assertEquals ("The test should be there", this, new MyLkp (true).lookup (Object.class));

        assertEquals ("and in async mode as well", this, new MyLkp (false).lookup (Object.class));

    }

    public void testBeforeLookupIsCalled () {

        class BeforeL extends AbstractLookup {

            public ArrayList list = new ArrayList ();

            public String toAdd;

            public InstanceContent ic;

            public BeforeL () {

                this (new InstanceContent ());

            }

            private BeforeL (InstanceContent c) {

                super (c);

                this.ic = c;

            }

            protected @Override void beforeLookup(Template t) {

                if (toAdd != null) {

                    list.add (0, new SerialPair (toAdd));

                    setPairs (list);

                } else {

                    ic.add (new Integer (1));

                }

            }

        }

        BeforeL lookup = new BeforeL ();

        lookup.toAdd = "First";

        assertEquals ("First if found", "First", lookup.lookup (String.class));

        lookup.toAdd = "2";

        assertEquals ("2 is not first", "2", lookup.lookup (String.class));

        Lookup.Result res = lookup.lookup (new Lookup.Template (Object.class));

        for (int i = 3; i < 20; i++) {

            lookup.toAdd = String.valueOf (i);

            assertEquals (i + " items are now there", i, res.allInstances ().size ());

        }

        for (int i = 20; i < 35; i++) {

            lookup.toAdd = String.valueOf (i);

            assertEquals (i + " items are now there", i, res.allItems ().size ());

        }

        assertEquals ("Just strings are there now", 1, res.allClasses ().size ());

        lookup.toAdd = null; // this will add integer

        assertEquals ("Two classes now", 2, res.allClasses ().size ());

    }

    public void testInconsistentAfterDeserIssue71744() throws Exception {

        InheritanceTree inhTree = new InheritanceTree();

        AbstractLookup al = new AbstractLookup(new AbstractLookup.Content(), inhTree);

        {

            Collection r = al.lookup(new Lookup.Template(Integer.class)).allInstances();

            assertEquals("None", 0, r.size());

        }

        ICP item = new ICP(new Integer(10));

        al.addPair(item);

        al.removePair(item);

        AbstractLookup newLookup = (AbstractLookup)reserialize(al);

        newLookup.lookup(Number.class);

        newLookup.addPair(new ICP(new Long(20)));

        {

            Collection r = newLookup.lookup(new Lookup.Template(Number.class)).allInstances();

            assertEquals("one", 1, r.size());

/*

            Iterator it = r.iterator();

            assertEquals(new Integer(10), it.next());

            assertEquals(new Long(20), it.next());*/

        }

    }

    public void testMatchesIssue130673() {

        class BrokenPairReturningNullID extends Pair<Object> {

            @Override

            protected boolean instanceOf(Class<?> c) {

                return false;

            }

            @Override

            protected boolean creatorOf(Object obj) {

                return false;

            }

            @Override

            public Object getInstance() {

                return null;

            }

            @Override

            public Class<? extends Object> getType() {

                return null;

            }

            @Override

            public String getId() {

                return null;

            }

            @Override

            public String getDisplayName() {

                return null;

            }

        }

        BrokenPairReturningNullID broken = new BrokenPairReturningNullID();

        Lookup.Template<String> t = new Lookup.Template<String>(String.class, "ID", null);

        boolean not = AbstractLookup.matches(t, broken, true);

        assertFalse("Does not match the template, but throws no exception", not);

    }

    private static final class ICP extends AbstractLookup.Pair {

        private Number s;

        public ICP (Number s) {

            this.s = s;

        }

        protected boolean instanceOf(Class c) {

            return c.isInstance(s);

        }

        protected boolean creatorOf(Object obj) {

            return s == obj;

        }

        public Object getInstance() {

            return s;

        }

        public Class getType() {

            return s.getClass();

        }

        public String getId() {

            return s.toString();

        }

        public String getDisplayName() {

            return getId();

        }

    }

}