import java.util.HashSet;

import java.util.Set;

    /** Set of property names which values can be used as additional base

     * directories. */

    private Set/*<String>*/ extraBaseDirectories = new HashSet();

    /**

     * Test whether file does not lie under an extra base folder and if it does

     * then return string in form of "${extra.base}/remaining/path"; or null.

     */

    private String relativizeFileToExtraBaseFolders(File f) {

        File base = FileUtil.toFile(h.getProjectDirectory());

        String fileToRelativize = f.getAbsolutePath();

        synchronized (extraBaseDirectories) {

            Iterator it = extraBaseDirectories.iterator();

            while (it.hasNext()) {

                String prop = (String)it.next();

                String path = eval.getProperty(prop);

                File extraBase = PropertyUtils.resolveFile(base, path);

                path = extraBase.getAbsolutePath();

                if (!path.endsWith(File.separator)) {

                    path += File.separator;

                }

                if (fileToRelativize.startsWith(path)) {

                    return "${"+prop+"}/"+fileToRelativize.substring(path.length()).replace('\\', '/'); // NOI18N

                }

            }

        }

        return null;

    }

    /**

     * Add extra folder which can be used as base directory (in addition to

     * project base folder) for creating references. Duplicate property names

     * are not allowed. Any newly created reference to a file lying under an

     * extra base directory will be based on that property and will be stored in

     * shared project proeprties.

     * @param propertyName property name which value is path to folder which

     * can be used as alternative project's base directory

     * @since 1.3

     */

    public void addExtraBaseDirectory(String propertyName) {

        assert propertyName != null && eval.getProperty(propertyName) != null;

        synchronized (extraBaseDirectories) {

            if (!extraBaseDirectories.add(propertyName)) {

                throw new IllegalArgumentException("Already extra base directory property: "+propertyName); // NOI18N

            }

        }

    }

    /**

     * Remove extra base directory. The base directory property had to be added

     * by {@link #addExtraBaseDirectory} method call. At the time when this

     * method is called the property must still exist and must be valid. This

     * method will replace all references of the extra base directory property

     * with its current value and if needed it may move such a property from

     * shared project properties into the private properties.

     * @param propertyName property name which was added by 

     * {@link #addExtraBaseDirectory} method.

     * @since 1.3

     */

    public void removeExtraBaseDirectory(String propertyName) {

        synchronized (extraBaseDirectories) {

            if (!extraBaseDirectories.remove(propertyName)) {

                throw new IllegalArgumentException("Non-existing extra base directory property: "+propertyName); // NOI18N

            }

            // substitute all references of removed extra base folder property with its value

            String tag = "${"+propertyName+"}"; // NOI18N

            // was extra base property defined in shared file or not:

            boolean shared = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).containsKey(propertyName);

            String value = eval.getProperty(propertyName);

            EditableProperties propProj = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);

            EditableProperties propPriv = h.getProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH);

            boolean modifiedProj = false;

            boolean modifiedPriv = false;

            Iterator it = propProj.entrySet().iterator();

            while (it.hasNext()) {

                Map.Entry entry = (Map.Entry)it.next();

                String val = (String)entry.getValue();

                int index;

                if ((index = val.indexOf(tag)) != -1) {

                    val = val.substring(0, index) +value + val.substring(index+tag.length());

                    if (shared) {

                        // substitute extra base folder property with its value

                        entry.setValue(val);

                        modifiedProj = true;

                    } else {

                        // move property to private properties file

                        it.remove();

                        propPriv.put(entry.getKey(), val);

                        modifiedPriv = true;

                        modifiedProj = true;

                    }

                }

            }

            if (modifiedProj) {

                h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, propProj);

            }

            if (modifiedPriv) {

                h.putProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH, propPriv);

            }

        }

    }

    public void testAddRemoveExtraBaseDirectory() throws Exception {

        // test foreign file reference for non-collocated jar under extra base folder

        FileObject nonCollocatedLib = scratch.getFileObject("separate").createFolder("jars").createData("mylib.jar");

        File f = FileUtil.toFile(nonCollocatedLib);

        EditableProperties props = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);

        props.setProperty("externalSourceRoot", "../separate");

        h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, props);

        r.addExtraBaseDirectory("externalSourceRoot");

        String ref = r.createForeignFileReference(f, "jar");

        assertEquals("foreign file reference created", "${file.reference.mylib.jar}", ref);

        String refval = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).getProperty(ref.substring(2, ref.length()-1));

        assertEquals("reference is using extra base folder", "${externalSourceRoot}/jars/mylib.jar", refval);

        assertEquals("reference is correctly evaluated", f, h.resolveFile(h.getStandardPropertyEvaluator().evaluate(refval)));

        // test removal of extra base folder

        r.removeExtraBaseDirectory("externalSourceRoot");

        refval = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).getProperty(ref.substring(2, ref.length()-1));

        assertEquals("reference does not contain extra base folder", "../separate/jars/mylib.jar", refval);

        assertEquals("reference is correctly evaluated", f, h.resolveFile(refval));

        // the same test as above but with extra base folder defined in PRIVATE props

        nonCollocatedLib = scratch.createFolder("separate2").createFolder("jars").createData("mylib2.jar");

        f = FileUtil.toFile(nonCollocatedLib);

        props = h.getProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH);

        String absolutePath = FileUtil.toFile(scratch.getFileObject("separate2")).getAbsolutePath();

        props.setProperty("externalSourceRootAbsolute", absolutePath);

        h.putProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH, props);

        r.addExtraBaseDirectory("externalSourceRootAbsolute");

        ref = r.createForeignFileReference(f, "jar");

        assertEquals("foreign file reference created", "${file.reference.mylib2.jar}", ref);

        refval = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).getProperty(ref.substring(2, ref.length()-1));

        assertEquals("reference is using extra base folder", "${externalSourceRootAbsolute}/jars/mylib2.jar", refval);

        assertEquals("reference is correctly evaluated", f, h.resolveFile(h.getStandardPropertyEvaluator().evaluate(refval)));

        r.removeExtraBaseDirectory("externalSourceRootAbsolute");

        refval = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).getProperty(ref.substring(2, ref.length()-1));

        assertNull("reference was removed from PROJECT_PROPERTIES_PATH", refval);

        refval = h.getProperties(AntProjectHelper.PRIVATE_PROPERTIES_PATH).getProperty(ref.substring(2, ref.length()-1));

        assertNotNull("reference was moved to PRIVATE_PROPERTIES_PATH", refval);

        assertEquals("reference does not contain extra base folder", absolutePath+"/jars/mylib2.jar", refval);

        assertEquals("reference is correctly evaluated", f, h.resolveFile(h.getStandardPropertyEvaluator().evaluate(refval)));

    }