/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.netbeans.modules.debugger.jpda.ant;

import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.beans.PropertyChangeEvent;

import com.sun.jdi.Bootstrap;
import com.sun.jdi.connect.ListeningConnector;
import com.sun.jdi.connect.Transport;
import com.sun.jdi.connect.Connector;
import java.beans.PropertyChangeListener;
import java.io.FileFilter;
import java.io.IOException;

import java.lang.ref.WeakReference;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.UnknownHostException;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.apache.tools.ant.BuildEvent;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.BuildListener;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.Path;
import org.netbeans.api.debugger.Breakpoint;
import org.netbeans.api.debugger.jpda.DebuggerStartException;

import org.openide.util.RequestProcessor;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;

import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.queries.SourceForBinaryQuery;
import org.netbeans.api.debugger.DebuggerManager;
import org.netbeans.api.debugger.jpda.JPDADebugger;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;
import org.netbeans.api.debugger.DebuggerEngine;
import org.netbeans.api.debugger.DebuggerManagerAdapter;
import org.netbeans.api.debugger.Session;
import org.netbeans.api.debugger.jpda.ExceptionBreakpoint;
import org.netbeans.api.debugger.jpda.JPDAClassType;
import org.netbeans.api.debugger.jpda.JPDAThread;
import org.netbeans.api.debugger.jpda.MethodBreakpoint;
import org.netbeans.api.debugger.jpda.ObjectVariable;
import org.netbeans.api.debugger.jpda.Variable;
import org.netbeans.api.debugger.jpda.event.JPDABreakpointEvent;
import org.netbeans.api.debugger.jpda.event.JPDABreakpointListener;
import org.netbeans.api.java.platform.JavaPlatform;
import org.netbeans.api.java.source.BuildArtifactMapper;
import org.netbeans.api.java.source.BuildArtifactMapper.ArtifactsUpdated;
import org.netbeans.api.project.ProjectManager;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.WeakListeners;


/**
 * Ant task to start the NetBeans JPDA debugger in listening mode.
 *
 * @author Jesse Glick, David Konecny
 */
public class JPDAStart extends Task implements Runnable {

    private static final Logger logger = Logger.getLogger("org.netbeans.modules.debugger.jpda.ant"); // NOI18N

    private static final String URL_EMBEDDING = String.format("!%c",File.separatorChar);   //NOI18N
    private static final String SOCKET_TRANSPORT = "dt_socket"; // NOI18N
    private static final String SHMEM_TRANSPORT = "dt_shmem"; // NOI18N
    private static final String SOCKET_CONNECTOR = "com.sun.jdi.SocketListen"; // NOI18N
    private static final String SHMEM_CONNECTOR = "com.sun.jdi.SharedMemoryListen"; // NOI18N
    private static final String MODULE_INFO_CLZ = "module-info.class";  //NOI18N
    private static final Set<? extends String> MODULE_FILES;
    static {
        final Set<String> exts = new HashSet<String>();
        exts.add("jar");    //NOI18N
        exts.add("jmod");   //NOI18N
        MODULE_FILES = Collections.unmodifiableSet(exts);
    }

    /** Name of the property to which the JPDA address will be set.
     * Target VM should use this address and connect to it
     */
    private String                  addressProperty;
    /** Default transport is socket*/
    private String                  transport = SOCKET_TRANSPORT;
    /** Preferred connector name. May be null. */
    private String                  connector;
    /** Name which will represent this debugging session in debugger UI.
     * If known in advance it should be name of the app which will be debugged.
     */
    private String                  name;
    /** Explicit sourcepath of the debugged process. */
    private Sourcepath              sourcepath = null;
    private Path                    plainSourcepath = null;
    private boolean                 isSourcePathExclusive;
    /** Explicit classpath of the debugged process. */
    private Path                    classpath = null;
    /** Explicit bootclasspath of the debugged process. */
    private Path                    bootclasspath = null;
    /** Explicit modulepath of the debugged process. */
    private Path                    modulepath = null;
    private final Object []         lock = new Object[2];
    /** The class debugger should stop in, or null. */
    private String                  stopClassName = null;
    private String                  listeningCP = null;
    private boolean                 useLoopBackAddress = true;
    private RequestProcessor        rp = new RequestProcessor("JPDAStart", 5);

    
    // properties ..............................................................

    public void setAddressProperty (String propertyName) {
        this.addressProperty = propertyName;
    }

    private String getAddressProperty () {
        return addressProperty;
    }

    public void setTransport (String transport) {
        logger.log(Level.FINE, "Set transport: ''{0}''", transport);
        this.transport = transport;
    }

    private String getTransport () {
        return transport;
    }
    
    public void setConnector(String connector) {
        this.connector = connector;
    }

    public String getConnector() {
        return connector;
    }

    public void setName (String name) {
        this.name = name;
    }

    private String getName () {
        return name;
    }

    public void setStopClassName (String stopClassName) {
        this.stopClassName = stopClassName;
    }

    private String getStopClassName () {
        return stopClassName;
    }

    public void setListeningcp(String listeningCP) {
        this.listeningCP = listeningCP;
    }
    
    public void setUseLoopBackAddress(String useLoopBackAddress) { // useLoopBackAddress
        this.useLoopBackAddress = Boolean.parseBoolean(useLoopBackAddress);
        logger.log(Level.FINE, "setUseLoopBackAddress = ''{0}'' => {1}", new Object[] { useLoopBackAddress, this.useLoopBackAddress });
    }

    public void addClasspath (Path path) {
        logger.log(Level.FINE, "addClasspath({0})", path);
        if (classpath != null)
            throw new BuildException ("Only one classpath subelement is supported");
        classpath = path;
    }

    public void addBootclasspath (Path path) {
        logger.log(Level.FINE, "addBootclasspath({0})", path);
        if (bootclasspath != null)
            throw new BuildException ("Only one bootclasspath subelement is supported");
        bootclasspath = path;
    }

    public void addModulepath (Path path) {
        logger.log(Level.FINE, "addModlepath({0})", path);
        if (modulepath != null)
            throw new BuildException ("Only one modulepath subelement is supported");
        modulepath = path;
    }

    public void addSourcepath (Sourcepath path) {
        logger.log(Level.FINE, "addSourcepath({0})", path);
        if (sourcepath != null)
            throw new BuildException ("Only one sourcepath subelement is supported");
        sourcepath = path;
    }

    static void verifyPaths(Project project, Path path) {
        if (path == null) return ;
        String[] paths = path.list();
        for (int i = 0; i < paths.length; i++) {
            String pathName = project.replaceProperties(paths[i]);
            File file = FileUtil.normalizeFile
                (project.resolveFile (pathName));
            if (!file.exists()) {
                project.log("Non-existing path \""+pathName+"\" provided.", Project.MSG_WARN);
                //throw new BuildException("Non-existing path \""+paths[i]+"\" provided.");
            }
        }
    }

    /** Searching for a connector in given collection.
     * @param name - name of the connector
     * @param connectors
     * @return the connector or null
     */
    private static ListeningConnector findConnector(String name, final Collection<ListeningConnector> connectors) {
        assert name != null;
        for (ListeningConnector c : connectors) {
            if (name.equals(c.name())) {
                return c;
            }
        }
        return null;
    }
    
    // main methods ............................................................

    @Override
    public void execute () throws BuildException {
        verifyPaths(getProject(), classpath);
        verifyPaths(getProject(), modulepath);
        //verifyPaths(getProject(), bootclasspath); Do not check the paths on bootclasspath (see issue #70930).
        if (sourcepath != null) {
            isSourcePathExclusive = sourcepath.isExclusive();
            plainSourcepath = sourcepath.getPlainPath();
        }
        verifyPaths(getProject(), plainSourcepath);
        try {
            logger.fine("JPDAStart.execute()"); // NOI18N
            debug ("Execute started"); // NOI18N
            if (name == null)
                throw new BuildException ("name attribute must specify name of this debugging session", getLocation ());
            if (addressProperty == null)
                throw new BuildException ("addressproperty attribute must specify name of property to which address will be set", getLocation ());
            if (transport == null)
                transport = SOCKET_TRANSPORT;
            debug ("Entering synch lock"); // NOI18N
            lock[0] = lock[1] = null;
            synchronized (lock) {
                debug ("Entered synch lock"); // NOI18N
                rp.post (this);
                try {
                    debug ("Entering wait"); // NOI18N
                    lock.wait ();
                    debug ("Wait finished"); // NOI18N
                    if (lock [1] != null) {
                        if (lock[1] instanceof DebuggerStartException) {
                            //getProject().log(((DebuggerStartException) lock[1]).getLocalizedMessage(), Project.MSG_ERR);
                            throw new BuildException(((DebuggerStartException) lock[1]).getLocalizedMessage());
                        } else if (lock[1] instanceof ThreadDeath) {
                            throw (ThreadDeath) lock[1];
                        } else {
                            throw new BuildException ((Throwable) lock [1]);
                        }
                    }
                } catch (InterruptedException e) {
                    throw new BuildException (e);
                }
            }
        } catch (Throwable t) {
            t.printStackTrace ();
            throw new BuildException (t);
        }
    }

    @Override
    public void run () {
        logger.fine("JPDAStart.run()"); // NOI18N
        debug ("Entering synch lock"); // NOI18N
        synchronized (lock) {
            debug("Entered synch lock"); // NOI18N
            try {
                ListeningConnector lc = null;
                final Set<ListeningConnector> connectors = new HashSet<ListeningConnector>();
                // search for connectors registered by NetBeans modules
                // In JavaFX listening connectors are registered as Connector.class.
                final Lookup.Result<Connector> r = Lookup.getDefault().lookupResult(Connector.class);
                for(Connector c: r.allInstances()) {
                    if (c instanceof ListeningConnector) connectors.add((ListeningConnector) c);
                }
                // use JDI default as well
                connectors.addAll(Bootstrap.virtualMachineManager().listeningConnectors());

                // if name of the connector has been specified, try to use it
                if (connector != null) {
                    logger.log(Level.FINE, "Looking for connector {0}", connector);
                    lc = findConnector(connector, connectors);
                }
                if (lc == null) {
                    // if dt_socket then use default socket as specified by JDI
                    if (transport.equals(SOCKET_TRANSPORT)) {
                        logger.log(Level.FINE, "Looking for default connector {0}", SOCKET_CONNECTOR);
                        lc = findConnector(SOCKET_CONNECTOR, connectors);
                    // if dt_shmem then use the default socket as specified by JDI
                    } else if (transport.equals(SHMEM_TRANSPORT)) {
                        logger.log(Level.FINE, "Looking for default connector {0}", SHMEM_CONNECTOR);
                        lc = findConnector(SHMEM_CONNECTOR, connectors);
                    }
                }
                // fallback to the original, i.e. find first connector whose transport
                // name matches given transport
                if (lc == null) {
                    logger.log(Level.FINE, "Fall back, looking for a connector with transport {0}", transport);
                    for (ListeningConnector c: connectors) {
                        Transport t = c.transport ();
                        if (t != null && t.name ().equals (transport)) {
                            lc = c;
                            break;
                        }
                    }
                }
                if (lc == null) {
                    throw new BuildException
                        ("No transports named " + transport + " found!");
                }
                logger.log(Level.FINE, "Listening using connector {0}, transport {1}", new Object[] {lc.name(), lc.transport().name()});

                final Map args = lc.defaultArguments ();
                Connector.StringArgument localAddress = (Connector.StringArgument) args.get("localAddress"); // NOI18N
                if (localAddress != null) {
                    String host = null;
                    if (!useLoopBackAddress) {
                        try {
                            host = InetAddress.getLocalHost().getCanonicalHostName();
                        } catch (UnknownHostException uhex) {}
                    }
                    if (host == null) {
                        host = "127.0.0.1"; // NOI18N
                    }
                    localAddress.setValue(host);
                }
                logger.log(Level.FINE, "Assigned host = ''{0}''", localAddress);
                String address = null;
                try {
                    address = lc.startListening (args);
                } catch (java.io.IOException ioex) {
                    boolean passed = false;
                    // workaround for issue 148490
                    if (SHMEM_TRANSPORT.equals(transport)) {
                        Connector.StringArgument argName = (Connector.StringArgument) args.get("name"); // NOI18N
                        for (int x = 0; x < 5; x++) {
                            String tryAddress = "javadebug" + Math.round(Math.random() * 10000); // NOI18N
                            try {
                                argName.setValue (tryAddress);
                                address = lc.startListening (args);
                                passed = true;
                                break;
                            } catch (Exception e) {
                                // ignore
                            }
                        } // for
                    }
                    if (!passed) {
                        getProject().log("Listening failed with arguments: "+args);
                        throw ioex;
                    }
                } catch (com.sun.jdi.connect.IllegalConnectorArgumentsException iaex) {
                    getProject().log("Listening failed with arguments: "+args);
                    throw iaex;
                }
                /* A fix to bug http://developer.java.sun.com/developer/bugParade/bugs/4932074.html has been integrated into JDK 1.5
                // Uncomment if the fix is not complete in all cases
                // This code parses the address string "HOST:PORT" to extract PORT and then point debugee to localhost:PORT
                // This is NOT a clean solution to the problem but it SHOULD work in 99% cases
                if (SOCKET_TRANSPORT.equals(transport)) {
                    int port = -1;
                    try {
                        port = Integer.parseInt (address.substring (address.indexOf (':') + 1));
                        Connector.IntegerArgument portArg = (Connector.IntegerArgument) args.get("port"); // NOI18N
                        portArg.setValue (port);
                        address = "localhost:" + port; // NOI18N
                    } catch (Exception e) {
                        // this address format is not known, use default
                    }
                }*/
                if (SOCKET_TRANSPORT.equals(transport)) {
                    try {
                        int port = Integer.parseInt (address.substring (address.indexOf (':') + 1));
                        Connector.IntegerArgument portArg = (Connector.IntegerArgument) args.get("port"); // NOI18N
                        portArg.setValue (port);
                        // Since some users have badly configured host addresses,
                        // perform a check for the address and use "localhost"
                        // if the address can not be resolved: (see http://www.netbeans.org/issues/show_bug.cgi?id=154974)
                        String host = address.substring(0, address.indexOf (':'));
                        logger.log(Level.FINE, "  socket listening at {0}, host = {1}, port = {2}",  // NOI18N
                                   new Object[]{address, host, port});
                        try {
                            InetAddress.getByName(host);
                        } catch (UnknownHostException uhex) {
                            logger.log(  Level.FINE, "unknown host ''{0}''", host);
                            address = "localhost:" + port; // NOI18N
                        } catch (SecurityException  se) {}
                    } catch (Exception e) {
                        // ignore
                    }
                }
                if (SHMEM_TRANSPORT.equals(transport)) {
                    try {
                        Connector.StringArgument name = (Connector.StringArgument) args.get("name"); // NOI18N
                        name.setValue (address);
                    } catch (Exception e) {
                        // ignore
                    }
                }
                getProject ().setNewProperty (getAddressProperty (), address);

                debug ("Creating source path"); // NOI18N
                ClassPath sourcePath = createSourcePath (
                    getProject (),
                    modulepath,
                    classpath,
                    plainSourcepath,
                    isSourcePathExclusive
                );
                ClassPath jdkSourcePath = createJDKSourcePath (
                    getProject (),
                    bootclasspath
                );
                if (logger.isLoggable(Level.FINE)) {
                    logger.fine("Create sourcepath:"); // NOI18N
                    logger.log(Level.FINE, "    modulepath : {0}", modulepath); // NOI18N
                    logger.log(Level.FINE, "    classpath : {0}", classpath); // NOI18N
                    logger.log(Level.FINE, "    sourcepath : {0}", plainSourcepath); // NOI18N
                    logger.log(Level.FINE, "    bootclasspath : {0}", bootclasspath); // NOI18N
                    logger.log(Level.FINE, "    >> sourcePath : {0}", sourcePath); // NOI18N
                    logger.log(Level.FINE, "    >> jdkSourcePath : {0}", jdkSourcePath); // NOI18N
                }

                Breakpoint first = null;

                if (stopClassName != null && stopClassName.length() > 0) {
                    logger.log(Level.FINE, "create method breakpoint, class name = {0}", stopClassName);    // NOI18N
                    first = createBreakpoint (stopClassName);
                }

                debug ("Debugger started"); // NOI18N
                logger.log(Level.FINE, "start listening at {0}", address); // NOI18N

                final Map properties = new HashMap ();
                // uncomment to implement smart stepping with step-outs
                // rather than step-ins (for J2ME)
                // props.put("SS_ACTION_STEPOUT", Boolean.TRUE);
                properties.put ("sourcepath", sourcePath); // NOI18N
                properties.put ("name", getName ()); // NOI18N
                properties.put ("jdksources", jdkSourcePath); // NOI18N
                properties.put ("listeningCP", listeningCP); // NOI18N
                String workDir = getProject().getProperty("work.dir");
                final File baseDir;
                if (workDir != null) {
                    baseDir = new File(workDir);
                } else {
                    baseDir = getProject().getBaseDir();
                }
                properties.put ("baseDir", baseDir); // NOI18N

                logger.log(Level.FINE, "JPDAStart: properties = {0}", properties);

                final ListeningConnector flc = lc;
                final WeakReference<Session> startedSessionRef[] = new WeakReference[] { new WeakReference<Session>(null) };

                Map<URL, ArtifactsUpdated> listeners = new HashMap<URL, ArtifactsUpdated>();
                List<Breakpoint> artificialBreakpoints = new LinkedList<Breakpoint>();
                if (listeningCP != null) {
                    ExceptionBreakpoint b = createCompilationErrorBreakpoint();
                    DebuggerManager.getDebuggerManager ().addBreakpoint (b);
                    artificialBreakpoints.add(b);
                }

                DebuggerManager.getDebuggerManager().addDebuggerListener(
                        DebuggerManager.PROP_DEBUGGER_ENGINES,
                        new Listener(first, artificialBreakpoints, listeners, startedSessionRef, rp));

                // Let it start asynchronously so that the script can go on and start the debuggee
                final Thread[] listeningThreadPtr = new Thread[] { null };
                final boolean[] listeningStarted = new boolean[] { false };
                rp.post(new Runnable() {
                    @Override
                    public void run() {
                        synchronized (listeningStarted) {
                            listeningThreadPtr[0] = Thread.currentThread();
                            listeningStarted[0] = true;
                            listeningStarted.notifyAll();
                        }
                        Object[] services = null;
                        try {
                            FileObject prjRoot = FileUtil.toFileObject(FileUtil.normalizeFile(baseDir));
                            if (prjRoot != null) {
                                org.netbeans.api.project.Project prj = ProjectManager.getDefault().findProject(prjRoot);
                                if (prj != null) {
                                    services = new Object[] { properties, prj };
                                }
                            }
                        } catch (IOException ioex) {}
                        if (services == null) {
                            services = new Object[] { properties };
                        }
                        try {
                            DebuggerEngine[] engines = JPDADebugger.startListeningAndGetEngines (
                                flc,
                                args,
                                services
                            );
                            startedSessionRef[0] = new WeakReference(engines[0].lookupFirst(null, Session.class));
                        } catch (DebuggerStartException dsex) {
                            // Was not able to start up
                        } finally {
                            synchronized (listeningStarted) {
                                listeningThreadPtr[0] = null;
                                listeningStarted.notifyAll();
                            }
                        }
                    }
                });

                logger.log(Level.FINE, "adding a BuildListener to project {0} in {1}", new Object[] {getProject().getName(), getProject().getBaseDir()});
                getProject().addBuildListener(new BuildListener() {

                    @Override public void messageLogged(BuildEvent event) {}
                    @Override public void taskStarted(BuildEvent event) { }
                    @Override public void taskFinished(BuildEvent event) {}
                    @Override public void targetStarted(BuildEvent event) {}
                    @Override public void targetFinished(BuildEvent event) {}
                    @Override public void buildStarted(BuildEvent event) {}
                    @Override public void buildFinished(BuildEvent event) {
                        // First wait until listening actually starts:
                        logger.fine("buildFinished: waiting for listening start...");
                        synchronized (listeningStarted) {
                            if (!listeningStarted[0]) {
                                try {
                                    listeningStarted.wait();
                                } catch (InterruptedException ex) {}
                            }
                        }
                        logger.fine("buildFinished: stopping listening...");
                        // Then stop it:
                        try {
                            flc.stopListening(args);
                        } catch (java.io.IOException ioex) {
                        } catch (com.sun.jdi.connect.IllegalConnectorArgumentsException iaex) {
                        }
                        logger.fine("buildFinished: interrupting listening thread...");
                        // If the listening is still running, interrupt it:
                        for (int i = 0; i < 10; i++) {
                            synchronized (listeningStarted) {
                                logger.log(Level.FINE, "buildFinished: listening thread = {0}", listeningThreadPtr[0]);
                                if (listeningThreadPtr[0] != null) {
                                    listeningThreadPtr[0].interrupt();
                                    try {
                                        listeningStarted.wait(500);
                                    } catch (InterruptedException ex) {}
                                } else {
                                    break;
                                }
                            }
                        }
                        // Finally, kill the started session:
                        Session s = startedSessionRef[0].get();
                        logger.log(Level.FINE, "buildFinished: killing session {0}", s);
                        if (s != null) {
                            s.kill();
                        }
                    }

                });
            } catch (java.io.IOException ioex) {
                lock[1] = ioex;
            } catch (com.sun.jdi.connect.IllegalConnectorArgumentsException icaex) {
                lock[1] = icaex;
            } catch (ThreadDeath td) {
                // Session was canceled - see issue #148483
                lock[1] = td;
            } finally {
                debug ("Notifying"); // NOI18N
                lock.notify ();
            }
        }
    } // run ()


    // support methods .........................................................

    private MethodBreakpoint createBreakpoint (String stopClassName) {
        MethodBreakpoint breakpoint = MethodBreakpoint.create (
            stopClassName,
            "*"
        );
        breakpoint.setHidden (true);
        DebuggerManager.getDebuggerManager ().addBreakpoint (breakpoint);
        return breakpoint;
    }

    private ExceptionBreakpoint createCompilationErrorBreakpoint() {
        ExceptionBreakpoint b = ExceptionBreakpoint.create("java.lang.RuntimeException", ExceptionBreakpoint.TYPE_EXCEPTION_UNCATCHED);
        b.setHidden (true);
        b.addJPDABreakpointListener(new JPDABreakpointListener() {
            @Override
            public void breakpointReached(JPDABreakpointEvent event) {
                boolean suspend = false;
                try {
                    if (event.getVariable() instanceof ObjectVariable) {
                        ObjectVariable ov = (ObjectVariable) event.getVariable();
                        JPDAClassType ct = ov.getClassType();
                        if (ct != null) {
                            suspend = "java.lang.RuntimeException".equals(ct.getName());
                            if (suspend) {
                                java.lang.reflect.Method invokeMethodMethod = ov.getClass().getMethod("invokeMethod", JPDAThread.class, String.class, String.class, Variable[].class);
                                invokeMethodMethod.setAccessible(true);
                                Variable message = (Variable) invokeMethodMethod.invoke(ov, event.getThread(), "getMessage", "()Ljava/lang/String;", new Variable[0]);
                                if (message != null) {
                                    suspend = message.getValue().startsWith("\"Uncompilable source code");
                                }
                                //suspend = suspend && ov.invokeMethod("getMessage", "()Ljava/lang/String;", new Variable[0]).getValue().startsWith("\"Uncompilable source code");
                            }
                        }
                    }
                } catch (IllegalAccessException iaex) {
                    logger.log(Level.FINE, null, iaex);
                } catch (java.lang.reflect.InvocationTargetException itex) {
                    logger.log(Level.FINE, null, itex);
                } catch (NoSuchMethodException ex) {
                    logger.log(Level.FINE, null, ex);
                //} catch (InvalidExpressionException ex) {
                //    logger.log(Level.FINE, null, ex);
                }

                if (!suspend) {
                    event.resume();
                }
            }
        });
        b.setPrintText(NbBundle.getBundle("org/netbeans/modules/debugger/jpda/ant/Bundle").getString("MSG_StoppedOnCompileError"));
        return b;
    }

    private static void debug (String msg) {
        if (!logger.isLoggable(Level.FINER)) return;
        logger.log(Level.FINER, "{0} [{1}] - {2}",
                   new Object[]{ new Date(), Thread.currentThread().getName(), msg });
    }

    static ClassPath createSourcePath (
        Project project,
        Path modulepath,
        Path classpath,
        Path sourcepath,
        boolean isSourcePathExclusive
    ) {
        if (sourcepath != null && isSourcePathExclusive) {
            return convertToClassPath (project, sourcepath);
        }
        ClassPath cp = convertToSourcePath (project, classpath, true);
        ClassPath modulesSources = convertToSourcePath(project, modules(project, modulepath), true);
        ClassPath sp = convertToClassPath (project, sourcepath);

        ClassPath sourcePath = ClassPathSupport.createProxyClassPath (
            new ClassPath[] {cp, modulesSources, sp}
        );
        return sourcePath;
    }

    private static Path modules(
            Project project,
            Path modulepath) {
        if (modulepath == null) {
            return null;
        }
        final Path modules = new Path(project);
        for (String pathElement : modulepath.list()) {
            final String pathName = project.replaceProperties(pathElement);
            if (pathName.lastIndexOf(URL_EMBEDDING) >=0) {
                modules.append(new Path(project, pathElement));
                continue;
            }
            final File file = FileUtil.normalizeFile(project.resolveFile (pathName));
            if (file.isDirectory() && !new File(file,MODULE_INFO_CLZ).exists()) {
                //Folder of modules add them
                for (File module : file.listFiles(new FileFilter() {
                    @Override
                    public boolean accept(File pathname) {
                        return pathname.isDirectory() ||
                            MODULE_FILES.contains(getExt(pathname));
                    }
                   })) {
                    modules.append(new Path(project, String.format("%s%s%s",   //NOI18N
                           pathElement,
                           File.separatorChar,
                           module.getName())));
               }
            } else {
                modules.append(new Path(project, pathElement));
            }

        }
        return modules;
    }

    private static String getExt(final File file) {
        final String name = file.getName();
        final int dot = name.indexOf('.');  //NOI18N
        return dot <= 0 ?
                "" :
                name.substring(dot+1).toLowerCase();
    }

    static ClassPath createJDKSourcePath (
        Project project,
        Path bootclasspath
    ) {
        if (bootclasspath == null) {
            // if current platform is default one, bootclasspath is set to null
            JavaPlatform jp = JavaPlatform.getDefault();
            if (jp != null) {
                return jp.getSourceFolders ();
            } else {
                return ClassPathSupport.createClassPath(java.util.Collections.EMPTY_LIST);
            }
        } else {
            return convertToSourcePath (project, bootclasspath, false);
        }
    }

    private static ClassPath convertToClassPath (Project project, Path path) {
        String[] paths = path == null ? new String [0] : path.list ();
        List l = new ArrayList ();
        int i, k = paths.length;
        for (i = 0; i < k; i++) {
            String pathName = project.replaceProperties(paths[i]);
            File f = FileUtil.normalizeFile (project.resolveFile (pathName));
            if (!isValid (f, project)) continue;
            URL url = fileToURL (f, project, true, false);
            if (url == null) continue;
            l.add (url);
        }
        URL[] urls = (URL[]) l.toArray (new URL [l.size ()]);
        return ClassPathSupport.createClassPath (urls);
    }

    /**
     * This method uses SourceForBinaryQuery to find sources for each
     * path item and returns them as ClassPath instance. All path items for which
     * the sources were not found are omitted.
     *
     */
    private static ClassPath convertToSourcePath (Project project, Path path, boolean reportNonExistingFiles) {
        String[] paths = path == null ? new String [0] : path.list ();
        List l = new ArrayList ();
        Set exist = new HashSet ();
        int i, k = paths.length;
        for (i = 0; i < k; i++) {
            String pathName = project.replaceProperties(paths[i]);
            final String pathInArchive;
            final int index = pathName.lastIndexOf(URL_EMBEDDING);
            if (index >= 0) {
                pathInArchive = pathName.substring(index+URL_EMBEDDING.length()).replace(File.separatorChar, '/');  //NOI18N
                pathName = pathName.substring(0, index);
            } else {
                pathInArchive = ""; //NOI18N
            }
            File file = FileUtil.normalizeFile
                (project.resolveFile (pathName));
            if (!isValid (file, project)) continue;
            URL url = fileToURL (file, project, reportNonExistingFiles, true);
            if (url == null) continue;
            if (!pathInArchive.isEmpty()) {
                url = appendPathInArchive(url, pathInArchive, project);
            }
            logger.log(Level.FINE, "convertToSourcePath - class: {0}", url); // NOI18N
            try {
                SourceForBinaryQuery.Result srcRootsResult = SourceForBinaryQuery.findSourceRoots(url);
                FileObject fos[] = srcRootsResult.getRoots();
                int j, jj = fos.length;
                logger.log(Level.FINE, "  source roots = {0}; jj = {1}", new Object[]{java.util.Arrays.asList(fos), jj});
                /* ?? (#60640)
                if (jj == 0) { // no sourcepath defined
                    // Take all registered source roots
                    Set allSourceRoots = GlobalPathRegistry.getDefault().getSourceRoots();
                    fos = (FileObject[]) allSourceRoots.toArray(new FileObject[0]);
                    jj = fos.length;
                }
                 */
                for (j = 0; j < jj; j++) {
                    FileObject fo = fos[j];
                    logger.log(Level.FINE, "convertToSourcePath - source : {0}", fo); // NOI18N
                    if (FileUtil.isArchiveFile (fo)) {
                        fo = FileUtil.getArchiveRoot (fo);
                        if (fo == null) { // can occur if we fail to find the actual archive
                            fo = fos[j];
                        }
                    }
                    url = fo.toURL ();
                    if (url == null) continue;
                    if (!exist.contains (url)) {
                        l.add (ClassPathSupport.createResource (url));
                        exist.add (url);
                    }
                } // for
            } catch (IllegalArgumentException ex) {
                Exceptions.printStackTrace(ex);
                logger.log(Level.FINE, "Have illegal url! {0}", ex.getLocalizedMessage()); // NOI18N
            }
        }
        return ClassPathSupport.createClassPath (l);
    }

    private static URL appendPathInArchive(URL rootURL, String pathInArchive, Project prj) {
        String embeddedURL = rootURL.toExternalForm() + pathInArchive;
        if (embeddedURL.charAt(embeddedURL.length()-1) != '/') {    //NOI18N
            embeddedURL = embeddedURL + '/';    //NOI18N
        }
        try {
            return new URL(embeddedURL);
        } catch (MalformedURLException e) {
            prj.log("Invalid embedded URL: \""+embeddedURL+"\".", Project.MSG_WARN);   //NOI18N
            return rootURL;
        }
    }


    private static URL fileToURL (File file, Project project, boolean reportNonExistingFiles, boolean withSlash) {
        FileObject fileObject = FileUtil.toFileObject (file);
        if (fileObject == null) {
            if (reportNonExistingFiles) {
                String path = file.getAbsolutePath();
                project.log("Have no file for "+path, Project.MSG_WARN);
            }
            return null;
        }
        if (FileUtil.isArchiveFile (fileObject)) {
            fileObject = FileUtil.getArchiveRoot (fileObject);
            if (fileObject == null) {
                project.log("Bad archive "+file.getAbsolutePath(), Project.MSG_WARN);
                /*
                ErrorManager.getDefault().notify(ErrorManager.getDefault().annotate(
                        new NullPointerException("Bad archive "+file.toString()),
                        NbBundle.getMessage(JPDAStart.class, "MSG_WrongArchive", file.getAbsolutePath())));
                 */
                return null;
            }
        }
        if (withSlash) {
            return FileUtil.urlForArchiveOrDir(file);
        } else {
            return fileObject.toURL ();
        }
    }

    private static boolean isValid (File f, Project project) {
        if (f.getPath ().indexOf ("${") != -1 && !f.exists ()) { // NOI18N
            project.log (
                "Classpath item " + f + " will be ignored.",  // NOI18N
                Project.MSG_VERBOSE
            );
            return false;
        }
        return true;
    }


    // innerclasses ............................................................

    public static class Sourcepath extends Path {

        private boolean isExclusive;
        private String path = null;
        private Path plainPath;

        public Sourcepath(Project p) {
            super(p);
            logger.log(Level.FINE, "new Sourcepath({0})", p);
        }

        public Sourcepath(Project p, String path) {
            super(p, path);
            this.path = path;
            logger.log(Level.FINE, "new Sourcepath({0}, {1})", new Object[]{p, path});
        }

        public void setExclusive(String exclusive) {
            isExclusive = "true".equalsIgnoreCase(exclusive);
        }

        boolean isExclusive() {
            return isExclusive;
        }

        public Path getPlainPath() {
            if (plainPath == null) {
                if (getRefid() != null) {
                    Path pp;
                    if (path != null) {
                        pp = new Path(getProject(), path);
                    } else {
                        pp = new Path(getProject());
                    }
                    pp.setLocation(getLocation());
                    pp.setDescription(getDescription());
                    pp.setRefid(getRefid());
                    //pp.setChecked(isChecked());
                    //pp.union = union == null ? union : (Union) union.clone();
                    plainPath = pp;
                } else {
                    plainPath = this;
                }
            }
            return plainPath;
        }

    }

    private static class Listener extends DebuggerManagerAdapter {

        private final PropertyChangeListener pcl = WeakListeners.propertyChange(this, null);

        private Set<DebuggerEngine> engines = new HashSet<DebuggerEngine>();

        private Breakpoint first;
        private final List<Breakpoint> artificalBreakpoints;
        private final Map<URL, ArtifactsUpdated> listeners;
        private final WeakReference<Session> startedSessionRef[];
        private boolean enginesCheckDone = false;
        private final RequestProcessor rp;

        private Listener(Breakpoint first,
                         List<Breakpoint> artificalBreakpoints,
                         Map<URL, ArtifactsUpdated> listeners,
                         WeakReference<Session> startedSessionRef[],
                         RequestProcessor rp) {
            this.first = first;
            this.artificalBreakpoints = artificalBreakpoints;
            this.listeners = listeners;
            this.startedSessionRef = startedSessionRef;
            this.rp = rp;
        }

        @Override
        public void propertyChange (final PropertyChangeEvent e) {
            if (JPDADebugger.PROP_STATE.equals(e.getPropertyName ())) {
                int state = ((Integer) e.getNewValue ()).intValue ();
                if (state == JPDADebugger.STATE_STOPPED || state == JPDADebugger.STATE_DISCONNECTED) {
                    rp.post(new Runnable() {
                        @Override
                        public void run() {
                            if (first != null) {
                                DebuggerManager.getDebuggerManager().removeBreakpoint(first);
                                first = null;
                                ((JPDADebugger) e.getSource()).removePropertyChangeListener(JPDADebugger.PROP_STATE, pcl);
                            }
                        }
                    });
                }
            }
        }

        private void dispose() {
            DebuggerManager.getDebuggerManager ().removeDebuggerListener (
                DebuggerManager.PROP_DEBUGGER_ENGINES,
                this
            );
            rp.post (new Runnable () {
                @Override
                public void run () {
                    if (artificalBreakpoints != null) {
                        for (Breakpoint b : artificalBreakpoints) {
                            DebuggerManager.getDebuggerManager().removeBreakpoint(b);
                        }
                    }
                    if (first != null) {
                        DebuggerManager.getDebuggerManager().removeBreakpoint(first);
                    }
                    if (listeners != null) {
                        for (Entry<URL, ArtifactsUpdated> e : listeners.entrySet()) {
                            BuildArtifactMapper.removeArtifactsUpdatedListener(e.getKey(), e.getValue());
                        }
                    }
                }
            });
        }

        @Override
        public void engineAdded (DebuggerEngine engine) {
            // Consider only engines from the started session.
            Session session;
            synchronized (startedSessionRef) {
                session = startedSessionRef[0].get();
            }
            if (session != null) {
                // perform check
                boolean hasEngine = false;
                for (String l : session.getSupportedLanguages()) {
                    if (engine.equals(session.getEngineForLanguage(l))) {
                        hasEngine = true;
                        break;
                    }
                }
                if (!hasEngine) {
                    return;
                }
            }
            JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
            if (debugger == null) return;
            debugger.addPropertyChangeListener (
                JPDADebugger.PROP_STATE,
                pcl
            );
            engines.add(engine);
        }

        @Override
        public void engineRemoved (DebuggerEngine engine) {
            Session session;
            synchronized (startedSessionRef) {
                session = startedSessionRef[0].get();
            }
            if (session != null && !enginesCheckDone) {
                // check each registered engine if it belong to the session
                enginesCheckDone = true;
                List<DebuggerEngine> list = new ArrayList<DebuggerEngine>(engines);
                for (DebuggerEngine eng : list) {
                    boolean hasEngine = false;
                    for (String l : session.getSupportedLanguages()) {
                        if (engine.equals(session.getEngineForLanguage(l))) {
                            hasEngine = true;
                            break;
                        }
                    }
                    if (!hasEngine) {
                        engines.remove(eng);
                    }
                }
            }
            JPDADebugger debugger = engine.lookupFirst(null, JPDADebugger.class);
            if (debugger == null) return;
            if (engines.remove(engine)) {
                debugger.removePropertyChangeListener (
                    JPDADebugger.PROP_STATE,
                    pcl
                );
            }
            if (engines.isEmpty()) {
                dispose();
            }
        }
    }

}