/*

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

  *

  * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

  *

  * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

  * Other names may be trademarks of their respective owners.

  *

  * The contents of this file are subject to the terms of either the GNU

  * General Public License Version 2 only ("GPL") or the Common

  * Development and Distribution License("CDDL") (collectively, the

  * "License"). You may not use this file except in compliance with the

  * License. You can obtain a copy of the License at

  * http://www.netbeans.org/cddl-gplv2.html

  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

  * specific language governing permissions and limitations under the

  * License.  When distributing the software, include this License Header

  * Notice in each file and include the License file at

  * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the GPL Version 2 section of the License file that

  * accompanied this code. If applicable, add the following below the

  * License Header, with the fields enclosed by brackets [] replaced by

  * your own identifying information:

  * "Portions Copyrighted [year] [name of copyright owner]"

  * 

  * Contributor(s):

  * 

  * Portions Copyrighted 2007 Sun Microsystems, Inc.

  */

 package org.netbeans.modules.websvc.manager.test;

 import java.io.File;

 import java.io.FileFilter;

 import java.io.FileInputStream;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.net.URL;

 import java.nio.channels.FileChannel;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.Properties;

 import java.util.jar.Manifest;

 import org.netbeans.junit.MockServices;

 import org.netbeans.modules.websvc.manager.WebServiceManager;

 import org.openide.DialogDisplayer;

 import org.openide.filesystems.FileSystem;

 import org.openide.filesystems.FileUtil;

 import org.openide.filesystems.LocalFileSystem;

 import org.openide.filesystems.MultiFileSystem;

 import org.openide.filesystems.Repository;

 import org.openide.filesystems.XMLFileSystem;

 import org.openide.modules.InstalledFileLocator;

 import org.openide.util.Lookup;

 import org.openide.util.LookupEvent;

 import org.openide.util.LookupListener;

 import org.openide.util.NbCollections;

 /**

  *

  * @author quynguyen

  */

 public class SetupUtil {

     private static final String WORKDIR_SPACES = "user directory";

     private static final String WORKDIR = "userdirectory";

     private static final String TEST_WSDL = "/org/netbeans/modules/websvc/manager/resources/uszip-asmx-catalog/www.webservicemart.com/uszip.asmx.wsdl";

     private static final String TEST_CATALOG = "/org/netbeans/modules/websvc/manager/resources/uszip-asmx-catalog/catalog.xml";

     private static final String CATALOG_FILE = "uszip-asmx-catalog/catalog.xml";

     private static final String WSDL_FILE = "uszip-asmx-catalog/www.webservicemart.com/uszip.asmx.wsdl";

     private static final String ENDORSED_REF = "modules/ext/jaxws21/api/jaxws-api.jar";

     private static final String JAXWS_LIB_PROPERTY = "libs.jaxws21.classpath";

     public static SetupData commonSetUp(File workingDir) throws Exception {

         SetupData data = new SetupData();

         File userDir = new File(workingDir.getParentFile(),

                 System.getProperty("os.name").startsWith("Windows") ? WORKDIR_SPACES : WORKDIR);

         System.getProperties().setProperty("netbeans.user", userDir.getAbsolutePath());

         File websvcHome = new File(WebServiceManager.WEBSVC_HOME);

         data.setWebsvcHome(websvcHome);

         File websvcUserDir = new File(WebServiceManager.WEBSVC_HOME);

         websvcUserDir.mkdirs();

         File wsdlFile = new File(websvcUserDir, WSDL_FILE);

         File catalogFile = new File(websvcUserDir, CATALOG_FILE);

         retrieveURL(wsdlFile, SetupUtil.class.getResource(TEST_WSDL));

         retrieveURL(catalogFile, SetupUtil.class.getResource(TEST_CATALOG));

         copy(wsdlFile, workingDir);

         data.setLocalWsdlFile(wsdlFile);

         data.setLocalCatalogFile(catalogFile);

         data.setLocalOriginalWsdl(new File(workingDir, wsdlFile.getName()));

         MainFS fs = new MainFS();

         fs.setConfigRootDir(websvcHome.getParentFile());

         TestRepository.defaultFileSystem = fs;

         MockServices.setServices(DialogDisplayerNotifier.class, InstalledFileLocatorImpl.class, TestRepository.class);

         InstalledFileLocatorImpl locator = (InstalledFileLocatorImpl)Lookup.getDefault().lookup(InstalledFileLocator.class);

         locator.setUserConfigRoot(websvcHome.getParentFile());

         File targetBuildProperties = new File(websvcUserDir.getParentFile().getParentFile(), "build.properties");

         generatePropertiesFile(targetBuildProperties);

         return data;

     }

     public static void commonTearDown() throws Exception {

         DialogDisplayer dd = DialogDisplayer.getDefault();

         if (dd instanceof DialogDisplayerNotifier) {

             ((DialogDisplayerNotifier)dd).removeAllListeners();

         }

         MockServices.setServices();

     }

     public static void copy(File src, File target) throws Exception {        

         if (src.isFile()) {

             File targetFile = new File(target, src.getName());

             FileInputStream is = new FileInputStream(src);

             FileOutputStream os = new FileOutputStream(targetFile);

             FileChannel inputChannel = is.getChannel();

             FileChannel outputChannel = os.getChannel();

             inputChannel.transferTo(0, inputChannel.size(), outputChannel);

             inputChannel.close();

             outputChannel.close();

         }else {

             File newDir = new File(target, src.getName());

             newDir.mkdirs();

             File[] dirFiles = src.listFiles();

             if (dirFiles != null) {

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

                     copy(dirFiles[i], newDir);

                 }

             }

         }

     }

     public static void retrieveURL(File targetFile, URL url) throws IOException {

         targetFile.getParentFile().mkdirs();

         FileOutputStream fos = new FileOutputStream(targetFile);

         byte[] readBuffer = new byte[1024];

         InputStream is = url.openStream();

         int bytesRead = 0;

         while ( (bytesRead = is.read(readBuffer, 0, 1024)) > 0) {

             fos.write(readBuffer, 0, bytesRead);

         }

         fos.flush();

         fos.close();

         is.close();

     }

     private static void generatePropertiesFile(File target) throws IOException {

         String separator = System.getProperty("path.separator");

         File apiBase = InstalledFileLocator.getDefault().locate(ENDORSED_REF, null, true).getParentFile();

         File jaxWsBase = apiBase.getParentFile();

         FileFilter jarFilter = new FileFilter() {

             public boolean accept(File pathname) {

                 return pathname.isFile() && pathname.getName().endsWith(".jar");

             }

         };

         File[] apiJars = apiBase.listFiles(jarFilter);

         File[] implJars = jaxWsBase.listFiles(jarFilter);

         Properties result = new Properties();

         StringBuffer classpath = new StringBuffer();

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

             String pathElement = apiJars[i].getAbsolutePath() + separator;

             classpath.append(pathElement);

         }

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

             classpath.append(implJars[i].getAbsolutePath());

             if (i != implJars.length - 1) {

                 classpath.append(separator);

             }

         }

         result.setProperty(JAXWS_LIB_PROPERTY, classpath.toString());

         FileOutputStream fos = new FileOutputStream(target);

         result.store(fos, "build.properties file");

     }

     public static final class TestRepository extends Repository {

         static FileSystem defaultFileSystem = null;

         public TestRepository() {

             super(defaultFileSystem);

         }

     }

     // Taken from org.openide.filesystems.ExternalUtil to allow layer files to be

     // loaded into the default filesystem (since core/startup is in the classpath

     // and registers a default Repository that we do not want)

     public static final class MainFS extends MultiFileSystem implements LookupListener {

         private final Lookup.Result<FileSystem> ALL = Lookup.getDefault().lookupResult(FileSystem.class);

         private final FileSystem MEMORY = FileUtil.createMemoryFileSystem();

         private final XMLFileSystem layers = new XMLFileSystem();

         private final LocalFileSystem configRoot = new LocalFileSystem();

         public void setConfigRootDir(File root) throws Exception {

             configRoot.setRootDirectory(root);

         }

         public MainFS() {

             ALL.addLookupListener(this);

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

             ClassLoader l = Thread.currentThread().getContextClassLoader();

             try {

                 for (URL manifest : NbCollections.iterable(l.getResources("META-INF/MANIFEST.MF"))) { // NOI18N

                     InputStream is = manifest.openStream();

                     try {

                         Manifest mani = new Manifest(is);

                         String layerLoc = mani.getMainAttributes().getValue("OpenIDE-Module-Layer"); // NOI18N

                         if (layerLoc != null) {

                             URL layer = l.getResource(layerLoc);

                             if (layer != null) {

                                 layerUrls.add(layer);

                             }

                         }

                     } finally {

                         is.close();

                     }

                 }

                 layers.setXmlUrls(layerUrls.toArray(new URL[layerUrls.size()]));

             } catch (Exception x) {

             }

             resultChanged(null); // run after add listener - see PN1 in #26338

         }

         private FileSystem[] computeDelegates() {

             List<FileSystem> arr = new ArrayList<FileSystem>();

             arr.add(MEMORY);

             arr.add(layers);

             arr.add(configRoot);

             arr.addAll(ALL.allInstances());

             return arr.toArray(new FileSystem[0]);

         }

         public void resultChanged(LookupEvent ev) {

             setDelegates(computeDelegates());

         }

     }

 }