/*

 * 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.netbeans.modules.j2ee.clientproject;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import org.openide.filesystems.FileObject;

import org.netbeans.api.queries.FileBuiltQuery;

import org.netbeans.spi.queries.FileBuiltQueryImplementation;

import org.netbeans.spi.project.support.ant.AntProjectHelper;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;

import org.netbeans.modules.j2ee.clientproject.ui.customizer.AppClientProjectProperties;

public class AppClientFileBuiltQuery implements FileBuiltQueryImplementation, PropertyChangeListener {

    private FileBuiltQueryImplementation delegate;

    private final AntProjectHelper helper;

    private final PropertyEvaluator evaluator;

    private final SourceRoots sourceRoots;

    private final SourceRoots testRoots;

    AppClientFileBuiltQuery (AntProjectHelper helper, PropertyEvaluator evaluator,

                        SourceRoots sourceRoots, SourceRoots testRoots) {

        assert helper != null && evaluator != null && sourceRoots != null && testRoots != null;

        this.helper = helper;

        this.evaluator = evaluator;

        this.sourceRoots = sourceRoots;

        this.testRoots = testRoots;

        this.sourceRoots.addPropertyChangeListener (this);

        this.testRoots.addPropertyChangeListener (this);

    }

    public synchronized FileBuiltQuery.Status getStatus(FileObject file) {

        if (this.delegate == null) {

            this.delegate = createDelegate ();

        }

        return this.delegate.getStatus (file);

    }

    private FileBuiltQueryImplementation createDelegate () {

        String[] srcRoots = this.sourceRoots.getRootProperties();

        String[] tstRoots = this.testRoots.getRootProperties();

        String[] from = new String [srcRoots.length + tstRoots.length];

        String[] to = new String [srcRoots.length + tstRoots.length];

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

            from[i] = "${" + srcRoots[i] + "}/*.java"; // NOI18N

            to[i] = "${" + AppClientProjectProperties.BUILD_CLASSES_DIR + "}/*.class"; // NOI18N

        }

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

            from[srcRoots.length+i] = "${" + tstRoots[i] + "}/*.java"; // NOI18N

            to[srcRoots.length+i] = "${" + AppClientProjectProperties.BUILD_TEST_CLASSES_DIR + "}/*.class"; // NOI18N

        }

        return helper.createGlobFileBuiltQuery(evaluator, from, to);    //Safe to pass APH

    }

    public void propertyChange(PropertyChangeEvent evt) {

        if (SourceRoots.PROP_ROOT_PROPERTIES.equals (evt.getPropertyName())) {

            synchronized(this) {

                this.delegate = null;

                ///XXX: What to do with already returned Statuses

            }

        }

    }

}

import org.netbeans.modules.j2ee.clientproject.queries.AppClientProjectEncodingQueryImpl;

import org.netbeans.modules.j2ee.clientproject.queries.CompiledSourceForBinaryQuery;

import org.netbeans.modules.j2ee.clientproject.queries.JavadocForBinaryQueryImpl;

import org.netbeans.modules.j2ee.clientproject.queries.SourceLevelQueryImpl;

import org.netbeans.modules.j2ee.clientproject.queries.UnitTestForSourceQueryImpl;

/*

 * 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.netbeans.modules.j2ee.clientproject;

import java.io.File;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import org.openide.util.Mutex;

import org.netbeans.api.project.ProjectManager;

import org.netbeans.spi.queries.SharabilityQueryImplementation;

import org.netbeans.spi.project.support.ant.AntProjectHelper;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;

import org.netbeans.modules.j2ee.clientproject.ui.customizer.AppClientProjectProperties;

/**

 * SharabilityQueryImplementation for j2seproject with multiple sources

 */

public class AppClientSharabilityQuery implements SharabilityQueryImplementation, PropertyChangeListener {

    private final AntProjectHelper helper;

    private final PropertyEvaluator evaluator;

    private final SourceRoots srcRoots;

    private final SourceRoots testRoots;

    private SharabilityQueryImplementation delegate;

    /**

     * Creates new AppClientSharabilityQuery

     *

     * @param helper AntProjectHelper

     * @param evaluator PropertyEvaluator

     * @param srcRoots sources

     * @param testRoots tests

     */

    AppClientSharabilityQuery (AntProjectHelper helper, PropertyEvaluator evaluator, SourceRoots srcRoots, SourceRoots testRoots) {

        this.helper = helper;

        this.evaluator = evaluator;

        this.srcRoots = srcRoots;

        this.testRoots = testRoots;

        this.srcRoots.addPropertyChangeListener(this);

        this.testRoots.addPropertyChangeListener(this);

    }

    /**

     * Check whether a file or directory should be shared.

     * If it is, it ought to be committed to a VCS if the user is using one.

     * If it is not, it is either a disposable build product, or a per-user

     * private file which is important but should not be shared.

     * @param file a file to check for sharability (may or may not yet exist)

     * @return one of {@link org.netbeans.api.queries.SharabilityQuery}'s constants

     */

    public int getSharability(final File file) {

        Integer ret = ProjectManager.mutex().readAccess(new Mutex.Action<Integer>() {

            public Integer run() {

                synchronized (AppClientSharabilityQuery.this) {

                    if (delegate == null) {

                        delegate = createDelegate ();

                    }

                    return new Integer(delegate.getSharability (file));

                }

            }

        });

        return ret.intValue();

    }

    public void propertyChange(PropertyChangeEvent evt) {

        if (SourceRoots.PROP_ROOT_PROPERTIES.equals(evt.getPropertyName())) {

            synchronized (this) {

                this.delegate = null;

            }

        }

    }

    private SharabilityQueryImplementation createDelegate () {

        String[] srcProps = srcRoots.getRootProperties();

        String[] testProps = testRoots.getRootProperties();

        String[] props = new String [srcProps.length + testProps.length + 1];

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

            props[i] = "${"+srcProps[i]+"}"; // NOI18N

        }

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

            props[srcProps.length+i] = "${"+testProps[i]+"}"; // NOI18N

        }

        props[props.length - 1] = "${" + AppClientProjectProperties.META_INF + "}"; // NOI18N

        return helper.createSharabilityQuery(this.evaluator, props,

            new String[] {

                "${" + AppClientProjectProperties.DIST_DIR + "}", // NOI18N

                "${" + AppClientProjectProperties.BUILD_DIR + "}", // NOI18N

            });

    }

}

/*

 * 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.netbeans.modules.j2ee.clientproject;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.io.File;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URI;

import java.util.Arrays;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.HashMap;

import java.text.MessageFormat;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.util.WeakListeners;

import org.openide.util.Mutex;

import org.openide.util.NbBundle;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

import org.w3c.dom.Document;

import org.netbeans.spi.project.support.ant.AntProjectHelper;

import org.netbeans.spi.project.support.ant.AntProjectEvent;

import org.netbeans.spi.project.support.ant.AntProjectListener;

import org.netbeans.spi.project.support.ant.EditableProperties;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;

import org.netbeans.spi.project.support.ant.ReferenceHelper;

import org.netbeans.api.project.ProjectManager;

import org.netbeans.api.java.project.JavaProjectConstants;

import org.openide.util.Exceptions;

/**

 * This class represents a project source roots. It is used to obtain roots as Ant properties, FileObject's

 * or URLs.

 * @author Tomas Zezula

 */

public final class SourceRoots {

    public static final String PROP_ROOT_PROPERTIES = "rootProperties";    //NOI18N

    public static final String PROP_ROOTS = "roots";   //NOI18N

    public static final String DEFAULT_SOURCE_LABEL = NbBundle.getMessage(SourceRoots.class, "NAME_src.dir");

    public static final String DEFAULT_TEST_LABEL = NbBundle.getMessage(SourceRoots.class, "NAME_test.src.dir");

    private final UpdateHelper helper;

    private final PropertyEvaluator evaluator;

    private final ReferenceHelper refHelper;

    private final String elementName;

    private final String newRootNameTemplate;

    private List<String> sourceRootProperties;

    private List<String> sourceRootNames;

    private List<FileObject> sourceRoots;

    private List<URL> sourceRootURLs;

    private final PropertyChangeSupport support;

    private final ProjectMetadataListener listener;

    private final boolean isTest;

    private final File projectDir;

    /**

     * Creates new SourceRoots

     * @param helper

     * @param evaluator

     * @param elementName the name of XML element under which are declared the roots

     * @param newRootNameTemplate template for new property name of source root

     */

    SourceRoots (UpdateHelper helper, PropertyEvaluator evaluator, ReferenceHelper refHelper, String elementName, boolean isTest, String newRootNameTemplate) {

        assert helper != null && evaluator != null && refHelper != null && elementName != null && newRootNameTemplate != null;

        this.helper = helper;

        this.evaluator = evaluator;

        this.refHelper = refHelper;

        this.elementName = elementName;

        this.isTest = isTest;

        this.newRootNameTemplate = newRootNameTemplate;

        this.projectDir = FileUtil.toFile(this.helper.getAntProjectHelper().getProjectDirectory());

        this.support = new PropertyChangeSupport(this);

        this.listener = new ProjectMetadataListener();

        this.evaluator.addPropertyChangeListener (WeakListeners.propertyChange(this.listener,this.evaluator));

        this.helper.getAntProjectHelper().addAntProjectListener(WeakListeners.create(AntProjectListener.class, this.listener,this.helper));

    }

    /**

     * Returns the display names of soruce roots

     * The returned array has the same length as an array returned by the getRootProperties.

     * It may contain empty strings but not null.

     * @return an array of String

     */

    public String[] getRootNames() {

        return ProjectManager.mutex().readAccess(new Mutex.Action<String[]>() {

            public String[] run() {

                synchronized (SourceRoots.this) {

                    if (sourceRootNames == null) {

                        readProjectMetadata();

                    }

                }

                return sourceRootNames.toArray(new String[sourceRootNames.size()]);

            }

        });

    }

    /**

     * Returns names of Ant properties in the project.properties file holding the source roots.

     * @return an array of String

     */

    public String[] getRootProperties () {

        return ProjectManager.mutex().readAccess(new Mutex.Action<String[]>() {

            public String[] run() {

                synchronized (SourceRoots.this) {

                    if (sourceRootProperties == null) {

                        readProjectMetadata();

                    }

                }

                return sourceRootProperties.toArray(new String[sourceRootProperties.size()]);

            }

        });

    }

    /**

     * Returns the source roots

     * @return an array of FileObject

     */

    public FileObject[] getRoots () {

        return ProjectManager.mutex().readAccess(new Mutex.Action<FileObject[]>() {

                public FileObject[] run () {

                    synchronized (this) {

                        //Local caching

                        if (sourceRoots == null) {

                            String[] srcProps = getRootProperties();

                            List<FileObject> result = new ArrayList<FileObject>();

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

                                String prop = evaluator.getProperty(srcProps[i]);

                                if (prop != null) {

                                    FileObject f = helper.getAntProjectHelper().resolveFileObject(prop);

                                    if (f == null) {

                                        continue;

                                    }

                                    if (FileUtil.isArchiveFile(f)) {

                                        f = FileUtil.getArchiveRoot(f);

                                    }

                                    result.add(f);

                                }

                            }

                            sourceRoots = Collections.unmodifiableList(result);

                        }

                    }

                    return sourceRoots.toArray(new FileObject[sourceRoots.size()]);

                }

        });

    }

    /**

     * Returns the source roots as URLs.

     * @return an array of URL

     */

    public URL[] getRootURLs() {

        return ProjectManager.mutex().readAccess(new Mutex.Action<URL[]>() {

            public URL[] run() {

                synchronized (this) {

                    //Local caching

                    if (sourceRootURLs == null) {

                        String[] srcProps = getRootProperties();

                        List<URL> result = new ArrayList<URL>();

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

                            String prop = evaluator.getProperty(srcProps[i]);

                            if (prop != null) {

                                File f = helper.getAntProjectHelper().resolveFile(prop);

                                try {

                                    URL url = f.toURI().toURL();

                                    if (!f.exists()) {

                                        url = new URL(url.toExternalForm() + "/"); // NOI18N

                                    }

                                    result.add(url);

                                } catch (MalformedURLException e) {

                                    Exceptions.printStackTrace(e);

                                }

                            }

                        }

                        sourceRootURLs = Collections.unmodifiableList(result);

                    }

                }

                return sourceRootURLs.toArray(new URL[sourceRootURLs.size()]);

            }

        });

    }

    /**

     * Adds PropertyChangeListener

     * @param listener

     */

    public void addPropertyChangeListener (PropertyChangeListener listener) {

        this.support.addPropertyChangeListener (listener);

    }

    /**

     * Removes PropertyChangeListener

     * @param listener

     */

    public void removePropertyChangeListener (PropertyChangeListener listener) {

        this.support.removePropertyChangeListener (listener);

    }

    /**

     * Replaces the current roots by the new ones

     * @param roots the URLs of new roots

     * @param labels the names of roots

     */

    public void putRoots (final URL[] roots, final String[] labels) {

        ProjectManager.mutex().writeAccess(new Runnable() {

                public void run() {

                    String[] originalProps = getRootProperties();

                    URL[] originalRoots = getRootURLs();

                    Map<URL, String> oldRoots2props = new HashMap<URL, String>();

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

                        oldRoots2props.put (originalRoots[i],originalProps[i]);

                    }

                    Map<URL,String> newRoots2lab = new HashMap<URL,String>();

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

                        newRoots2lab.put (roots[i],labels[i]);

                    }

                    Element cfgEl = helper.getPrimaryConfigurationData(true);

                    NodeList nl = cfgEl.getElementsByTagNameNS(AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE, elementName);

                    assert nl.getLength() == 1 : "Illegal project.xml"; //NOI18N

                    Element ownerElement = (Element) nl.item(0);

                    //Remove all old roots

                    NodeList rootsNodes = ownerElement.getElementsByTagNameNS(AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE, "root");    //NOI18N

                    while (rootsNodes.getLength()>0) {

                        Element root = (Element) rootsNodes.item(0);

                        ownerElement.removeChild(root);

                    }

                    //Remove all unused root properties

                    List newRoots = Arrays.asList(roots);

                    Map<URL, String> propsToRemove = new HashMap<URL, String>(oldRoots2props);

                    propsToRemove.keySet().removeAll(newRoots);

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

                    for (Iterator<String> it = propsToRemove.values().iterator(); it.hasNext();) {

                        String propName = it.next();

                        props.remove(propName);

                    }

                    helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH,props);

                    //Add the new roots

                    Document doc = ownerElement.getOwnerDocument();

                    oldRoots2props.keySet().retainAll(newRoots);

                    for (Iterator it = newRoots.iterator(); it.hasNext();) {

                        URL newRoot = (URL) it.next ();

                        String rootName = oldRoots2props.get (newRoot);

                        if (rootName == null) {

                            //Root is new generate property for it

                            props = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);

                            String[] names = newRoot.getPath().split("/");  //NOI18N

                            rootName = MessageFormat.format(newRootNameTemplate,new Object[]{names[names.length-1],""});    //NOI18N

                            int rootIndex = 1;

                            while (props.containsKey(rootName)) {

                                rootIndex++;

                                rootName = MessageFormat.format(newRootNameTemplate,new Object[]{names[names.length-1],new Integer(rootIndex)});

                            }

                            File f = FileUtil.normalizeFile(new File(URI.create(newRoot.toExternalForm())));

                            File projDir = FileUtil.toFile(helper.getAntProjectHelper().getProjectDirectory());

                            String path = f.getAbsolutePath();

                            String prjPath = projDir.getAbsolutePath()+File.separatorChar;

                            if (path.startsWith(prjPath)) {

                                path = path.substring(prjPath.length());

                            }

                            else {

                                path = refHelper.createForeignFileReference(f, JavaProjectConstants.SOURCES_TYPE_JAVA);

                                props = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);

                            }

                            props.put(rootName,path);

                            helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH,props);

                        }

                        Element newRootNode = doc.createElementNS(AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE, "root"); //NOI18N

                        newRootNode.setAttribute("id",rootName);    //NOI18N

                        String label = newRoots2lab.get (newRoot);

                        if (label != null && label.length()>0 && !label.equals (getRootDisplayName(null,rootName))) { //NOI18N

                            newRootNode.setAttribute("name",label); //NOI18N

                        }

                        ownerElement.appendChild (newRootNode);

                    }

                    helper.putPrimaryConfigurationData(cfgEl,true);

                }

            }

        );

    }

    /**

     * Translates root name into display name of source/test root

     * @param rootName the name of root got from {@link SourceRoots#getRootNames}

     * @param propName the name of property the root is stored in

     * @return the label to be displayed

     */

    public String getRootDisplayName (String rootName, String propName) {

        if (rootName == null || rootName.length() ==0) {

            //If the prop is src.dir use the default name

            if (isTest && "test.src.dir".equals(propName)) {    //NOI18N

                rootName = DEFAULT_TEST_LABEL;

            }

            else if (!isTest && "src.dir".equals(propName)) {   //NOI18N

                rootName = DEFAULT_SOURCE_LABEL;

            }

            else {

                //If the name is not given, it should be either a relative path in the project dir

                //or absolute path when the root is not under the project dir

                String propValue = evaluator.getProperty(propName);

                File sourceRoot = propValue == null ? null : helper.getAntProjectHelper().resolveFile(propValue);

                rootName = createInitialDisplayName(sourceRoot);

            }

        }

        return rootName;

    }

    /**

     * Creates initial display name of source/test root

     * @param sourceRoot the source root

     * @return the label to be displayed

     */

    public String createInitialDisplayName (File sourceRoot) {

        String rootName;

        if (sourceRoot != null) {

        String srPath = sourceRoot.getAbsolutePath();

        String pdPath = projectDir.getAbsolutePath() + File.separatorChar;

        if (srPath.startsWith(pdPath)) {

            rootName = srPath.substring(pdPath.length());

        }

        else {

            rootName = sourceRoot.getAbsolutePath();

        }

        }

        else {

            rootName = isTest ? DEFAULT_TEST_LABEL : DEFAULT_SOURCE_LABEL;

        }

        return rootName;

    }

    /**

     * Returns true if this SourceRoots instance represents source roots belonging to

     * the tests compilation unit.

     * @return boolean

     */

    public boolean isTest () {

        return this.isTest;

    }

    private void resetCache (boolean isXMLChange, String propName) {

        boolean fire = false;

        synchronized (this) {

            //In case of change reset local cache

            if (isXMLChange) {

                this.sourceRootProperties = null;

                this.sourceRootNames = null;

                this.sourceRoots = null;

                this.sourceRootURLs = null;

                fire = true;

            } else if (propName == null || (sourceRootProperties != null && sourceRootProperties.contains(propName))) {

                this.sourceRoots = null;

                this.sourceRootURLs = null;

                fire = true;

            }

        }

        if (fire) {

            if (isXMLChange) {

                this.support.firePropertyChange (PROP_ROOT_PROPERTIES,null,null);

            }

            this.support.firePropertyChange (PROP_ROOTS,null,null);

        }

    }

    private void readProjectMetadata () {

        Element cfgEl = helper.getPrimaryConfigurationData(true);

        NodeList nl = cfgEl.getElementsByTagNameNS(AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE, elementName);

        assert nl.getLength() == 0 || nl.getLength() == 1 : "Illegal project.xml"; //NOI18N

        List<String> rootProps = new ArrayList<String>();

        List<String> rootNames = new ArrayList<String>();

        // It can be 0 in the case when the project is created by J2SEProjectGenerator and not yet customized

        if (nl.getLength()==1) {

            NodeList roots = ((Element)nl.item(0)).getElementsByTagNameNS(AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE, "root");    //NOI18N

            for (int i=0; i<roots.getLength(); i++) {

                Element root = (Element) roots.item(i);

                String value = root.getAttribute("id");  //NOI18N

                assert value.length() > 0 : "Illegal project.xml";

                rootProps.add(value);

                value = root.getAttribute("name");  //NOI18N

                rootNames.add (value);

            }

        }

        this.sourceRootProperties = Collections.unmodifiableList(rootProps);

        this.sourceRootNames = Collections.unmodifiableList(rootNames);

    }

    private class ProjectMetadataListener implements PropertyChangeListener,AntProjectListener {

        public void propertyChange(PropertyChangeEvent evt) {

            resetCache (false,evt.getPropertyName());

        }

        public void configurationXmlChanged(AntProjectEvent ev) {

            resetCache (true,null);

        }

        public void propertiesChanged(AntProjectEvent ev) {

            //Handled by propertyChange

        }

    }

}

/*

 * 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.netbeans.modules.j2ee.clientproject;

import java.io.IOException;

import javax.swing.JButton;

import org.netbeans.modules.j2ee.clientproject.api.AppClientProjectGenerator;

import org.netbeans.modules.j2ee.clientproject.ui.customizer.AppClientProjectProperties;

import org.netbeans.spi.project.support.ant.GeneratedFilesHelper;

import org.w3c.dom.Comment;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.Text;

import org.openide.DialogDisplayer;

import org.openide.NotifyDescriptor;

import org.openide.util.NbBundle;

import org.openide.util.Mutex;

import org.netbeans.api.project.Project;

import org.netbeans.api.project.ProjectManager;

import org.netbeans.spi.project.AuxiliaryConfiguration;

import org.netbeans.spi.project.support.ant.AntProjectHelper;

import org.netbeans.spi.project.support.ant.EditableProperties;

import org.openide.util.Exceptions;

/**

 * Proxy for the AntProjectHelper which defers the update of the project metadata

 * to explicit user action. Currently it is hard coded for update from

 * "http://www.netbeans.org/ns/j2se-project/1" to "http://www.netbeans.org/ns/j2se-project/2".

 * In future it should define plugable SPI.

 */

public class UpdateHelper {

    private static final boolean TRANSPARENT_UPDATE = Boolean.getBoolean("carproject.transparentUpdate");

    private static final String BUILD_NUMBER = System.getProperty("netbeans.buildnumber"); // NOI18N

    private static final String MINIMUM_ANT_VERSION_ELEMENT = "minimum-ant-version"; // NOI18N

    private final Project project;

    private final AntProjectHelper helper;

    private final AuxiliaryConfiguration cfg;

    private final GeneratedFilesHelper genFileHelper;

    private final Notifier notifier;

    private boolean alreadyAskedInWriteAccess;

    private Boolean isCurrent;

    private Element cachedElement;

    /**

     * Creates new UpdateHelper

     * @param project

     * @param helper AntProjectHelper

     * @param cfg AuxiliaryConfiguration

     * @param genFileHelper GeneratedFilesHelper

     * @param notifier used to ask user about project update

     */

    UpdateHelper (Project project, AntProjectHelper helper, AuxiliaryConfiguration cfg, GeneratedFilesHelper genFileHelper, Notifier notifier) {

        assert project != null && helper != null && cfg != null && genFileHelper != null && notifier != null;

        this.project = project;

        this.helper = helper;

        this.cfg = cfg;

        this.genFileHelper = genFileHelper;

        this.notifier = notifier;

    }

    /**

     * Returns the AntProjectHelper.getProperties(), {@link AntProjectHelper#getProperties(String)}

     * @param path a relative URI in the project directory.

     * @return a set of properties

     */

    public EditableProperties getProperties (final String path) {

        //Properties are the same in both j2seproject/1 and j2seproject/2

        return ProjectManager.mutex().readAccess(new Mutex.Action<EditableProperties>(){

            public EditableProperties run() {

                if (!isCurrent() && AntProjectHelper.PROJECT_PROPERTIES_PATH.equals(path)) { //Only project properties were changed

                    return getUpdatedProjectProperties ();

                }

                else {

                    return helper.getProperties(path);

                }

            }

        });

    }

    /**

     * In the case that the project is of current version or the properties are not {@link AntProjectHelper#PROJECT_PROPERTIES_PATH}

     * it calls AntProjectHelper.putProperties(), {@link AntProjectHelper#putProperties(String, EditableProperties)}

     * otherwise it asks user to updata project. If the user agrees with the project update, it does the update and calls

     * AntProjectHelper.putProperties().

     * @param path a relative URI in the project directory.

     * @param props a set of properties

     */

    public void putProperties(final String path, final EditableProperties props) {

        ProjectManager.mutex().writeAccess(new Runnable() {

            public void run() {

                if (isCurrent() || !AntProjectHelper.PROJECT_PROPERTIES_PATH.equals(path)) {  //Only project props should cause update

                    helper.putProperties(path,props);

                } else if (canUpdate()) {

                    try {

                        saveUpdate();

                        helper.putProperties(path,props);

                    } catch (IOException ioe) {

                        Exceptions.printStackTrace(ioe);

                    }

                }

            }

        });

    }

    /**

     * In the case that the project is of current version or shared is false it delegates to

     * AntProjectHelper.getPrimaryConfigurationData(), {@link AntProjectHelper#getPrimaryConfigurationData(boolean)}.

     * Otherwise it creates an in memory update of shared configuration data and returns it.

     * @param shared if true, refers to <code>project.xml</code>, else refers to

     *               <code>private.xml</code>

     * @return the configuration data that is available

     */

    public Element getPrimaryConfigurationData (final boolean shared) {

        return ProjectManager.mutex().readAccess(new Mutex.Action<Element>(){

            public Element run() {

                if (!shared || isCurrent()) { //Only shared props should cause update

                    return helper.getPrimaryConfigurationData(shared);

                }

                return getUpdatedSharedConfigurationData ();

            }

        });

    }

    /**

     * In the case that the project is of current version or shared is false it calls AntProjectHelper.putPrimaryConfigurationData(),

     * {@link AntProjectHelper#putPrimaryConfigurationData(Element, boolean)}.

     * Otherwise it asks user to update the project. If the user agrees with the project update, it does the update and calls

     * AntProjectHelper.PrimaryConfigurationData().

     * @param element the configuration data

     * @param shared if true, refers to <code>project.xml</code>, else refers to

     * <code>private.xml</code>

     */

    public void putPrimaryConfigurationData(final Element element, final boolean shared) {

        ProjectManager.mutex().writeAccess(new Runnable() {

            public void run() {

                if (!shared || isCurrent()) {

                    helper.putPrimaryConfigurationData(element, shared);

                } else if (canUpdate()) {

                    try {

                        saveUpdate();

                        helper.putPrimaryConfigurationData(element, shared);

                    } catch (IOException ioe) {

                        Exceptions.printStackTrace(ioe);

                    }

                }

            }

        });

    }

    /**

     * Returns an AntProjectHelper. The helper may not be used for accessing/storing project metadata.

     * For project metadata manipulation the UpdateHelper must be used.

     * @return AntProjectHelper

     */

    public AntProjectHelper getAntProjectHelper () {

        return this.helper;

    }

    /**

     * Request an saving of update. If the project is not of current version the user will be asked to update the project.

     * If the user agrees with an update the project is updated.

     * @return true if the metadata are of current version or updated

     */

    public boolean requestSave () throws IOException{

        if (isCurrent()) {

            return true;

        }

        if (!canUpdate()) {

            return false;

        }

        saveUpdate ();

        return true;

    }

    /**

     * Returns true if the project is of current version.

     * @return true if the project is of current version, otherwise false.

     */

    public synchronized boolean isCurrent () {

        /*

        if (this.isCurrent == null) {

            if ((this.cfg.getConfigurationFragment("data","http://www.netbeans.org/ns/j2se-project/1",true) != null) ||

                (this.cfg.getConfigurationFragment("data","http://www.netbeans.org/ns/j2se-project/2",true) != null)) {

                this.isCurrent = Boolean.FALSE;

            } else {

                this.isCurrent = Boolean.TRUE;

            }

        }

        return isCurrent.booleanValue();

         */

        //there are no other versions yet => we can always return true

        return true;

    }

    private boolean canUpdate () {

        if (TRANSPARENT_UPDATE) {

            return true;

        }

        //Ask just once under a single write access

        if (alreadyAskedInWriteAccess) {

            return false;

        }

        else {

            boolean canUpdate = this.notifier.canUpdate();

            if (!canUpdate) {

                alreadyAskedInWriteAccess = true;

                ProjectManager.mutex().postReadRequest(new Runnable() {

                    public void run() {

                        alreadyAskedInWriteAccess = false;

                    }

                });

            }

            return canUpdate;

        }

    }

    private void saveUpdate () throws IOException {

        this.helper.putPrimaryConfigurationData(getUpdatedSharedConfigurationData(),true);

        this.cfg.removeConfigurationFragment("data","http://www.netbeans.org/ns/j2se-project/1",true); //NOI18N

        this.cfg.removeConfigurationFragment("data","http://www.netbeans.org/ns/j2se-project/2",true); //NOI18N

        ProjectManager.getDefault().saveProject (this.project);

        synchronized(this) {

            this.isCurrent = Boolean.TRUE;

        }

    }

    private synchronized Element getUpdatedSharedConfigurationData () {

        if (cachedElement == null) {

            Element  oldRoot = this.cfg.getConfigurationFragment("data","http://www.netbeans.org/ns/j2se-project/1",true);    //NOI18N

            if (oldRoot != null) {

                Document doc = oldRoot.getOwnerDocument();

                Element newRoot = doc.createElementNS (AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE,"data"); //NOI18N

                copyDocument (doc, oldRoot, newRoot);

                Element sourceRoots = doc.createElementNS(AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE,"source-roots");  //NOI18N

                Element root = doc.createElementNS (AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE,"root");   //NOI18N

                root.setAttribute ("id","src.dir");   //NOI18N

                sourceRoots.appendChild(root);

                newRoot.appendChild (sourceRoots);

                Element testRoots = doc.createElementNS(AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE,"test-roots");  //NOI18N

                root = doc.createElementNS (AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE,"root");   //NOI18N

                root.setAttribute ("id","test.src.dir");   //NOI18N

                testRoots.appendChild (root);

                newRoot.appendChild (testRoots);

                cachedElement = updateMinAntVersion (newRoot, doc);

            } else {

                oldRoot = this.cfg.getConfigurationFragment("data","http://www.netbeans.org/ns/j2se-project/2",true);    //NOI18N

                if (oldRoot != null) {

                    Document doc = oldRoot.getOwnerDocument();

                    Element newRoot = doc.createElementNS (AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE,"data"); //NOI18N

                    copyDocument (doc, oldRoot, newRoot);

                    cachedElement = updateMinAntVersion (newRoot, doc);

                }

            }

        }

        return cachedElement;

    }

    private synchronized EditableProperties getUpdatedProjectProperties () {

        EditableProperties cachedProperties = this.helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);

        //The javadoc.additionalparam was not in NB 4.0

        if (cachedProperties.get (AppClientProjectProperties.JAVADOC_ADDITIONALPARAM)==null) {

            cachedProperties.put (AppClientProjectProperties.JAVADOC_ADDITIONALPARAM,"");    //NOI18N

        }

        if (cachedProperties.get ("build.generated.dir")==null) { //NOI18N

            cachedProperties.put ("build.generated.dir","${build.dir}/generated"); //NOI18N

        }

         if (cachedProperties.get (AppClientProjectProperties.META_INF)==null) { //NOI18N

            cachedProperties.put (AppClientProjectProperties.META_INF,"${src.dir}/conf"); //NOI18N

        }

        return cachedProperties;

    }

    private static void copyDocument (Document doc, Element from, Element to) {

        NodeList nl = from.getChildNodes();

        int length = nl.getLength();

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

            Node node = nl.item (i);

            Node newNode = null;

            switch (node.getNodeType()) {

                case Node.ELEMENT_NODE:

                    Element oldElement = (Element) node;

                    newNode = doc.createElementNS(AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE,oldElement.getTagName());

                    NamedNodeMap m = oldElement.getAttributes();

                    Element newElement = (Element) newNode;

                    for (int index = 0; index < m.getLength(); index++) {

                        Node attr = m.item(index);

                          newElement.setAttribute(attr.getNodeName(), attr.getNodeValue());

                    }

                    copyDocument(doc,oldElement,newElement);

                    break;

                case Node.TEXT_NODE:

                    Text oldText = (Text) node;

                    newNode = doc.createTextNode(oldText.getData());

                    break;

                case Node.COMMENT_NODE:

                    Comment oldComment = (Comment) node;

                    newNode = doc.createComment(oldComment.getData());

                    break;

            }

            if (newNode != null) {

                to.appendChild (newNode);

            }

        }

    }

    private static Element updateMinAntVersion (final Element root, final Document doc) {

        NodeList list = root.getElementsByTagNameNS (AppClientProjectType.PROJECT_CONFIGURATION_NAMESPACE,MINIMUM_ANT_VERSION_ELEMENT);

        if (list.getLength() == 1) {

            Element me = (Element) list.item(0);

            list = me.getChildNodes();

            if (list.getLength() == 1) {

                me.replaceChild (doc.createTextNode(AppClientProjectGenerator.MINIMUM_ANT_VERSION), list.item(0));

                return root;

            }

        }

        assert false : "Invalid project file"; //NOI18N

        return root;

    }

    /**

     * Creates an default Notifier. The default notifier displays a dialog warning user about project update.

     * @return notifier

     */

    public static Notifier createDefaultNotifier () {

        return new Notifier() {

            public boolean canUpdate() {

                JButton updateOption = new JButton (NbBundle.getMessage(UpdateHelper.class, "CTL_UpdateOption"));

                updateOption.getAccessibleContext().setAccessibleDescription(NbBundle.getMessage(UpdateHelper.class, "AD_UpdateOption"));

                return DialogDisplayer.getDefault().notify(

                    new NotifyDescriptor (NbBundle.getMessage(UpdateHelper.class,"TXT_ProjectUpdate", BUILD_NUMBER),

                        NbBundle.getMessage(UpdateHelper.class,"TXT_ProjectUpdateTitle"),

                        NotifyDescriptor.DEFAULT_OPTION,

                        NotifyDescriptor.WARNING_MESSAGE,

                        new Object[] {

                            updateOption,

                            NotifyDescriptor.CANCEL_OPTION

                        },

                        updateOption)) == updateOption;

            }

        };

    }

    /**

     * Interface used by the UpdateHelper to ask user about

     * the project update.

     */

    public static interface Notifier {

        /**

         * Asks user to update the project

         * @return true if the project should be updated

         */

        public boolean canUpdate ();

    }

}

import org.netbeans.modules.j2ee.clientproject.UpdateHelper;

import org.netbeans.modules.j2ee.clientproject.ui.customizer.PlatformUiSupport;

import org.netbeans.modules.j2ee.clientproject.UpdateHelper;

import org.netbeans.modules.j2ee.clientproject.SourceRoots;

import org.netbeans.modules.j2ee.clientproject.SourceRoots;

/*

 * 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-2007 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.netbeans.modules.j2ee.clientproject.queries;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.nio.charset.Charset;

import java.nio.charset.IllegalCharsetNameException;

import org.netbeans.modules.j2ee.clientproject.ui.customizer.AppClientProjectProperties;

import org.netbeans.spi.queries.FileEncodingQueryImplementation;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;

import org.openide.filesystems.FileObject;

/**

 *

 * @author Tomas Zezula

 */

public class AppClientProjectEncodingQueryImpl extends FileEncodingQueryImplementation implements PropertyChangeListener {

    private final PropertyEvaluator eval;

    private Charset cache;

    /** Creates a new instance of J2SEProjectEncodingQueryImpl */

    public AppClientProjectEncodingQueryImpl(final PropertyEvaluator eval) {

        assert eval != null;

        this.eval = eval;

        this.eval.addPropertyChangeListener(this);

    }

    public Charset getEncoding(FileObject file) {

        assert file != null;

        synchronized (this) {

            if (cache != null) {

                return cache;

            }

        }

        String enc = eval.getProperty(AppClientProjectProperties.SOURCE_ENCODING);

        synchronized (this) {

            if (cache == null) {

                try {

                    cache = enc == null ? Charset.defaultCharset() : Charset.forName(enc);

                } catch (IllegalCharsetNameException exception) {

                    return null;

                }

            }

            return cache;

        }

    }

    public void propertyChange(PropertyChangeEvent event) {

        String propName = event.getPropertyName();

        if (propName == null || propName.equals(AppClientProjectProperties.SOURCE_ENCODING)) {

            synchronized (this) {

                cache = null;

            }

        }

    }

}

/*

 * 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.netbeans.modules.j2ee.clientproject.queries;

import java.io.File;

import org.netbeans.spi.java.queries.SourceForBinaryQueryImplementation;

import org.netbeans.spi.project.support.ant.AntProjectHelper;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import java.net.URL;

import java.net.MalformedURLException;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeEvent;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.Map;

import java.util.HashMap;

import javax.swing.event.ChangeListener;

import javax.swing.event.ChangeEvent;

import org.netbeans.api.java.queries.SourceForBinaryQuery;

import org.netbeans.spi.project.support.ant.PropertyEvaluator;

import org.netbeans.modules.j2ee.clientproject.SourceRoots;

import org.netbeans.modules.j2ee.clientproject.ui.customizer.AppClientProjectProperties;

import org.openide.util.Exceptions;

/**

 * Finds sources corresponding to binaries in a J2SE project.

 * @author Jesse Glick, Tomas Zezula

 */

public class CompiledSourceForBinaryQuery implements SourceForBinaryQueryImplementation {

    private final AntProjectHelper helper;

    private final PropertyEvaluator evaluator;

    private final SourceRoots sourceRoots;

    private final SourceRoots testRoots;

    private Map<URL,SourceForBinaryQuery.Result> cache = new HashMap<URL,SourceForBinaryQuery.Result>();

    public CompiledSourceForBinaryQuery(AntProjectHelper helper, PropertyEvaluator evaluator, SourceRoots srcRoots, SourceRoots testRoots) {

        this.helper = helper;

        this.evaluator = evaluator;

        this.sourceRoots = srcRoots;

        this.testRoots = testRoots;

    }

    public SourceForBinaryQuery.Result findSourceRoots(URL binaryRoot) {

        if (FileUtil.getArchiveFile(binaryRoot) != null) {

            binaryRoot = FileUtil.getArchiveFile(binaryRoot);

            // XXX check whether this is really the root

        }

        SourceForBinaryQuery.Result res = cache.get(binaryRoot);

        if (res != null) {

            return res;

        }

        SourceRoots src = null;

        if (hasSources(binaryRoot, AppClientProjectProperties.BUILD_CLASSES_DIR)) {

            src = this.sourceRoots;

        } else if (hasSources(binaryRoot, AppClientProjectProperties.DIST_JAR)) {

            src = this.sourceRoots;

        } else if (hasSources(binaryRoot, AppClientProjectProperties.BUILD_TEST_CLASSES_DIR)) {

            src = this.testRoots;

        }

        if (src == null) {

            return null;

        } else {

            res = new Result(src);

            cache.put(binaryRoot, res);

            return res;

        }

    }

    private boolean hasSources(URL binaryRoot, String binaryProperty) {

        try {

            String outDir = evaluator.getProperty(binaryProperty);

            if (outDir != null) {

                File f = helper.resolveFile(outDir);

                URL url = f.toURI().toURL();

                if (!f.exists() && !f.getPath().toLowerCase().endsWith(".jar")) { // NOI18N

                    // non-existing

                    assert !url.toExternalForm().endsWith("/") : f; // NOI18N

                    url = new URL(url.toExternalForm() + "/"); // NOI18N

                }

                if (url.equals(binaryRoot)) {

                    return true;

                }

            }

        } catch (MalformedURLException malformedURL) {

            Exceptions.printStackTrace(malformedURL);

        }

        return false;

    }

    private static class Result implements SourceForBinaryQuery.Result, PropertyChangeListener {

        private ArrayList<ChangeListener> listeners;

        private SourceRoots sourceRoots;

        public Result(SourceRoots sourceRoots) {

            this.sourceRoots = sourceRoots;

            this.sourceRoots.addPropertyChangeListener(this);

        }

        public FileObject[] getRoots() {

            return this.sourceRoots.getRoots(); //No need to cache it, SourceRoots does

        }

        public synchronized void addChangeListener(ChangeListener l) {

            if (this.listeners == null) {

                this.listeners = new ArrayList<ChangeListener>();

            }

            this.listeners.add(l);

        }

        public synchronized void removeChangeListener(ChangeListener l) {

            if (this.listeners == null) {

                return;

            }

            this.listeners.remove(l);

        }

        public void propertyChange(PropertyChangeEvent evt) {

            if (SourceRoots.PROP_ROOTS.equals(evt.getPropertyName())) {

                this.fireChange();

            }

        }

        private void fireChange() {

            Iterator<ChangeListener> it;

            synchronized (this) {

                if (this.listeners == null) {

                    return;

                }

                @SuppressWarnings("unchecked")

                ArrayList<ChangeListener> cloned = (ArrayList) this.listeners.clone();

                it = cloned.iterator();

            }

            ChangeEvent event = new ChangeEvent(this);