/*
 * 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.maven.jaxws;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.URI;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.Preferences;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.modules.j2ee.common.dd.DDHelper;
import org.netbeans.modules.j2ee.dd.api.common.NameAlreadyUsedException;
import org.netbeans.modules.j2ee.dd.api.web.DDProvider;
import org.netbeans.modules.j2ee.dd.api.web.Listener;
import org.netbeans.modules.j2ee.dd.api.web.Servlet;
import org.netbeans.modules.j2ee.dd.api.web.ServletMapping;
import org.netbeans.modules.j2ee.dd.api.web.ServletMapping25;
import org.netbeans.modules.j2ee.dd.api.web.WebApp;
import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule;
import org.netbeans.modules.j2ee.deployment.devmodules.spi.J2eeModuleProvider;
import org.netbeans.modules.javaee.specs.support.api.JaxWs;
import org.netbeans.modules.maven.api.NbMavenProject;
import org.netbeans.modules.web.api.webmodule.WebModule;
import org.netbeans.modules.websvc.api.jaxws.project.config.Endpoint;
import org.netbeans.modules.websvc.api.jaxws.project.config.Endpoints;
import org.netbeans.modules.websvc.api.jaxws.project.config.EndpointsProvider;
import org.netbeans.modules.websvc.api.jaxws.wsdlmodel.WsdlModel;
import org.netbeans.modules.websvc.jaxws.light.api.JAXWSLightSupport;
import org.netbeans.modules.websvc.jaxws.light.api.JaxWsService;
import org.netbeans.modules.websvc.wsstack.api.WSStack;
import org.netbeans.modules.xml.retriever.RetrieveEntry;
import org.netbeans.modules.xml.retriever.Retriever;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;
import org.openide.ErrorManager;
import org.openide.NotifyDescriptor;
import org.openide.cookies.SaveCookie;
import org.openide.filesystems.FileLock;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileSystem.AtomicAction;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.util.NbBundle;

/**
 *
 * @author mkuchtiak
 */
public class WSUtils {

    private static final String GENERATE_NON_JSR109 = "generate_nonjsr109"; //NOI18N
    private final static String SERVLET_CLASS_NAME =
            "com.sun.xml.ws.transport.http.servlet.WSServlet"; //NOI18N
    private final static String SERVLET_LISTENER =
            "com.sun.xml.ws.transport.http.servlet.WSServletContextListener"; //NOI18N
    /** downloads XML resources from source URI to target folder
     * (USAGE : this method can download a wsdl file and all wsdl/XML schemas,
     * that are recursively imported by this wsdl)
     * @param targetFolder A folder inside a NB project (ONLY) to which the retrieved resource will be copied to. All retrieved imported/included resources will be copied relative to this directory.
     * @param source URI of the XML resource that will be retrieved into the project
     * @return FileObject of the retrieved resource in the local file system
     */
    public static FileObject retrieveResource(FileObject targetFolder, URI catalog, URI source)
            throws java.net.UnknownHostException, java.net.URISyntaxException, IOException{
        try {
            Retriever retriever = Retriever.getDefault();
            FileObject result = retriever.retrieveResource(targetFolder, catalog, source);
            if (result==null) {
                Map<RetrieveEntry,Exception> map = 
                        retriever.getRetrievedResourceExceptionMap();
                if (map!=null) {
                    for(Entry<RetrieveEntry,Exception> entry : map.entrySet()){
                        RetrieveEntry key = entry.getKey();
                        Exception exc = entry.getValue(); 
                        if (exc instanceof IOException) {
                            throw (IOException)exc;
                        } else if (exc instanceof java.net.URISyntaxException) {
                            throw (java.net.URISyntaxException)exc;
                        } else  {
                            IOException ex = new IOException(NbBundle.getMessage(
                                    WSUtils.class,"ERR_retrieveResource",       // NOI18N
                                    key.getCurrentAddress()));
                            ex.initCause(exc);
                            throw ex;
                        }
                    }
                }
            }
            return result;
        } catch (RuntimeException ex) {
            throw (IOException)(new IOException(ex.getLocalizedMessage()).initCause(ex));
        }
    }
    
    public static void generateSunJaxwsFile(final FileObject targetDir) throws IOException {
        final String sunJaxwsContent =
                readResource(WsdlModel.class.getResourceAsStream("/org/netbeans/modules/websvc/jaxwsmodel/resources/sun-jaxws.xml")); //NOI18N
        FileSystem fs = targetDir.getFileSystem();
        fs.runAtomicAction(new FileSystem.AtomicAction() {
            @Override
            public void run() throws IOException {
                FileObject sunJaxwsFo = FileUtil.createData(targetDir, "sun-jaxws.xml");//NOI18N
                FileLock lock = sunJaxwsFo.lock();
                BufferedWriter bw = null;
                OutputStream os = null;
                OutputStreamWriter osw = null;
                try {
                    os = sunJaxwsFo.getOutputStream(lock);
                    osw = new OutputStreamWriter(os, Charset.forName("UTF-8"));     // NOI18N
                    bw = new BufferedWriter(osw);
                    bw.write(sunJaxwsContent);
                } finally {
                    if(bw != null)
                        bw.close();
                    if(os != null)
                        os.close();
                    if(osw != null)
                        osw.close();
                    if(lock != null)
                        lock.releaseLock();
                }
            }
        });
    }
    
    static final J2eeModuleProvider getModuleProvider(Project project){
        return project.getLookup().lookup(J2eeModuleProvider.class);
    }
    
    private static String readResource(InputStream is) throws IOException {
        // read the config from resource first
        StringBuffer sb = new StringBuffer();
        String lineSep = System.getProperty("line.separator");//NOI18N
        BufferedReader br = new BufferedReader(new InputStreamReader(is, 
                Charset.forName("UTF-8")));
        String line = br.readLine();
        while (line != null) {
            sb.append(line);
            sb.append(lineSep);
            line = br.readLine();
        }
        br.close();
        return sb.toString();
    }
    
    public static void removeImplClass(Project project, String implClass) {
        Sources sources = project.getLookup().lookup(Sources.class);
        String resource = implClass.replace('.','/')+".java"; //NOI18N
        if (sources!=null) {
            SourceGroup[] srcGroup = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
            for (int i=0;i<srcGroup.length;i++) {
                final FileObject srcRoot = srcGroup[i].getRootFolder();
                final FileObject implClassFo = srcRoot.getFileObject(resource);
                if (implClassFo!=null) {
                    try {
                        FileSystem fs = implClassFo.getFileSystem();
                        fs.runAtomicAction(new AtomicAction() {
                            @Override
                            public void run() {
                                deleteFile(implClassFo);
                            }
                        });
                    } catch (IOException ex) {
                        ErrorManager.getDefault().notify(ex);
                    }
                    return;
                }
            }
        }
    }
    
    private static void deleteFile(FileObject f) {
        FileLock lock = null;
        try {
            DataObject dObj = DataObject.find(f);
            if (dObj != null) {
                SaveCookie save = dObj.getCookie(SaveCookie.class);
                if (save!=null) save.save();
            }
            lock = f.lock();
            f.delete(lock);
        } catch(java.io.IOException e) {
            NotifyDescriptor ndd =
                    new NotifyDescriptor.Message(NbBundle.getMessage(WSUtils.class, "MSG_Unable_Delete_File", f.getNameExt()),
                    NotifyDescriptor.ERROR_MESSAGE);
            DialogDisplayer.getDefault().notify(ndd);
        } finally {
            if(lock != null) {
                lock.releaseLock();
            }
        }
    }
    
    /** Copy files from source folder to target folder recursively */
    public static void copyFiles(FileObject sourceFolder, FileObject targetFolder) throws IOException {
        FileObject[] children = sourceFolder.getChildren();
        for (int i=0;i<children.length;i++) {
            if (children[i].isFolder()) {
                FileObject folder = targetFolder.createFolder(children[i].getNameExt());
                copyFiles(children[i],folder);
            } else {
                children[i].copy(targetFolder, children[i].getName(), children[i].getExt());
            }
        }
    }
    
    public static FileObject findJaxWsFileObject(Project project) {
        return project.getProjectDirectory().getFileObject("nbproject/jax-ws.xml");
    }
    
    private static final String DEFAULT_PACKAGE_NAME="org.netbeans.ws"; //NOI18N
    
    private static String getPackageNameFromNamespace(String ns) {
        String base = ns;
        int doubleSlashIndex = ns.indexOf("//"); //NOI18N
        if (doubleSlashIndex >=0) {
            base = ns.substring(doubleSlashIndex+2);
        } else {
            int colonIndex = ns.indexOf(":");
            if (colonIndex >=0) base = ns.substring(colonIndex+1);
        }
        StringTokenizer tokens = new StringTokenizer(base,"/"); //NOI18N
        if (tokens.countTokens() > 0) {
            List<String> packageParts = new ArrayList<String>();
            List<String> nsParts = new ArrayList<String>();
            while (tokens.hasMoreTokens()) {
                String part = tokens.nextToken();
                if (part.length() >= 0) {
                    nsParts.add(part);
                }
            }
            if (nsParts.size() > 0) {
                StringTokenizer tokens1 = new StringTokenizer(nsParts.get(0),"."); //NOI18N
                int countTokens = tokens1.countTokens();
                if (countTokens > 0) {
                    List<String> list = new ArrayList<String>();
                    while(tokens1.hasMoreTokens()) {
                        list.add(tokens1.nextToken());
                    }
                    for (int i=countTokens-1; i>=0; i--) {
                        String part = list.get(i);
                        if (i > 0 || !"www".equals(part)) { //NOI18N
                            packageParts.add(list.get(i).toLowerCase());
                        }
                    }
                } else {
                    return DEFAULT_PACKAGE_NAME;
                }
                for (int i=1; i<nsParts.size(); i++) {
                    packageParts.add(nsParts.get(i).toLowerCase());
                }
                StringBuffer buf = new StringBuffer(packageParts.get(0));
                for (int i=1;i<packageParts.size();i++) {
                    buf.append("."+packageParts.get(i));
                }
                return buf.toString();
            }
        }
        return DEFAULT_PACKAGE_NAME;
        
    }

    public static boolean isProjectReferenceable(Project sourceProject, Project targetProject) {
        if (sourceProject == targetProject) {
            return true;
        } else {
            NbMavenProject mavenProject = sourceProject.getLookup().lookup(NbMavenProject.class);
            if (mavenProject != null && NbMavenProject.TYPE_JAR.equals(mavenProject.getPackagingType())) {
                return true;
            }
            return false;
        }
    }


    public static boolean isEJB(Project project) {
        J2eeModuleProvider j2eeModuleProvider = project.getLookup().lookup(J2eeModuleProvider.class);
        if (j2eeModuleProvider != null) {
            J2eeModule.Type moduleType = j2eeModuleProvider.getJ2eeModule().getType();
            if (J2eeModule.Type.EJB.equals(moduleType)) {
                return true;
            }
        }
        return false;
    }

    public static boolean isWeb(Project project) {
        J2eeModuleProvider j2eeModuleProvider = project.getLookup().lookup(J2eeModuleProvider.class);
        if (j2eeModuleProvider != null) {
            J2eeModule.Type moduleType = j2eeModuleProvider.getJ2eeModule().getType();
            if (J2eeModule.Type.WAR.equals(moduleType)) {
                return true;
            }
        }
        return false;
    }
    
    public static void updateClients(final Project prj, final JAXWSLightSupport jaxWsSupport) {
        Runnable runnable = new Runnable() {
            
            @Override
            public void run() {
                doUpdateClients(prj, jaxWsSupport);
            }
        };
        jaxWsSupport.runAtomic(runnable);
    }

    public static void detectWsdlClients(final Project prj, final JAXWSLightSupport jaxWsSupport)  {
        final List<WsimportPomInfo> candidates = MavenModelUtils.getWsdlFiles(prj);
        if (candidates.size() > 0) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    for (WsimportPomInfo candidate : candidates) {             
                        if (isClient(prj, candidate)) {
                            String wsdlPath = candidate.getWsdlPath();
                            JaxWsService client = new JaxWsService(wsdlPath, false);
                            if (candidate.getHandlerFile() != null) {
                                client.setHandlerBindingFile(candidate.getHandlerFile());
                            }
                            client.setId(candidate.getId());
                            client.setWsdlUrl(getOriginalWsdlUrl(prj, client.getId(), false));
                            jaxWsSupport.addService(client);
                        }
                    }                    
                }
            };
            jaxWsSupport.runAtomic(runnable);
        } else {
            // look for wsdl in wsdl folder
        }
    }
    
    private static void doUpdateClients(Project prj, JAXWSLightSupport jaxWsSupport) {
        // get old clients
        List<JaxWsService> oldClients = new ArrayList<JaxWsService>();
        Set<String> oldNames = new HashSet<String>();
        for (JaxWsService s : jaxWsSupport.getServices()) {
            if (!s.isServiceProvider()) {
                oldClients.add(s);
                oldNames.add(s.getId());
            }
        }
        FileObject wsdlFolder = jaxWsSupport.getWsdlFolder(false);
        if (wsdlFolder != null) {
            List<JaxWsService> newClients = getJaxWsClients(prj);
            Set<String> commonNames = new HashSet<String>();
            for (JaxWsService client : newClients) {
                String id = client.getId();
                if (oldNames.contains(id)) {
                    commonNames.add(id);
                }
            }
            // removing old clients
            for (JaxWsService oldClient : oldClients) {
                if (!commonNames.contains(oldClient.getId())) {
                    jaxWsSupport.removeService(oldClient);
                }
            }
            // add new clients
            for (JaxWsService newClient : newClients) {
                if (!commonNames.contains(newClient.getId())) {
                    newClient.setWsdlUrl(getOriginalWsdlUrl(prj, newClient.getId(), false));
                    jaxWsSupport.addService(newClient);
                }
            }
        } else {
            // removing ald clients
            for (JaxWsService client : oldClients) {
                jaxWsSupport.removeService(client);
            }
        }
        
    }

    private static List<JaxWsService> getJaxWsClients(Project prj) {
        List<WsimportPomInfo> candidates = MavenModelUtils.getWsdlFiles(prj);
        List<JaxWsService> clients = new ArrayList<JaxWsService>();
        for (WsimportPomInfo candidate : candidates) {           
            if (isClient(prj, candidate)) {
                String wsdlPath = candidate.getWsdlPath();
                JaxWsService client = new JaxWsService(wsdlPath, false);
                client.setId(candidate.getId());
                if (candidate.getHandlerFile() != null) {
                    client.setHandlerBindingFile(candidate.getHandlerFile());
                }
                clients.add(client);
            }
        }
        return clients;
    }

    private static boolean isClient(Project prj, WsimportPomInfo candidate) {
        Preferences prefs = ProjectUtils.getPreferences(prj, MavenWebService.class,true);
        if (prefs != null) {
            // if client exists return true
            if (prefs.get(MavenWebService.SERVICE_PREFIX+candidate.getId(), null) != null) {
                return false;
            }
        }
        return true;
    }

    static FileObject getLocalWsdl(JAXWSLightSupport jaxWsSupport, String localWsdlPath) {
        FileObject wsdlFolder = jaxWsSupport.getWsdlFolder(false);
        if (wsdlFolder!=null) {
            return wsdlFolder.getFileObject(localWsdlPath);
        }
        return null;
    }

    public static String getOriginalWsdlUrl(Project prj, String id, boolean forService) {
        Preferences prefs = ProjectUtils.getPreferences(prj, MavenWebService.class, true);
        if (prefs != null) {
            // remember original WSDL URL for service
            if (forService) {
                return prefs.get(MavenWebService.SERVICE_PREFIX+id, null);
            } else {
                return prefs.get(MavenWebService.CLIENT_PREFIX+id, null);
            }
        }
        return null;
    }
    private static boolean webAppHasListener(WebApp webApp, String listenerClass){
        Listener[] listeners = webApp.getListener();
        for(int i = 0; i < listeners.length; i++){
            Listener listener = listeners[i];
            if(listenerClass.equals(listener.getListenerClass())){
                return true;
            }
        }
        return false;
    }

    // useful methods to work with Deployment Descriptor 
    
    private static WebApp getWebApp(Project prj) {
        try {
            FileObject deploymentDescriptor = getDeploymentDescriptor(prj);
            if(deploymentDescriptor != null) {
                return DDProvider.getDefault().getDDRoot(deploymentDescriptor);
            }
        } catch (java.io.IOException e) {
            Logger.getLogger("global").log(Level.INFO, e.getLocalizedMessage());
        }
        return null;
    }

    private static FileObject getDeploymentDescriptor(Project prj) {
        J2eeModuleProvider provider = prj.getLookup().lookup(J2eeModuleProvider.class);
        if (provider != null) {
            File dd = provider.getJ2eeModule().getDeploymentConfigurationFile(
                    "WEB-INF/web.xml");                                // NOI18N
            if (dd != null && dd.exists()) {
                return FileUtil.toFileObject(dd);
            }
            else {
                WebModule wm = WebModule.getWebModule(prj.getProjectDirectory());
                if ( wm ==null ){
                    return null;
                }
                FileObject webInf = wm.getWebInf();
                try {
                    if (webInf == null) {
                        FileObject docBase = wm.getDocumentBase();
                        if (docBase != null) {
                            webInf = docBase.createFolder("WEB-INF"); // NOI18N
                        }
                    }
                    if (webInf == null) {
                        return null;
                    }
                    return DDHelper.createWebXml(wm.getJ2eeProfile(), webInf);
                }
                catch (IOException e) {
                    Logger.getLogger(WSUtils.class.getName()).log(Level.INFO, null, e );
                    return null;
                }
            }
        }
        return null;
    }

    // methods that handle sun-jaxws.xml file

    public static Endpoint addSunJaxWsEntry(FileObject ddFolder, JaxWsService service)
            throws IOException {
        FileObject sunjaxwsFile = ddFolder.getFileObject("sun-jaxws.xml"); //NOI18N
        if(sunjaxwsFile == null){
            generateSunJaxwsFile(ddFolder);
        }
        sunjaxwsFile = ddFolder.getFileObject("sun-jaxws.xml"); //NOI18N
        Endpoints endpoints = EndpointsProvider.getDefault().getEndpoints(sunjaxwsFile);
        Endpoint oldEndpoint =
                endpoints.findEndpointByImplementation(service.getImplementationClass());
        if (oldEndpoint == null) {
            Endpoint newEndpoint = addService(endpoints, service);
            FileLock lock = null;
            OutputStream os = null;
            synchronized (sunjaxwsFile) {
                try {
                    lock = sunjaxwsFile.lock();
                    os = sunjaxwsFile.getOutputStream(lock);
                    endpoints.write(os);
                } finally{
                    if (lock != null)
                        lock.releaseLock();

                    if(os != null)
                        os.close();
                }
            }
            return newEndpoint;
        } else {
            return oldEndpoint;
        }
    }

    private static void addJaxWsEntries(FileObject ddFolder, JAXWSLightSupport jaxWsSupport)
            throws IOException {

        generateSunJaxwsFile(ddFolder);
        FileObject sunjaxwsFile = ddFolder.getFileObject("sun-jaxws.xml"); //NOI18N
        Endpoints endpoints = EndpointsProvider.getDefault().getEndpoints(sunjaxwsFile);
        for (JaxWsService service: jaxWsSupport.getServices()) {
            if (service.isServiceProvider()) {
                addService(endpoints, service);
            }
        }
        FileLock lock = null;
        OutputStream os = null;
        synchronized (sunjaxwsFile) {
            try {
                lock = sunjaxwsFile.lock();
                os = sunjaxwsFile.getOutputStream(lock);
                endpoints.write(os);
            } finally{
                if (lock != null)
                    lock.releaseLock();

                if(os != null)
                    os.close();
            }
        }
    }

    private static Endpoint addService(Endpoints endpoints, JaxWsService service) {
        Endpoint endpoint = endpoints.newEndpoint();
        endpoint.setEndpointName(service.getServiceName());
        endpoint.setImplementation(service.getImplementationClass());
        endpoint.setUrlPattern("/" + service.getServiceName());
        endpoints.addEnpoint(endpoint);
        return endpoint;
    }

    public static void removeSunJaxWsEntry(FileObject ddFolder, JaxWsService service)
            throws IOException {
        FileObject sunjaxwsFile = ddFolder.getFileObject("sun-jaxws.xml"); //NOI18N
        if (sunjaxwsFile != null) {
            Endpoints endpoints = EndpointsProvider.getDefault().getEndpoints(sunjaxwsFile);
            Endpoint endpoint = endpoints.findEndpointByName(service.getServiceName());
            if (endpoint != null) {
                endpoints.removeEndpoint(endpoint);
                FileLock lock = null;
                OutputStream os = null;
                synchronized (sunjaxwsFile) {
                    try {
                        lock = sunjaxwsFile.lock();
                        os = sunjaxwsFile.getOutputStream(lock);
                        endpoints.write(os);
                    } finally {
                        if (lock != null) {
                            lock.releaseLock();
                        }
                        if (os != null) {
                            os.close();
                        }
                    }
                }
            }
        }
    }

    private static void removeSunJaxWs(FileObject ddFolder)
            throws IOException {
        FileObject sunjaxwsFile = ddFolder.getFileObject("sun-jaxws.xml"); //NOI18N
        if (sunjaxwsFile != null) {
            sunjaxwsFile.delete();
        }
    }

    public static void replaceSunJaxWsEntries(FileObject ddFolder, String oldServiceName, String newServiceName)
            throws IOException {

        FileObject sunjaxwsFile = ddFolder.getFileObject("sun-jaxws.xml"); //NOI18N
        if (sunjaxwsFile != null) {
            Endpoints endpoints = EndpointsProvider.getDefault().getEndpoints(sunjaxwsFile);
            Endpoint endpoint = endpoints.findEndpointByName(oldServiceName);
            if (endpoint != null) {
                endpoint.setEndpointName(newServiceName);
                endpoint.setUrlPattern("/" + newServiceName);
                FileLock lock = null;
                OutputStream os = null;
                synchronized (sunjaxwsFile) {
                    try {
                        lock = sunjaxwsFile.lock();
                        os = sunjaxwsFile.getOutputStream(lock);
                        endpoints.write(os);
                    } finally {
                        if (lock != null) {
                            lock.releaseLock();
                        }
                        if (os != null) {
                            os.close();
                        }
                    }
                }
            }
        }
    }
    
    public static boolean needNonJsr109Artifacts(Project prj){
        FileObject ddFolder = getDeploymentDescriptorFolder(prj);
        return WSUtils.generateNonJsr109Artifacts(prj);
    }

    private static boolean generateNonJsr109Artifacts(Project prj) {
        Preferences prefs = ProjectUtils.getPreferences(prj, WSUtils.class, true);
        if (prefs == null) {
            return false;
        }
        if (prefs.get(GENERATE_NON_JSR109 , null) == null) {
            ConfirmationPanel panel =
                new ConfirmationPanel(NbBundle.getMessage(WSUtils.class,"MSG_GenerateDDEntries", prj.getProjectDirectory().getName()));
            DialogDescriptor dd = new DialogDescriptor(
                    panel,
                    NbBundle.getMessage(WSUtils.class,"TTL_GenerateDDEntries"),
                    true,
                    DialogDescriptor.YES_NO_OPTION,
                    null,null);
            Object result = DialogDisplayer.getDefault().notify(dd);
            if (panel.notAskAgain()) {
                if (prefs != null) {
                    prefs.put(GENERATE_NON_JSR109, (NotifyDescriptor.YES_OPTION.equals(result) ? "true" : "false")); //NOI18N
                }
            }
            return NotifyDescriptor.YES_OPTION.equals(result);
        } else {
            return "true".equals(prefs.get(GENERATE_NON_JSR109, null));
        }
    }

    private static boolean removeNonJsr109Artifacts(Project prj) {
        Preferences prefs = ProjectUtils.getPreferences(prj, WSUtils.class, true);
        if (prefs == null) {
            return false;
        }
        if (prefs.get(GENERATE_NON_JSR109 , null) == null) {
            ConfirmationPanel panel =
                new ConfirmationPanel(NbBundle.getMessage(WSUtils.class,"MSG_RemoveDDEntries"));
            DialogDescriptor dd = new DialogDescriptor(
                    panel,
                    NbBundle.getMessage(WSUtils.class,"TTL_RemoveDDEntries"),
                    true,
                    DialogDescriptor.YES_NO_OPTION,
                    null,null);
            Object result = DialogDisplayer.getDefault().notify(dd);
            if (panel.notAskAgain()) {
                if (prefs != null) {
                    prefs.put(GENERATE_NON_JSR109 , (NotifyDescriptor.YES_OPTION.equals(result) ? "true" : "false")); //NOI18N
                }
            }
            return NotifyDescriptor.YES_OPTION.equals(result);
        } else {
            return "true".equals(prefs.get(GENERATE_NON_JSR109, null));
        }
    }
    
    public static FileObject getDeploymentDescriptorFolder(Project project) {
        JAXWSLightSupport jaxWsSupport = JAXWSLightSupport.
                getJAXWSLightSupport(project.getProjectDirectory());
        return jaxWsSupport.getDeploymentDescriptorFolder();
    }

    public static boolean isJsr109Supported(Project project) {
        J2eeModuleProvider j2eeModuleProvider = project.getLookup().lookup(J2eeModuleProvider.class);
        if (j2eeModuleProvider == null) {
            // set to true by default
            return true;
        } else {
            WSStackUtils stackUtils = new WSStackUtils(project);
            return stackUtils.isJsr109Supported();
        }
    }

    /** Add service entries to deployment descriptor.
     *
     * @param prj
     * @param service
     * @throws java.io.IOException
     */
    public static void addServiceToDD(Project prj, JaxWsService service, Endpoint endpoint)
        throws IOException {
        //add servlet entry to web.xml
        WebApp webApp = getWebApp(prj);
        if (webApp != null) {
            try{
                addServlet(webApp, service, endpoint);
                if (!webAppHasListener(webApp, SERVLET_LISTENER)){
                    webApp.addBean("Listener", new String[]{"ListenerClass"}, //NOI18N
                            new Object[]{SERVLET_LISTENER}, "ListenerClass"); //NOI18N
                }
                // This also saves server specific configuration, if necessary.
                webApp.write(getDeploymentDescriptor(prj));
            } catch (ClassNotFoundException exc) {
                Logger.getLogger("global").log(Level.INFO, exc.getLocalizedMessage()); //NOI18N
            } catch (NameAlreadyUsedException exc) {
                Logger.getLogger(WSUtils.class.getName()).log(Level.INFO, exc.getLocalizedMessage()); //NOI18N
            }
        }
    }

    private static void addServicesToDD(Project prj, JAXWSLightSupport jaxWsSupport)
        throws IOException {
        WebApp webApp = getWebApp(prj);
        if (webApp != null) {
            try {
                if (!webAppHasListener(webApp, SERVLET_LISTENER)) {
                    webApp.addBean("Listener", new String[]{"ListenerClass"}, //NOI18N
                            new Object[]{SERVLET_LISTENER}, "ListenerClass"); //NOI18N
                }
                for (JaxWsService service : jaxWsSupport.getServices()) {
                    if (service.isServiceProvider()) {
                        addServlet(webApp, service);
                    }
                }
            } catch (NameAlreadyUsedException exc) {
                Logger.getLogger(WSUtils.class.getName()).log(Level.INFO, exc.getLocalizedMessage()); //NOI18N
            } catch (ClassNotFoundException exc) {
                Logger.getLogger(WSUtils.class.getName()).log(Level.INFO, exc.getLocalizedMessage()); //NOI18N
            }
            webApp.write(getDeploymentDescriptor(prj));
        }
    }

    private static void addServlet(WebApp webApp, JaxWsService service) throws ClassNotFoundException, NameAlreadyUsedException {
        String servletName = service.getServiceName();
        Servlet servlet = (Servlet)webApp.addBean("Servlet", new String[]{"ServletName","ServletClass"}, //NOI18N
                new Object[]{servletName, SERVLET_CLASS_NAME}, "ServletName"); //NOI18N
        servlet.setLoadOnStartup(new java.math.BigInteger("1")); //NOI18N
        webApp.addBean("ServletMapping", new String[] {"ServletName", "UrlPattern"}, //NOI18N
                new Object[]{servletName, "/" + servletName}, "ServletName"); //NOI18N
    }

    private static void addServlet(WebApp webApp, JaxWsService service, Endpoint endpoint) throws ClassNotFoundException, NameAlreadyUsedException {
        String endpointName = endpoint.getEndpointName();
        if (endpointName == null) {
            return;
        }
        // compare existing servlet mappings with endpoint mapping, whether they match
        if (servletMappingExistsFor(webApp, endpoint)) {
            return;
        }
        
        Servlet servlet = (Servlet)webApp.addBean("Servlet", new String[]{"ServletName","ServletClass"}, //NOI18N
                new Object[]{endpointName, SERVLET_CLASS_NAME}, "ServletName"); //NOI18N
        if (servlet != null) {
            servlet.setLoadOnStartup(new java.math.BigInteger("1")); //NOI18N
        }
        webApp.addBean("ServletMapping", new String[] {"ServletName", "UrlPattern"}, //NOI18N
                new Object[]{endpointName, "/" + endpointName}, "ServletName"); //NOI18N
    }
    
    private static boolean servletMappingExistsFor(WebApp webApp, Endpoint endpoint) {
        for (Servlet servlet : webApp.getServlet()) {
            String servletName = servlet.getServletName();
            if (endpoint.getEndpointName().equals(servletName)) {
                return true;
            }
            if (SERVLET_CLASS_NAME.equals(servlet.getServletClass())) {
                for (ServletMapping servletMapping : webApp.getServletMapping()) {
                    if (servletName != null && servletName.equals(servletMapping.getServletName())) {
                        String endpoindPattern = cutEndingWildcard(endpoint.getUrlPattern());
                        String servletMappingPattern = cutEndingWildcard(((ServletMapping25)servletMapping).getUrlPatterns()[0]);
                        if (endpoindPattern.startsWith(servletMappingPattern)) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
    
    private static String cutEndingWildcard(String urlPattern) {
        if (urlPattern == null) {
            return "";
        }
        if (urlPattern.endsWith("/*")) {
            return urlPattern.substring(0,urlPattern.length()-2);
        }
        return urlPattern;
    }
    
    /**
     * Remove the service entries from deployment descriptor.
     *
     * @param serviceName Name of the web service to be removed
     */
    public static void removeServiceFromDD(Project prj, JaxWsService service)
        throws IOException {
        WebApp webApp = getWebApp(prj);
        if (webApp != null) {
            boolean changed = removeServiceFromDD(webApp, service.getServiceName());

            //determine if there are other web services in the project
            //if none, remove the listener
            boolean hasMoreWebServices = false;
            Servlet[] remainingServlets = webApp.getServlet();
            for(int i = 0; i < remainingServlets.length; i++) {
                if (SERVLET_CLASS_NAME.equals(remainingServlets[i].getServletClass())) {
                    hasMoreWebServices = true;
                    break;
                }
            }
            if(!hasMoreWebServices){
                Listener[] listeners = webApp.getListener();
                for (int i = 0; i < listeners.length; i++) {
                    Listener listener = listeners[i];
                    if (SERVLET_LISTENER.equals(listener.getListenerClass())) {
                        webApp.removeListener(listener);
                        changed = true;
                        break;
                    }
                }
            }
            if (changed) {
                webApp.write(getDeploymentDescriptor(prj));
            }
        }
    }

    private static void removeServicesFromDD(Project prj, JAXWSLightSupport jaxWsSupport)
        throws IOException {
        WebApp webApp = getWebApp(prj);
        if (webApp != null) {
            boolean changed = false;
            // remove all services
            for (JaxWsService service : jaxWsSupport.getServices()) {
                changed = removeServiceFromDD(webApp, service.getServiceName());
            }
            // remove servlet listener
            Listener[] listeners = webApp.getListener();
            for(int i = 0; i < listeners.length; i++){
                Listener listener = listeners[i];
                if (SERVLET_LISTENER.equals(listener.getListenerClass())) {
                    webApp.removeListener(listener);
                    changed = true;
                    break;
                }
            }
            if (changed) {
                webApp.write(getDeploymentDescriptor(prj));
            }
        }
    }

    /**
     * Remove the web.xml servlets for the non-JSR 109 web service.
     *
     * @param serviceName Name of the web service to be removed
     */
    private static boolean removeServiceFromDD(WebApp webApp, String serviceName) {
        boolean changed = false;
        //first remove the servlet
        Servlet[] servlets = webApp.getServlet();
        for(int i = 0; i < servlets.length; i++){
            Servlet servlet = servlets[i];
            if(servlet.getServletName().equals(serviceName)){
                webApp.removeServlet(servlet);
                changed = true;
                break;
            }
        }
        //remove the servlet mapping
        ServletMapping[] mappings = webApp.getServletMapping();
        for(int i = 0; i < mappings.length; i++){
            ServletMapping mapping = mappings[i];
            if(mapping.getServletName().equals(serviceName)){
                webApp.removeServletMapping(mapping);
                changed = true;
                break;
            }
        }
        return changed;
    }

    /**
     * Remove the web.xml entries for the non-JSR 109 web service.
     *
     * @param serviceName Name of the web service to be removed
     */
    public static void replaceServiceEntriesFromDD(Project prj, String oldServiceName, String newServiceName)
        throws IOException {
        WebApp webApp = getWebApp(prj);
        if (webApp != null) {
            boolean changed = replaceServiceInDD(webApp, oldServiceName, newServiceName);
            if (changed) {
                webApp.write(getDeploymentDescriptor(prj));
            }
        }
    }

    /**
     * Remove the web.xml servlets for the non-JSR 109 web service.
     *
     * @param serviceName Name of the web service to be removed
     */
    private static boolean replaceServiceInDD(WebApp webApp, String oldServiceName, String newServiceName) {
        boolean changed = false;
        //first remove the servlet
        Servlet[] servlets = webApp.getServlet();
        for(int i = 0; i < servlets.length; i++){
            Servlet servlet = servlets[i];
            if(servlet.getServletName().equals(oldServiceName)){
                servlet.setServletName(newServiceName);
                changed = true;
                break;
            }
        }
        //remove the servlet mapping
        ServletMapping[] mappings = webApp.getServletMapping();
        for(int i = 0; i < mappings.length; i++){
            ServletMapping25 mapping = (ServletMapping25)mappings[i];
            if(mapping.getServletName().equals(oldServiceName)){
                mapping.setServletName(newServiceName);
                mapping.setUrlPatterns(new String[]{"/"+newServiceName});
                break;
            }
        }
        return changed;
    }

    public static void checkNonJSR109Entries(Project prj) {
        JAXWSLightSupport jaxWsSupport = JAXWSLightSupport.getJAXWSLightSupport(prj.getProjectDirectory());
        if (jaxWsSupport != null) {
            WSStack<JaxWs> wsStack = new WSStackUtils(prj).getWsStack(JaxWs.class);
            if (wsStack != null) {
                FileObject ddFolder = jaxWsSupport.getDeploymentDescriptorFolder();
                if (wsStack.isFeatureSupported(JaxWs.Feature.JSR109)) {
                    if (ddFolder != null && ddFolder.getFileObject("sun-jaxws.xml") != null) {
                        // remove non JSR109 artifacts
                        if (removeNonJsr109Artifacts(prj)) {
                            try {
                                removeSunJaxWs(ddFolder);
                            } catch (IOException ex) {
                                Logger.getLogger(WSUtils.class.getName()).log(Level.WARNING,
                                        "Cannot remove sun-jaxws.xml file.", ex); //NOI18N
                            }
                            try {
                                removeServicesFromDD(prj, jaxWsSupport);
                            } catch (IOException ex) {
                                Logger.getLogger(WSUtils.class.getName()).log(Level.WARNING,
                                        "Cannot remove services from web.xml.", ex); //NOI18N
                            }
                        }
                    }
                } else {
                    if (ddFolder == null || ddFolder.getFileObject("sun-jaxws.xml") == null) { // NOI18N
                    // generate non JSR109 artifacts
                    if (generateNonJsr109Artifacts(prj)) {
                        if (ddFolder != null) {
                            try {
                                addJaxWsEntries(ddFolder, jaxWsSupport);
                            }
                            catch (IOException ex) {
                                Logger.getLogger(WSUtils.class.getName()).log(
                                        Level.WARNING,
                                        "Cannot modify sun-jaxws.xml file", ex); // NOI18N
                            }
                            try {
                                addServicesToDD(prj, jaxWsSupport);
                            }
                            catch (IOException ex) {
                                Logger.getLogger(WSUtils.class.getName()).log(
                                        Level.WARNING,
                                        "Cannot modify web.xml file", ex); // NOI18N
                            }
                        }
                        else {
                            String mes = NbBundle.getMessage(
                                    MavenJAXWSSupportImpl.class,
                                    "MSG_CannotFindWEB-INF"); // NOI18N
                            NotifyDescriptor desc = new NotifyDescriptor.Message(
                                    mes, NotifyDescriptor.Message.ERROR_MESSAGE);
                            DialogDisplayer.getDefault().notify(desc);
                        }
                    }
                }
            }
        }
    }
    }

    public static String getUniqueId(String id, List<JaxWsService> services) {
        String result = id;
        Set<String> serviceIdSet = new HashSet<String>();
        for (JaxWsService s : services) {
            String serviceId = s.getId();
            if (serviceId != null) {
                serviceIdSet.add(serviceId);
            }
        }

        int i=1;
        while (serviceIdSet.contains(result)) {
            result = id+"_"+String.valueOf(i++); //NOI18N
        }
        return result;
    }

    static boolean isInSourceGroup(Project prj, String serviceClass) {
        if ( serviceClass == null ){
            return false;
        }
        String resource = serviceClass.replace('.', '/') + ".java"; //NOI18N
        SourceGroup[] sourceGroups = ProjectUtils.getSources(prj).getSourceGroups(
                JavaProjectConstants.SOURCES_TYPE_JAVA);
        for (SourceGroup group : sourceGroups) {
            if (group.getRootFolder() != null && group.getRootFolder().
                    getFileObject(resource) != null) 
            {
                return true;
            }

        }
        return false;
    }
    
}