/*
 *                 Sun Public License Notice
 * 
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.openide.loaders;

import java.io.ObjectOutputStream;
import org.openide.filesystems.*;
import org.openide.loaders.*;
import org.openide.util.*;
import org.openide.util.lookup.*;

import java.util.*;
import org.netbeans.junit.*;

public class FolderLookupTest extends NbTestCase {
    
    public FolderLookupTest() {
        super("");
    }
    
    public FolderLookupTest(java.lang.String testName) {
        super(testName);
    }
    
    public static void main(java.lang.String[] args) {
        junit.textui.TestRunner.run(new NbTestSuite(FolderLookupTest.class));
    }
    
    /** Test of the lookup method. Creates a file under Services directory 
     * and tries to lookup it. The object should be immediatelly found.
     *
     */
    public void testFolderLookupIsUpdatedQuickly () throws Exception {
        String fsstruct [] = new String [] {
            "AA/",
        };
        
        TestUtilHid.destroyLocalFileSystem (getName());
        FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);

        FileObject bb = lfs.findResource("/AA");
        
        DataFolder folder = DataFolder.findFolder (bb);
        
        
        Lookup lookup = new org.openide.loaders.FolderLookup (folder).getLookup ();
        try {
            checkTheLookup (lookup, folder);
        } finally {
            folder.delete ();
        }
    }


   private void checkTheLookup (Lookup lookup, DataFolder folder) throws Exception {
        Class toFind = java.util.Dictionary.class;
        Class toCreate = java.util.Hashtable.class;
        
        Object wrongResult = lookup.lookup (toFind);
        DataObject obj = InstanceDataObject.create (folder, "Test", toCreate);
        
        if (lookup.lookup (toFind) == null) {
            fail ("Lookup has not found the class");
        }
        obj.delete ();
        
        if (lookup.lookup (toFind) != null) {
            fail ("Still it is possible to find the class");
        }
        if (wrongResult != null) {
            // report the original mistake, means the a previous test forgot
            // to clean after itself
            fail ("There is uncleaned environment: " + wrongResult);
        }
        
    }
   
    /** Test of the lookup method. Creates files under different levels of directory 
     * hierarchy and tries to lookup it. The objects should be immediatelly found.
     *
     */
    public void testFolderLookupIsUpdatedQuicklyForSubfolders () throws Exception {
        String fsstruct [] = new String [] {
            "AA/",
        };
        
        TestUtilHid.destroyLocalFileSystem (getName());
        FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);

        FileObject bb = lfs.findResource("/AA");
        assertNotNull(bb + " not found", bb);
        
        DataFolder folder = DataFolder.findFolder (bb);
        
        
        Lookup lookup = new org.openide.loaders.FolderLookup (folder).getLookup ();
        checkTheLookupForSubfolders (lookup, folder);
    }
    
    private void checkTheLookupForSubfolders (Lookup lookup, DataFolder folder) throws Exception {
        Class toFind = java.awt.Component.class;
        Class toCreate = javax.swing.JButton.class;

        Lookup.Result res = lookup.lookup(new Lookup.Template(toFind));

        DataObject obj = InstanceDataObject.create (folder, "Test", toCreate);
        int count = res.allInstances().size();
        assertNotNull(obj.getPrimaryFile() + " not found",
            folder.getPrimaryFile().getFileSystem().findResource(obj.getPrimaryFile().getPath()));
        if (count != 1) {
            fail ("Lookup has not updated root content in time: expected count: 1, obtained: " + count);
        }

        DataFolder subfolder = DataFolder.create(folder, "BB");
        assertNotNull(subfolder.getPrimaryFile() + " not found",
            folder.getPrimaryFile().getFileSystem().findResource(subfolder.getPrimaryFile().getPath()));
        
        obj = InstanceDataObject.create (subfolder, "Test", toCreate);
        count = res.allInstances().size();
        assertNotNull(obj.getPrimaryFile() + " not found",
            folder.getPrimaryFile().getFileSystem().findResource(obj.getPrimaryFile().getPath()));
        if (count != 2) {
            fail ("Lookup has not updated subfolders content in time: expected count: 2, obtained: " + count);
        }
    }

    /** Tests delegation stuff.
     */
    public void testProxyLookups () throws Exception {
        String fsstruct [] = new String [] {
            "AA/",
        };
        
        TestUtilHid.destroyLocalFileSystem (getName());
        FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);

        FileObject bb = lfs.findResource("/AA");
        
        DataFolder folder = DataFolder.findFolder (bb);

        InstanceDataObject obj = InstanceDataObject.create (folder, null, ALkp.class);
        
        Lookup lookup = new org.openide.loaders.FolderLookup (folder).getLookup ();
        
        if (lookup.lookup (Integer.class) == null) {
            fail ("Integer not found in delegating lookup");
        }
        
    }
    
    public void testFindInstanceNotCreatedByYouIssue24986 () throws Exception {
        String fsstruct [] = new String [] {
            "AA/",
        };
        TestUtilHid.destroyLocalFileSystem (getName());
        FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);

        FileObject bb = lfs.findResource("/AA");
        
        String inst = "My instnace";
        
        DataFolder folder = DataFolder.findFolder (bb);
        FileObject fo = FileUtil.createData (folder.getPrimaryFile (), "test.ser");
        FileLock lock = fo.lock ();
        ObjectOutputStream oss = new ObjectOutputStream (fo.getOutputStream (lock));
        oss.writeObject (inst);
        oss.close ();
        lock.releaseLock ();
        DataObject o = DataObject.find (fo);
        assertTrue ("Is IDO: " + o, o instanceof InstanceDataObject);
        InstanceDataObject obj = (InstanceDataObject)o;

        assertEquals ("The instance is created", inst, obj.instanceCreate ());
        assertNotSame ("But is not the same", inst, obj.instanceCreate ());
        inst = (String)obj.instanceCreate ();
        
        Lookup lookup = new org.openide.loaders.FolderLookup (folder).getLookup ();
        
        Lookup.Template t = new Lookup.Template (null, null, inst);
        Collection found = lookup.lookup (t).allInstances ();
        
        assertEquals ("Lookup finds it as well", 1, found.size ());
        assertEquals ("Lookup finds it as well", inst, found.iterator ().next());
    }
        
    
    
    public void testDeserializationOnFolder () throws Exception {
        doDeser (true);
    }
    
    public void testDeserializationOnSubFolder () throws Exception {
        doDeser (false);
    }
    
    private void doDeser (boolean root) throws Exception {
        String fsstruct [] = new String [] {
            "AA/BB/A.simple"
        };
        
        TestUtilHid.destroyLocalFileSystem (getName());
        FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);
        Repository.getDefault ().addFileSystem (lfs);

        DataFolder folder = DataFolder.findFolder (lfs.findResource("/AA"));
        DataFolder subfolder = DataFolder.findFolder (lfs.findResource("/AA/BB/"));
        DataObject tmp = InstanceDataObject.create (subfolder, null, Hashtable.class);

        FolderLookup lkp = new FolderLookup (folder);
        Object res = lkp.getLookup ().lookup (Hashtable.class);
        assertNotNull ("The table is obtained", res);
        
        org.openide.util.io.NbMarshalledObject mar = new org.openide.util.io.NbMarshalledObject (lkp.getLookup ());
        
        java.lang.ref.WeakReference ref1 = new java.lang.ref.WeakReference (subfolder);
        java.lang.ref.WeakReference ref2 = new java.lang.ref.WeakReference (lkp);
        subfolder = null;
        tmp = null;
        folder = null;
        lkp = null;
        assertGC ("Lookup can disappear", ref1);
        assertGC ("Folder can disappear", ref2);

        
        Lookup lookup = (Lookup)mar.get ();
        ((FolderLookup.ProxyLkp)lookup).waitFinished ();
        res = lookup.lookup (Hashtable.class);
        assertNotNull ("A table is there", res);
        res = lookup.lookup (ArrayList.class);
        assertNull ("No array list", res);

        DataFolder my = DataFolder.findFolder (lfs.findResource(root ? "/AA/" : "/AA/BB/"));
        tmp = InstanceDataObject.create (my, null, ArrayList.class);
        res = lookup.lookup (ArrayList.class);
        assertNotNull ("array list is there", res);
        
        Repository.getDefault ().removeFileSystem (lfs);
    }
    
   
    
   public static final class ALkp extends AbstractLookup {
       public ALkp () {
           this (new InstanceContent ());
       }
       
       private ALkp (InstanceContent ic) {
           super (ic);
           ic.add (new Integer (1));
       }
       
   }
}