/*
    * 
    *   Copyright 2005-2010, Mike Odling-Smee.  All rights reserved.
    * 	
    * 	Licensed under the Artistic License: 
    * 	http://www.opensource.org/licenses/artistic-license.php
    * 	
    * Preamble
    * 
   *         The intent of this document is to state the conditions under which a 
   *         Package may be copied, such that the Copyright Holder maintains some 
   *         semblance of artistic control over the development of the package, while 
   *         giving the users of the package the right to use and distribute the Package
   * 	       in a more-or-less customary fashion, plus the right to make reasonable 
   *         modifications.
   * 
   * Definitions:
   * 
   *         * "Package" refers to the collection of files distributed by the 
   *         Copyright Holder, and derivatives of that collection of files created 
   *         through textual modification. 
   * 
   *         * "Standard Version" refers to such a Package if it has not been modified, 
   *         or has been modified in accordance with the wishes of the Copyright Holder.
   * 
   *         * "Copyright Holder" is whoever is named in the copyright or copyrights for
   *         the package. 
   * 
   *         * "You" is you, if you're thinking about copying or distributing this Package.
   * 
   *         * "Reasonable copying fee" is whatever you can justify on the basis of 
   *         media cost, duplication charges, time of people involved, and so on. 
   *         (You will not be required to justify it to the Copyright Holder, but 
   *         only to the computing community at large as a market that must bear the 
   *         fee.) 
   * 
   *         * "Freely Available" means that no fee is charged for the item 
   *         itself, though there may be fees involved in handling the item. It also 
   *         means that recipients of the item may redistribute it under the same 
   *         conditions they received it.
   * 
   * 	1. You may make and give away verbatim copies of the source form of the Standard 
   * 	Version of this Package without restriction, provided that you duplicate all of 
   * 	the original copyright notices and associated disclaimers.
   * 	
   * 	2. You may apply bug fixes, portability fixes and other modifications derived 
   * 	from the Public Domain or from the Copyright Holder. A Package modified in such 
   * 	a way shall still be considered the Standard Version.
   * 	
   * 	3. You may otherwise modify your copy of this Package in any way, provided that 
   * 	you insert a prominent notice in each changed file stating how and when you 
   * 	changed that file, and provided that you do at least ONE of the following:
   * 	
   * 		a) place your modifications in the Public Domain or otherwise make them 
   * 		Freely Available, such as by posting said modifications to Usenet or an 
   * 		equivalent medium, or placing the modifications on a major archive site such 
   * 		as ftp.uu.net, or by allowing the Copyright Holder to include your modifications 
   * 		in the Standard Version of the Package.
   * 	
   * 		b) use the modified Package only within your corporation or organization.
   * 	
   * 		c) rename any non-standard executables so the names do not conflict with 
   * 		standard executables, which must also be provided, and provide a separate 
   * 		manual page for each non-standard executable that clearly documents how it 
   * 		differs from the Standard Version.
   * 	
   * 		d) make other distribution arrangements with the Copyright Holder.
   * 	
   * 	4. You may distribute the programs of this Package in object code or executable 
   * 	form, provided that you do at least ONE of the following:
   * 	
   * 		a) distribute a Standard Version of the executables and library files, 
   * 		together with instructions (in the manual page or equivalent) on where to 
   * 		get the Standard Version.
   * 	
   * 		b) accompany the distribution with the machine-readable source of the 
   * 		Package with your modifications.
   * 	
   * 		c) accompany any non-standard executables with their corresponding Standard 
   * 		Version executables, giving the non-standard executables non-standard names, 
   * 		and clearly documenting the differences in manual pages (or equivalent), 
   * 		together with instructions on where to get the Standard Version.
   * 	
   * 		d) make other distribution arrangements with the Copyright Holder.
   * 	
   * 	5. You may charge a reasonable copying fee for any distribution of this Package. 
   * 	You may charge any fee you choose for support of this Package. You may not 
   * 	charge a fee for this Package itself. However, you may distribute this Package 
   * 	in aggregate with other (possibly commercial) programs as part of a larger 
   * 	(possibly commercial) software distribution provided that you do not advertise 
   * 	this Package as a product of your own.
   * 	
   * 	6. The scripts and library files supplied as input to or produced as output from 
   * 	the programs of this Package do not automatically fall under the copyright of 
   * 	this Package, but belong to whomever generated them, and may be sold 
   * 	commercially, and may be aggregated with this Package.
   * 	
   * 	7. C or perl subroutines supplied by you and linked into this Package shall not 
   * 	be considered part of this Package.
  * 	
  * 	8. The name of the Copyright Holder may not be used to endorse or promote 
  * 	products derived from this software without specific prior written permission.
  * 	
  * 	9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED 
  * 	WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 
  * 	MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  * 
  * The End
  */
 package net.sourceforge.xuse.build;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.Reader;
 import java.io.StringReader;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
 import javax.xml.parsers.SAXParserFactory;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerException;
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.URIResolver;
 import javax.xml.transform.stream.StreamResult;
 import javax.xml.transform.stream.StreamSource;
 
 import net.sf.saxon.Controller;
 import net.sf.saxon.FeatureKeys;
 import net.sourceforge.xuse.log.Logger;
 import net.sourceforge.xuse.utils.CommandLineWrapper;
 import net.sourceforge.xuse.utils.Utils;
 import net.sourceforge.xuse.utils.XuseUtils;
 
 import com.xmlsolutions.annotation.Requirement;
 
 
 public class StylesheetInvoker {
     
     	private static final TransformerFactory transformerFactory = new net.sf.saxon.TransformerFactoryImpl();
     	private static final SAXParserFactory saxFactory = SAXParserFactory.newInstance();
     	private static final URIResolver uriResolver = transformerFactory.getURIResolver();
     	private static final boolean DO_GRAPHS = CommandLineWrapper.graphVizAvailable(); 
     	private static final String PERF_XML_OUT_BASE = "target/performance/";
     	
     	private static final StylesheetInvoker INSTANCE = new StylesheetInvoker();
     	
     	protected StylesheetInvoker() {
     		Logger.debug(StylesheetInvoker.class, "Using TransformerFactory: " + transformerFactory.getClass().getCanonicalName());
     		Logger.debug(StylesheetInvoker.class, "Using SAXParserFactory: " + saxFactory.getClass().getCanonicalName());
     		Logger.debug(StylesheetInvoker.class, "Using URI Resolver: " + uriResolver.getClass().getCanonicalName());
     		try {
 				saxFactory.setFeature("http://xml.org/sax/features/validation", false);
     			transformerFactory.setAttribute(FeatureKeys.DTD_VALIDATION, false);
     			//Line numbers are useful in the processed peformance analysis graphs
     			if (XusePropertiesReader.doPerformanceAnalysis()) {
     				transformerFactory.setAttribute(FeatureKeys.LINE_NUMBERING,Boolean.TRUE);
     			}
     			//Some parsers cannot handle XInclude directives
     			try {
     				transformerFactory.setAttribute(FeatureKeys.XINCLUDE, true);
     				//Create a dummy transformer to test XInclude support
     				transformerFactory.newTransformer(new StreamSource(ClassLoader.getSystemResourceAsStream("xslts/utils/core-utils.xsl")));
     			} catch (Throwable t) {
     				Logger.warn(StylesheetInvoker.class, "It seems that your parser (" + saxFactory.getClass().getCanonicalName() + ") does not support XInclude directives so these will not be processed");
     				//Reset the XInclude support
     				transformerFactory.setAttribute(FeatureKeys.XINCLUDE, false);
     			}
     			File perfDir = new File(PERF_XML_OUT_BASE);
     			if (!perfDir.exists()) {
     				perfDir.mkdirs();
     			}
 			} catch (Throwable t) {
 				Logger.error(this, "Could not initialise XML parser", t);
 			}
     	}
     	
     	public static final StylesheetInvoker getInstance() {
 			return INSTANCE;
 		}
 	
     public void invokeXslForString(String xmlString, String output, String xslFile, String templateName, Map args) throws BuildException {
     	try {
 			Reader source = new StringReader(xmlString);
 	        StreamSource xmlSource = new StreamSource(source);
 	        this.invokeXslForStreamSource(xmlSource, output, xslFile, templateName, args);
 		} catch (Throwable t) {
 			throw new BuildException("Error transforming xml with " + xslFile + "\nto output : " + output + "\nerror was: "+  t.getLocalizedMessage(), t);
 		}
     }
     
     private void invokeXslForStreamSource(StreamSource xmlSource, String output, String xslFile, String templateName, Map args) throws TransformerException {
     		// Create a transformer for the stylesheet.
 	        StreamSource xsl = getXsl(xslFile);
 			Transformer transformer = this.initTransformer(xsl, args);	        
 			if(templateName != null && templateName.trim().length() > 0) {
 				//We have a dependency on Saxon here
 		        ((Controller)transformer).setInitialTemplate(templateName);
 			}	        
 	        File outFile = new File(output);
 	        StreamResult tempResult = new StreamResult(outFile.toURI().toString());
 	        tempResult.setSystemId(outFile.toURI().toString());
 	        transformer.transform(xmlSource, tempResult);
         
     }
 	
     public void invokeXsl(String input, String output, String xslFile, String templateName, Map args) throws BuildException {
 		Logger.debug(this, "Applying transform: " + xslFile + " to " + input + " writing " + output + " usings args (" + args + ")");
 		try {
 			StreamSource xmlSource = null;
 			if (input != null) {
 				//Have we got an absolute or relative path?
 				File srcXML = new File(input);
 				if (!srcXML.exists()) {
 					//Does not exist assume relative path
 					srcXML = new File(new File("."), input);
 			        if (!srcXML.exists()) {
 			        	Logger.warn(this, "Cannot find: " + srcXML.getAbsolutePath());
 			        }
 				}
 		        InputStream source = new FileInputStream(srcXML);
 		        xmlSource = new StreamSource(source);
 		        xmlSource.setSystemId(srcXML.getAbsolutePath());
 			}
 	        this.invokeXslForStreamSource(xmlSource, output, xslFile, templateName, args);
 		} catch (Throwable t) {
 			throw new BuildException("Error transforming " + input + "\nwith " + xslFile + "\nto output : " + output + "\nerror was: "+  t.getLocalizedMessage(), t);
 		}
 	}
 	
 	public void invokeXsl(StreamSource source, StreamResult result, String xslFile, String templateName, Map args) throws BuildException {
 		try {
 		    // Create a transformer for the stylesheet.
 		    StreamSource xsl = getXsl(xslFile);
 		    Transformer transformer = this.initTransformer(xsl, args);
 		    if(templateName != null && templateName.trim().length() > 0) {
 				//We have a dependency on Saxon here
 				((Controller)transformer).setInitialTemplate(templateName);
 		    }
 		    transformer.transform(source, result);
 		} catch (Throwable t) {
 		    throw new BuildException("Error transforming " + source.getSystemId() + "\nwith " + xslFile + "\nto output : " + result.getSystemId() + "\nerror was: "+  t.getLocalizedMessage(), t);
 		}
 	}
 	
 	public void invokeXsl(String input, String output, String xslFile) throws BuildException {
 		this.invokeXsl(input, output, xslFile, null, null);
 	}
 	
 	@Requirement(traceTo={"RQ58"})
 	public void invokePDFUseCases() throws BuildException {
 		if (XusePropertiesReader.doPerformanceAnalysis()) {
 			//Note this is not thread safe but Xuse is only single threaded so we are OK
 			transformerFactory.setAttribute(FeatureKeys.TRACE_LISTENER,TraceListenerFactory.getInstance().getTraceListener(PERF_XML_OUT_BASE + "pdf-use-cases.xml"));
 		}		
 		String xslID = XusePropertiesReader.getSitePdfXslController();
 		String sourceID = XusePropertiesReader.getRequirementsRepositoryFile();
 		this.invokeXsl(sourceID, "deleteme.xml", xslID, "do-use-cases", null);
 	}
 	
 	@Requirement(traceTo={"RQ58"})
 	public void invokePDFSingleUseCase(String useCaseId) throws BuildException {
 		if (XusePropertiesReader.doPerformanceAnalysis()) {
 			//Note this is not thread safe but Xuse is only single threaded so we are OK
 			transformerFactory.setAttribute(FeatureKeys.TRACE_LISTENER,TraceListenerFactory.getInstance().getTraceListener(PERF_XML_OUT_BASE + "pdf-use-case.xml"));
 		}
 		String xslID = XusePropertiesReader.getSitePdfXslController();
 		String sourceID = XusePropertiesReader.getRequirementsRepositoryFile();
 		Map<String, String> args = new HashMap<String, String>();
 		args.put("uc-id", useCaseId);
 		this.invokeXsl(sourceID, "deleteme.xml", xslID, "single-use-case", args);
 	}
 	
 	public void invokeImportTraceReport() throws BuildException {
 		String xslID = "xslts/data-imports/import-trace-report.xsl";
 		String sourceID = XusePropertiesReader.getTraceReportInput();
 		String upgradedRepositoryFileName = XusePropertiesReader.getTraceReportOutput();
 		Logger.info(INSTANCE, "Importing traces from " + sourceID + ", wrting result " + upgradedRepositoryFileName);
 		this.invokeXsl(sourceID, upgradedRepositoryFileName, xslID, null, null);
 	}
 
 	public void invokeBuildHTMLSite() throws BuildException {
 		if (XusePropertiesReader.doPerformanceAnalysis()) {
 			//Note this is not thread safe but Xuse is only single threaded so we are OK
 			transformerFactory.setAttribute(FeatureKeys.TRACE_LISTENER,TraceListenerFactory.getInstance().getTraceListener(PERF_XML_OUT_BASE + "html.xml"));
 		}
 		String xslID = XusePropertiesReader.getSiteXslController();
 		String sourceID = XusePropertiesReader.getRequirementsRepositoryFile();
 		this.invokeXsl(sourceID, "deleteme.xml", xslID, "main", null);
 	}
 	
 	public void processPerformanceResults() throws BuildException {
 		if (XusePropertiesReader.doPerformanceAnalysis()) {
 			Logger.info(this, "Plotting performance results...");
 			try {
 				/*
 				 * Cannot use-the default factory as this would try
 				 * do performance analysis on itself probably ending
 				 * up in some recursive mess!!
 				 */
 				TransformerFactory factory = new net.sf.saxon.TransformerFactoryImpl();
 				Transformer transformer = factory.newTransformer(getXsl("timing-profile.xsl"));
 				List<File> performanceXMLFiles = Arrays.asList(new File(PERF_XML_OUT_BASE).listFiles());
 				File outDir = new File(XusePropertiesReader.getOutputDirectory() + "/performance");
 				if (!outDir.exists()) {
 					outDir.mkdirs();
 				}
 				for (File performanceXMLFile : performanceXMLFiles) {
 					Logger.debug(this, "Creating performance results for: " + performanceXMLFile.getAbsolutePath());
 					InputStream source = new FileInputStream(performanceXMLFile);
 			        StreamSource xmlSource = new StreamSource(source);
 			        xmlSource.setSystemId(performanceXMLFile.getAbsolutePath());
 					File outFile = new File(outDir, "performance-results-" + performanceXMLFile.getName().substring(0, performanceXMLFile.getName().lastIndexOf(".")) + ".html");
 			        StreamResult result = new StreamResult(outFile.toURI().toString());
 			        result.setSystemId(outFile.toURI().toString());
 					transformer.transform(xmlSource, result);
 				}
 			} catch (Throwable t) {
 				throw new BuildException("Error generating performance results", t);
 			}
 		}
 	}
 	
 	@Requirement(traceTo={"RQ19", "RQ60"})
 	public void invokeBuildHTMLDocuments() throws BuildException {
 		
 		List<String> allDocs = XuseUtils.getDocuments();
 		if (allDocs != null) {
 			for (String currentDoc : allDocs) {
 				File currentFile = new File(currentDoc);
 				if (currentFile.exists() && currentFile.isFile()) {
 					if (XusePropertiesReader.doPerformanceAnalysis()) {
 						//Note this is not thread safe but Xuse is only single threaded so we are OK
 						String docSuffix =  currentFile.getName().substring(0, currentFile.getName().lastIndexOf("."));
 						transformerFactory.setAttribute(FeatureKeys.TRACE_LISTENER, TraceListenerFactory.getInstance().getTraceListener(PERF_XML_OUT_BASE + "html-documents-" + docSuffix + ".xml"));
 					}
 					String xslID = XusePropertiesReader.getGenericDocumentXsl();
 					this.invokeXsl(currentDoc, XusePropertiesReader.getOutputDirectory() + "/deleteme.html", xslID, null, null);
 					File deleteMeHTML = new File(XusePropertiesReader.getOutputDirectory() + "/deleteme.html");
 					if (!deleteMeHTML.delete()) {
 						Logger.debug(this, "Could not delete temporary file " + deleteMeHTML.getAbsolutePath());
 					}
 				} else {
 					Logger.warn(this, "Location " + currentFile + " does not appear to be a valid file");
 				}
 			}
 		}		
 	}
 	
 	public void invokeGraphRequirement(String requirementId) throws BuildException {
 		String requirementsDoc = XusePropertiesReader.getRequirementsRepositoryFile();
 		//TODO - get this from properties file
 		String xsl = "xslts/graph/requirement-graph.xsl";
 		Map<String, String> args = new HashMap<String, String>();
 		args.put("req-id", requirementId);
 		String dotDir = XusePropertiesReader.getOutputDirectory();
 		String dotFile =  "req-" + requirementId + ".dot";
 		String svgTempFile = XusePropertiesReader.getOutputDirectory() + "/req-" + requirementId + "-temp.svg";
 		String svgFile = XusePropertiesReader.getOutputDirectory() + "/req-" + requirementId + ".svg";
 		this.invokeXsl(requirementsDoc, dotFile, xsl, null, args);
 		FileWriter svgResultFile = null;
 		try {
 			String resultSvgRaw = CommandLineWrapper.executeGraphVizForSvg(dotDir, dotFile);
 			svgResultFile = new FileWriter(svgTempFile);
 			svgResultFile.append(resultSvgRaw);
 			this.invokeXslForString(resultSvgRaw, svgFile, "xslts/graph/prettying-graphviz.xsl", null, null);
 		} catch (IOException ioe) {
 			throw new BuildException("Could not create requirement graph", ioe);
 		} finally {
 			if (svgResultFile != null) {
 				try {
 					svgResultFile.close();
 				} catch (IOException e) {
 					throw new BuildException("Could not close SVG result file", e);
 				}
 			}
 		}
 	}
 	
 	@Requirement(traceTo={"RQ48"})
 	public void invokeValidateProject() throws BuildException {
 		if (XusePropertiesReader.doPerformanceAnalysis()) {
 			//Note this is not thread safe but Xuse is only single threaded so we are OK
 			transformerFactory.setAttribute(FeatureKeys.TRACE_LISTENER,TraceListenerFactory.getInstance().getTraceListener("validate.xml"));
 		}
 		String xslID = XusePropertiesReader.getSiteXslController();
 		String sourceID = XusePropertiesReader.getRequirementsRepositoryFile();
 		this.invokeXsl(sourceID, "deleteme.xml", xslID, "validate", null);
 	}
 
 	public void invokeUpgrade() throws BuildException {
 		String xslID = XusePropertiesReader.getUpgradeXslController();
 		String sourceID = XusePropertiesReader.getRequirementsRepositoryFile();
 		this.invokeXsl(sourceID, "deleteme.xml", xslID, "main", null);
 	}
 
 	public Transformer initTransformer(StreamSource xsl, Map<String, String> addtionalArgs) throws BuildException {
 		//System.setProperty("javax.xml.transform.TransformerFactory", "net.sf.saxon.TransformerFactoryImpl");
 		try {
 			//TransformerFactory tFactory = TransformerFactory.newInstance();
 			
 			Transformer transformer = transformerFactory.newTransformer(xsl);
 			File baseDir = new File(".");
 			transformer.setParameter("baseDir", baseDir.getAbsolutePath());
 			transformer.setParameter("theme", XusePropertiesReader.getHTMLTheme());
 			transformer.setParameter("useCaseFolder", XusePropertiesReader.getUseCaseDirectory());
 			transformer.setParameter("html-output-location", XusePropertiesReader.getOutputDirectory());
 			transformer.setParameter("dictionary", XusePropertiesReader.getDictionary());
 			transformer.setParameter("userDictionary", XusePropertiesReader.getUserDictionary());
 			transformer.setParameter("requirement-xml-file", XusePropertiesReader.getRequirementsRepositoryFile());
 			transformer.setParameter("actors-xml-file", XusePropertiesReader.getActors());
 			transformer.setParameter("stakeholders-xml-file", XusePropertiesReader.getStakeholders());
 			transformer.setParameter("glossary-xml-file", XusePropertiesReader.getGlossary());
 			transformer.setParameter("company", XusePropertiesReader.getCompanyName());
 			transformer.setParameter("project", XusePropertiesReader.getProjectName());
 			transformer.setParameter("customer", XusePropertiesReader.getCustomerName());
 			transformer.setParameter("company-logo", XusePropertiesReader.getCompanyLogo());
 			transformer.setParameter("project-logo", XusePropertiesReader.getProjectLogo());
 			transformer.setParameter("customer-logo", XusePropertiesReader.getCustomerLogo());
 			transformer.setParameter("req-nav-style", XusePropertiesReader.getRequirementNavigationViewStyle());
 			transformer.setParameter("req-list-style", XusePropertiesReader.getRequirementListStyle());
 			//All settings for doing graphics
 			transformer.setParameter("graphviz-available", new Boolean(DO_GRAPHS));
 			transformer.setParameter("usecase-pkg-diag-html", new Boolean(XusePropertiesReader.graphUseCasePackageHTML()));
 			transformer.setParameter("usecase-pkg-diag-pdf", new Boolean(XusePropertiesReader.graphUseCasePackagePDF()));
 			transformer.setParameter("usecase-pkg-diag-splines", XusePropertiesReader.graphUseCasePackageSplines());
 			transformer.setParameter("usecase-pkg-diag-degrees", XusePropertiesReader.graphUseCasePackageDegrees());
 			transformer.setParameter("use-case-activity-html", new Boolean(XusePropertiesReader.graphUseCaseActivityDiagramsHTML()));
 			transformer.setParameter("use-case-activity-pdf", new Boolean(XusePropertiesReader.graphUseCaseActivityDiagramsPDF()));
 			transformer.setParameter("use-case-activity-splines", XusePropertiesReader.graphUseCaseActivityDiagramsSplines());
 			//Miscellaneous
 			transformer.setParameter("min-log-level", XusePropertiesReader.getLogLevelAsStr());
 			transformer.setParameter("skip-model-validation", new Boolean(XusePropertiesReader.skipModelValidation()));
 			transformer.setParameter("store-model-memento", new Boolean(XusePropertiesReader.storeModelMemento()));
 			transformer.setParameter("skip-glossary-linking", new Boolean(XusePropertiesReader.skipGlossaryLinking()));
 			
 			//transformer.setParameter("trace-report", XusePropertiesReader.getTraceReport());
 			if (addtionalArgs != null && !addtionalArgs.isEmpty()) {
 				Iterator<Entry<String, String>> iter =  addtionalArgs.entrySet().iterator();
 				Map.Entry<String,String> entry = null;
 				while (iter.hasNext()) {
 					entry = iter.next();
 					Logger.debug(this, "Adding parameter: " + entry.getKey() + "; " + entry.getValue());
 					transformer.setParameter((String)entry.getKey(), entry.getValue());
 				}
 			}
 			this.overrideTransforInitialisation(transformer);	
 			return transformer;
 		} catch (Throwable t) {
 			t.printStackTrace();
 			throw new BuildException("Error initialising XSLT: " + t.getLocalizedMessage(), t);
 		}
 	}
 	
 	protected void overrideTransforInitialisation(Transformer transformer) throws BuildException {
 	    //Do nothing
 	}
 	
 	private StreamSource getXsl(String name) throws BuildException {
 		//File userDir = new File(System.getProperty("user.home"));
 		//File xuseDir = new File(userDir, ".xuse");
 		File xuseDir = new File(XusePropertiesReader.getXuseWorkingDir());
 		File file = new File(xuseDir, name);
 		StreamSource streamSource = null;
 		try {
 			if (!file.exists()) {
 				InputStream is = ClassLoader.getSystemResourceAsStream(name);
 				if (is != null) {
 					streamSource = new StreamSource(is);
 				} else {
 					throw new BuildException("Could not locate " + name + " in " + xuseDir.getAbsolutePath() + ", or in the classpath");
 				}
 			} else {
 				streamSource = new StreamSource(new FileInputStream(file));
 				streamSource.setSystemId(file.toURI().toString());
 			}
 		} catch (FileNotFoundException fnfe) {
 			throw new BuildException("Error finding the file - " + name + " - in the classpath.", fnfe);
 		}
 		return streamSource;
 	}
 	
 	
 
 }