/**
    * Copyright (C) 2005-2009 Alfresco Software Limited.
    *
    * This file is part of the Spring Surf Extension project.
    *
    * Licensed 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.springframework.roo.addon.surf;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.List;
  import java.util.logging.Logger;
  
  import org.springframework.roo.addon.surf.site.SiteOperations;
  import org.springframework.roo.addon.surf.util.SurfUtils;
  import org.springframework.roo.metadata.MetadataService;
  import org.springframework.roo.process.manager.FileManager;
  import org.springframework.roo.process.manager.MutableFile;
  import org.springframework.roo.project.Dependency;
  import org.springframework.roo.project.Path;
  import org.springframework.roo.project.PathResolver;
  import org.springframework.roo.project.ProjectMetadata;
  import org.springframework.roo.project.ProjectOperations;
  import org.springframework.roo.project.ProjectType;
  import org.springframework.roo.support.lifecycle.ScopeDevelopment;
  import org.springframework.roo.support.util.Assert;
  import org.springframework.roo.support.util.FileCopyUtils;
  import org.springframework.roo.support.util.TemplateUtils;
  import org.springframework.roo.support.util.XmlUtils;
  
  import org.w3c.dom.Comment;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  
  /**
   * Provides Surf related operations.
   *
   * @author Yong Qu
   * @since 1.0
   */
  @ScopeDevelopment
  public class SurfOperations
  {
  	private static final String RELATIVE_PATH_POM_XML = "pom.xml";
  	private static final String RELATIVE_PATH_SURF_CONFIG_XML = "WEB-INF/config/surf-config.xml";
  	private static final String RELATIVE_PATH_SURF_INTEROP_XML = "WEB-INF/config/surf-interop-config.xml";
  	private static final String RELATIVE_PATH_WEB_APPLICATION_CONFIG_XML = "WEB-INF/config/web-application-config.xml";
  	private static final String RELATIVE_PATH_WEB_XML = "WEB-INF/web.xml";
  	private static final String RELATIVE_PATH_SURF_XML = "WEB-INF/surf.xml";
  	private static final String RELATIVE_RATH_URLREWRITE_XML = "WEB-INF/urlrewrite.xml";
  
  	private static final String RELATIVE_PATH_WEB_XML_TEMPLATE = "web.xml";
  	private static final String RELATIVE_PATH_DEPENDENCIES_TEMPLATE = "dependencies.xml";
  	private static final String RELATIVE_PATH_PHP_DEPENDENCIES_TEMPLATE = "php-dependencies.xml";
  	private static final String RELATIVE_PATH_GROOVY_DEPENDENCIES_TEMPLATE = "groovy-dependencies.xml";
  	private static final String RELATIVE_PATH_WEBSTUDIO_DEPENDENCIES_TEMPLATE = "webstudio-dependencies.xml";
  
  	private static final String FILENAME_SURF_SAMPLE_SITE = "surf-sample-site";
  	private static final String FILENAME_CMIS_SAMPLES = "surf-cmis-samples";
  	private static final String FILENAME_ALFRESCO_SAMPLES = "surf-alfresco-samples";
  
  	private static final String DEFAULT_HOME_PAGE_NAME = "home";
  
  	Logger logger = Logger.getLogger(SurfOperations.class.getName());
  
  	private FileManager fileManager;
  	private PathResolver pathResolver;
  	private MetadataService metadataService;
  	private ProjectOperations projectOperations;
  
  	/**
  	 * @param fileManager
  	 * @param pathResolver
  	 * @param metadataService
  	 * @param projectOperations
  	 */
  	public SurfOperations(FileManager fileManager, PathResolver pathResolver, MetadataService metadataService, ProjectOperations projectOperations)
  	{
  		Assert.notNull(fileManager, "File manager required");
  		Assert.notNull(pathResolver, "Path resolver required");
  		Assert.notNull(metadataService, "Metadata service required");
  		Assert.notNull(projectOperations, "Project operations required");
  		this.fileManager = fileManager;
  		this.pathResolver = pathResolver;
  		this.metadataService = metadataService;
  		this.projectOperations = projectOperations;
 	}
 
 	/**
 	 * Returns whether Surf is installed or not.
 	 * @return True if Surf has not been installed. False if Surf has been installed.
 	 */
 	public boolean isInstallSurfAvailable()
 	{
 		return getPathResolver() != null && !fileManager.exists(getPathResolver().getIdentifier(Path.SRC_MAIN_WEBAPP, RELATIVE_PATH_SURF_XML));
 	}
 
 	/**
 	 * Returns whether Surf is available.
 	 * @return True if Surf has been installed. False if Surf has not been installed.
 	 */
 	public boolean isManageSurfAvailable() {
 		return fileManager.exists(getPathResolver().getIdentifier(Path.SRC_MAIN_WEBAPP, RELATIVE_PATH_SURF_XML));
 	}
 
 	/**
 	 * Installs Surf.
 	 * @param siteName Surf site name. The project name will be used as the default if the site name is not specified.
 	 */
 	public void installSurf(String siteName)
 	{
 		// Set up site name.
 		if (siteName==null || siteName.equals(""))
 		{
 			ProjectMetadata projectMetadata = (ProjectMetadata) metadataService.get(ProjectMetadata.getProjectIdentifier());
 			siteName = projectMetadata.getProjectName();
 		}
 
 		// Add Surf Configuration files.
 		installSurfConfigXmls();
 
 		// Add or update web.xml.
 		processWebXml();
 
 		// Update Maven pom.xml.
 		processMavenXml();
 
 		// Add surf UrlRewrite settings.
 		processUrlRewrite();
 
 		// Add surf autowire configuration file.
 		processSurfXml();
 
 		// Add surf pom dependencies.
 		updateDependencies();
 
 		// Install the default Surf sample site
 		// This helps people to get started
 		installSurfSampleSite();
 
 		// Setup site default configuration
 		SiteOperations siteOperations = new SiteOperations(fileManager, pathResolver, metadataService, projectOperations);
 		siteOperations.newSite(null, DEFAULT_HOME_PAGE_NAME);
 
 	}
 
 	/**
 	 * Updates pom.xml to include Surf specific plugins and repositories etc if any.
 	 */
 	private void processMavenXml(){
 
 		//copySurfTemplate(Path.ROOT, RELATIVE_PATH_POM_XML, false); 
 
 	}
 
 	/**
 	 * Installs or updates the urlrewrite.xml to include Surf-specific redirects.
 	 */
 	private void processUrlRewrite()
 	{
 		if ( copySurfTemplate(Path.SRC_MAIN_WEBAPP, RELATIVE_RATH_URLREWRITE_XML, false) ) {
 
 			//file exists, we need to inject surf settings.
 			String urlrewritePath = pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, RELATIVE_RATH_URLREWRITE_XML);
 
 			Document urlrewrite = getXmlDocument(urlrewritePath);
 
 			Element root = urlrewrite.getDocumentElement();
 
 			// surf rules (add in reverse order of intended display)
 			updateRule(urlrewrite,root,"/**", "/page/$1");
 			updateRule(urlrewrite,root,"/page/**", "/page/$1");
 			updateRule(urlrewrite,root,"/res/**", "/page/resource/$1");
 			updateRule(urlrewrite,root,"/endpoint/**", "/page/endpoint/$1");
 			Element newRuleElem1 = updateRule(urlrewrite,root,"/proxy**", "/page/proxy/$1");
 
 			// add some commentary above the surf rules
 			root.insertBefore(urlrewrite.createTextNode("\n"), newRuleElem1);
 			root.insertBefore(urlrewrite.createTextNode("\t"), newRuleElem1);
 			root.insertBefore(urlrewrite.createComment("Required for Surf - Redirects"), newRuleElem1);
 			root.insertBefore(urlrewrite.createTextNode("\n"), newRuleElem1);
 
 			// surf outbound rule
 			updateOutboundRule(urlrewrite,root,"/page/**", "/$1");
 
 			// Updates the file.
 			updateXmlDocument(urlrewritePath,urlrewrite);
 		}	
 	}
 
 	/**
 	 * Installs the Surf configuration files for Spring MVC.
 	 * The configuration files are surf-config.xml, surf-interop-config.xml and web-application-config.xml.
 	 * If the files are already there, they will not be overwritten.
 	 */
 	private void installSurfConfigXmls()
 	{
 
 		copySurfTemplate(Path.SRC_MAIN_WEBAPP, RELATIVE_PATH_SURF_CONFIG_XML, false); 
 
 		copySurfTemplate(Path.SRC_MAIN_WEBAPP, RELATIVE_PATH_SURF_INTEROP_XML, false); 
 
 		copySurfTemplate(Path.SRC_MAIN_WEBAPP, RELATIVE_PATH_WEB_APPLICATION_CONFIG_XML, false); 
 
 	}
 
 	/**
 	 * Installs or updates web.xml.
 	 */
 	private void processWebXml(){
 
 		String webXmlPath = pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, RELATIVE_PATH_WEB_XML);
 
 		if ( copySurfTemplate(Path.SRC_MAIN_WEBAPP, RELATIVE_PATH_WEB_XML, false)) {
 
 			Document webXml = getXmlDocument(webXmlPath);
 			Element root = webXml.getDocumentElement();
 
 			Document webXmlTemplate = getTemplateDocument(RELATIVE_PATH_WEB_XML_TEMPLATE);
 			Element webXmlElement = webXmlTemplate.getDocumentElement();
 
 			Element webAppElem = XmlUtils.findFirstElement("/web-app", root);
 
 			if ( webAppElem==null ) {
 				throw new IllegalStateException("This command cannot be run for an invalid web.xml.");
 			}
 
 			// Add add-on specific filters to pom.xml
 			List<Element> surfFilters = XmlUtils.findElements("/web-app/surf/filter", webXmlElement);
 			for(Element filter : surfFilters)
 			{
 				if (filter.hasChildNodes() && filter.getElementsByTagName("filter-name").getLength() > 0) {
 					String filterName = filter.getElementsByTagName("filter-name").item(0).getTextContent().trim();
 					// Check if the web.xml document has it
 					Element filterElem   = XmlUtils.findFirstElement("/web-app/filter[filter-name='"+filterName+"']", root);
 
 					if ( filterElem != null) {
 						webAppElem.removeChild(filterElem);
 					}
 
 					webAppElem.appendChild(webXml.importNode(filter,true));
 				}
 			}
 
 			// Add add-on specific filters to pom.xml
 			List<Element> surfFilterMappings = XmlUtils.findElements("/web-app/surf/filter-mapping", webXmlElement);
 			for(Element filterMapping : surfFilterMappings)
 			{
 				if (filterMapping.hasChildNodes() && filterMapping.getElementsByTagName("filter-name").getLength() > 0) {
 					String filterName = filterMapping.getElementsByTagName("filter-name").item(0).getTextContent().trim();
 					// Check if the web.xml document has it
 					Element filterMappingElem   = XmlUtils.findFirstElement("/web-app/filter-mapping[filter-name='"+filterName+"']", root);
 
 					if ( filterMappingElem != null) {
 						webAppElem.removeChild(filterMappingElem);
 					}
 
 					webAppElem.appendChild(webXml.importNode(filterMapping,true));
 				}
 			}
 
 			// Add add-on specific servlet  to pom.xml
 			List<Element> surfServlets = XmlUtils.findElements("/web-app/surf/servlet", webXmlElement);
 			for(Element servlet : surfServlets)
 			{
 				if (servlet.hasChildNodes() && servlet.getElementsByTagName("servlet-name").getLength() > 0) {
 					String servletName = servlet.getElementsByTagName("servlet-name").item(0).getTextContent().trim();
 					// Check if the web.xml document has it
 					Element servletElem   = XmlUtils.findFirstElement("/web-app/servlet[servlet-name='"+servletName+"']", root);
 
 					if ( servletElem != null) {
 						webAppElem.removeChild(servletElem);
 					}					
 					webAppElem.appendChild(webXml.importNode(servlet,true));
 				}
 			}
 
 			// Add add-on specific servlet mapping to pom.xml
 			List<Element> surfServletMappings = XmlUtils.findElements("/web-app/surf/servlet-mapping", webXmlElement);
 			for(Element servletMapping : surfServletMappings)
 			{
 				if (servletMapping.hasChildNodes() && servletMapping.getElementsByTagName("servlet-name").getLength() > 0) {
 					String servletName = servletMapping.getElementsByTagName("servlet-name").item(0).getTextContent().trim();
 					// Check if the web.xml document has it
 					Element servletMappingElem   = XmlUtils.findFirstElement("/web-app/servlet-mapping[servlet-name='"+servletName+"']", root);
 
 					if ( servletMappingElem != null) {
 						webAppElem.removeChild(servletMappingElem);
 					}
 
 					webAppElem.appendChild(webXml.importNode(servletMapping,true));
 				}
 			}
 
 			// Updates the file.
 			updateXmlDocument(webXmlPath,webXml);		
 		}
 
 	}
 
 	/**
 	 * Installs surf.xml.
 	 */
 	private void processSurfXml(){
 		copySurfTemplate(Path.SRC_MAIN_WEBAPP, RELATIVE_PATH_SURF_XML, false);
 	}
 
 	/**
 	 * Updates POM dependencies.
 	 */
 	private void updateDependencies()
 	{
 		addPOMDependenciesFromFile(RELATIVE_PATH_DEPENDENCIES_TEMPLATE);
 	}
 
 	/**
 	 * Returns current project path resolver.
 	 * @return Current project path resolver.
 	 */
 	private PathResolver getPathResolver() {
 		ProjectMetadata projectMetadata = (ProjectMetadata) metadataService.get(ProjectMetadata.getProjectIdentifier());
 		if (projectMetadata == null) {
 			return null;
 		}
 		return projectMetadata.getPathResolver();
 	}
 
 	/**
 	 * Utility method for adding a comment element to an XML document.
 	 * @param doc XML Document.
 	 * @param root Element which will be commented.
 	 * @param commentText Comment Text.
 	 * @return Added comment element.
 	 */
 	private Comment addComment(Document doc,Element root,String commentText)	{
 
 		Comment comment = doc.createComment(commentText);
 		root.getParentNode().insertBefore(comment, root);
 
 		return comment;
 
 	}
 
 	/**
 	 * Utility method for updating MVC interceptors.
 	 * @param webmvcxml MVC configuration XML file.
 	 * @param root Root element of the  MVC configuration XML file.
 	 * @param beanName Target bean name.
 	 * @return Updated interceptor element.
 	 */
 	private Element updateInterceptor(Document webmvcxml,Element root,String beanName)
 	{
 		Element interceptorElem = XmlUtils.findFirstElement("/ref[@bean='"+beanName+"']", root);
 		if ( interceptorElem != null )
 		{
 			interceptorElem.setAttribute("bean", beanName);
 		}
 		else
 		{
 			interceptorElem = webmvcxml.createElement("ref");
 			interceptorElem.setAttribute("bean", beanName);
 		}
 
 		// either way, move the interceptor to the top
 		Element firstChild = XmlUtils.findFirstElement("bean", root);
 		root.insertBefore(interceptorElem, firstChild);
 		root.insertBefore(webmvcxml.createTextNode("\n"), interceptorElem);
 
 		return interceptorElem;
 	}
 
 	/**
 	 * Utility method for updating rules of the urlrewrite.xml.
 	 * @param urlrewrite Urlrewrite.xml.
 	 * @param root Root element of the urlrewrite.xml.
 	 * @param from From setting of the rule element.
 	 * @param to To setting of the rule element.
 	 * @return Updated rule element.
 	 */
 	private Element updateRule(Document urlrewrite,Element root,String from, String to)
 	{
 		Element ruleElem = XmlUtils.findFirstElement("/urlrewrite/rule[from='"+from+"']", root);
 
 		if ( ruleElem != null ) {
 			XmlUtils.findRequiredElement("to", ruleElem).setTextContent(to);
 		} else {
 			ruleElem = urlrewrite.createElement("rule");
 			Element toElem = urlrewrite.createElement("to");
 			toElem.setTextContent(to);
 			Element fromElem = urlrewrite.createElement("from");
 			fromElem.setTextContent(from);
 			ruleElem.appendChild(fromElem);
 			ruleElem.appendChild(toElem);
 			//Make sure that the surf rule will be placed in front of the existing rules.
 			Element firstChild = XmlUtils.findFirstElement("rule", root);
 			//root.appendChild(ruleElem);
 			root.insertBefore(urlrewrite.createTextNode("\n"), firstChild);
 			root.insertBefore(urlrewrite.createTextNode("\t"), firstChild);
 			root.insertBefore(ruleElem, firstChild);
 			root.insertBefore(urlrewrite.createTextNode("\n"), firstChild);
 		}
 
 		return ruleElem;
 	}
 
 	/**
 	 * Utility method for updating outbound rules of the urlrewrite.xml.
 	 * @param urlrewrite Urlrewrite.xml.
 	 * @param root Root element of the urlrewrite.xml.
 	 * @param from From setting of the outbound rule element.
 	 * @param to To setting of the outbound rule element.
 	 * @return Updated outbound rule element.
 	 */
 	private Element updateOutboundRule(Document urlrewrite,Element root,String from, String to)	{
 		Element ruleElem = XmlUtils.findFirstElement("/urlrewrite/outbound-rule[from='"+from+"']", root);
 
 		if ( ruleElem != null ) {
 			XmlUtils.findRequiredElement("to", ruleElem).setTextContent(to);
 		} else {
 			ruleElem = urlrewrite.createElement("outbound-rule");
 			Element toElem = urlrewrite.createElement("to");
 			toElem.setTextContent(to);
 			Element fromElem = urlrewrite.createElement("from");
 			fromElem.setTextContent(from);
 			ruleElem.appendChild(fromElem);
 			ruleElem.appendChild(toElem);
 			//Make sure that the surf out-bound rule be placed in front of the existing out-bound rules.
 			Element firstChild = XmlUtils.findFirstElement("outbound-rule", root);
 			//root.appendChild(ruleElem);
 			root.insertBefore(urlrewrite.createTextNode("\n"), firstChild);
 			root.insertBefore(urlrewrite.createTextNode("\t"), firstChild);
 			root.insertBefore(ruleElem, firstChild);
 			root.insertBefore(urlrewrite.createTextNode("\n"), firstChild);
 
 		}
 		return ruleElem;
 	}
 
 	/**
 	 * Installs the default Surf sample site (Roo included)
 	 */
 	public void installSurfSampleSite()
 	{
 		installSurfPackage(FILENAME_SURF_SAMPLE_SITE);
 	}
 
 	/**
 	 * Installs the Surf package with the given name into the
 	 * current web application
 	 *
 	 * @param packageName Package name.
 	 */
 	public void installSurfPackage(String packageName)
 	{
 		// TODO: make a call out to community.alfresco.com to
 		// see if the package exists remotely
 		boolean existsRemotely = false;
 
 		// default to doing a local installation
 		if (!existsRemotely)
 		{
 			// attempt to do a local installation
 			installSurfPackageLocal(packageName, true);
 		}
 	}
 
 	/**
 	 * Installs a Surf site package from a file path in the
 	 * current web application.
 	 *
 	 * @param zipFilePath the path to the file relative to the web application root
 	 * @param deleteOnFinish whether to delete the file when finished
 	 */
 	public void installSurfPackageLocal(String packageName, boolean deleteOnFinish)
 	{
 		Assert.hasText(packageName);
 
 		// assume the file name is <packageName>.zip
 		String sampleZipName = packageName + ".zip";
 		String sampleZipPath = pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, sampleZipName);
 
 		// unzip file to web app
 		try
 		{
 			if (fileManager.exists(sampleZipPath))
 			{
 				FileCopyUtils.copy(TemplateUtils.getTemplate(getClass(), sampleZipName), fileManager.updateFile(sampleZipPath).getOutputStream());
 			}
 			else
 			{
 				FileCopyUtils.copy(TemplateUtils.getTemplate(getClass(), sampleZipName), fileManager.createFile(sampleZipPath).getOutputStream());
 			}
 		}
 		catch (IOException e)
 		{
 			throw new IllegalStateException(e);
 		}
 		SurfUtils.unzip(fileManager, sampleZipPath, pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP,""));
 
 		// delete if we're told to do so
 		if (deleteOnFinish)
 		{
 			try {
 				fileManager.delete(sampleZipPath);
 			} catch (Exception e) {
 				throw new IllegalStateException(e);
 			}
 		}
 
 		fileManager.scan();
 	}
 
 
 	/**
 	 * Installs PHP template support into the Surf web application.
 	 */
 	public void installSurfPHP()
 	{
 		addPOMDependenciesFromFile(RELATIVE_PATH_PHP_DEPENDENCIES_TEMPLATE);
 	}
 
 	/**
 	 * Installs Groovy scripting support into the Surf web application.
 	 */
 	public void installSurfGroovy()
 	{
 		addPOMDependenciesFromFile(RELATIVE_PATH_GROOVY_DEPENDENCIES_TEMPLATE);
 	}
 
 	/**
 	 * Installs Web Studio into the Surf web application.
 	 */
 	public void installSurfStudio()
 	{
 		addPOMDependenciesFromFile(RELATIVE_PATH_WEBSTUDIO_DEPENDENCIES_TEMPLATE);
 	}
 
 	/**
 	 * Installs CMIS sample components for Surf.
 	 */
 	public void installSurfCmisSamples()
 	{
 		installSurfPackage(FILENAME_CMIS_SAMPLES);
 	}
 
 	/**
 	 * Installs Alfresco sample components for Surf.
 	 */
 	public void installSurfAlfrescoSamples()
 	{
 		installSurfPackage(FILENAME_ALFRESCO_SAMPLES);
 	}
 
 	/**
 	 * Injects additional dependencies into Maven's pom.xml file.
 	 *
 	 * @param filePath Dependency template file name.
 	 */
 	public void addPOMDependenciesFromFile(String filePath)
 	{
 		// load and parse the dependency file
 		Document dependencyDoc = getTemplateDocument(filePath);
 		Element dependenciesElement = dependencyDoc.getDocumentElement();
 
 		// Add add-on specific dependencies to pom.xml
 		List<Element> springDependencies = XmlUtils.findElements("/dependencies/surf/dependency", dependenciesElement);
 		for(Element dependency : springDependencies)
 		{
 			projectOperations.dependencyUpdate(new Dependency(dependency));
 		}
 
 		// Change package option in pom.xml to war.
 		projectOperations.updateProjectType(ProjectType.WAR);
 
 		// Current ProjectOperation class doesn't process dependency scope field nor type field (other that ZIP or JAR).
 		// The following is a patch which makes sure dependency type field and scope field get injected correctly. 
 		String pomPath = pathResolver.getIdentifier(Path.ROOT, RELATIVE_PATH_POM_XML);
 
 		Document pom = getXmlDocument(pomPath);
 		Element root = pom.getDocumentElement();
 
 		for(Element dependency : springDependencies)
 		{
 			// Dependency type field
 			if (dependency.hasChildNodes() && dependency.getElementsByTagName("type").getLength() > 0) {
 				String t = dependency.getElementsByTagName("type").item(0).getTextContent().trim().toUpperCase();
 				if (!t.equals("JAR") && !t.equals("ZIP")) {
 					String groupId    = dependency.getElementsByTagName("groupId").item(0).getTextContent().trim();
 					String artifactId = dependency.getElementsByTagName("artifactId").item(0).getTextContent().trim();
 					Element dependencyElem = XmlUtils.findFirstElement("/project/dependencies/dependency[groupId='"+groupId+"'][artifactId='"+artifactId+"']", root);
 					if ( dependencyElem != null) {
 						Node typeElem = dependencyElem.getElementsByTagName("type").item(0);
 						if (typeElem!=null) {
 							typeElem.setTextContent(t);
 						} else {
 							typeElem = pom.createElement("type");
 							typeElem.setTextContent(t);
 							dependencyElem.insertBefore(typeElem, dependencyElem.getLastChild());
 						}
 					}
 				}
 			}
 			// Dependency scope field
 			if (dependency.hasChildNodes() && dependency.getElementsByTagName("scope").getLength() > 0) {
 				String s = dependency.getElementsByTagName("scope").item(0).getTextContent().trim();
 				String groupId    = dependency.getElementsByTagName("groupId").item(0).getTextContent().trim();
 				String artifactId = dependency.getElementsByTagName("artifactId").item(0).getTextContent().trim();
 				Element dependencyElem = XmlUtils.findFirstElement("/project/dependencies/dependency[groupId='"+groupId+"'][artifactId='"+artifactId+"']", root);
 				if ( dependencyElem != null) {
 					Node scopeElem = dependencyElem.getElementsByTagName("scope").item(0);
 					if (scopeElem!=null) {
 						scopeElem.setTextContent(s);
 					} else {
 						scopeElem = pom.createElement("scope");
 						scopeElem.setTextContent(s);
 						dependencyElem.insertBefore(scopeElem, dependencyElem.getLastChild());
 					}
 				}
 			}
 		}
 
 		// Updates pom.xml.
 		updateXmlDocument(pomPath,pom);
 
 	}
 
 	/**
 	 * Utility method for copying a template file.
 	 * @param rootPath Root path of the destination file.
 	 * @param relativePath Relative path of the destination file.
 	 * @param forced True if the rewrite is enforced.
 	 * @return true if the file exists. false if the file doesn't exists.
 	 */
 	private boolean copySurfTemplate(Path rootPath,String relativePath,boolean forced) {
 
 		boolean fileExists = fileManager.exists(pathResolver.getIdentifier(rootPath, relativePath));
 
 		if (!fileExists  || forced )
 		{
 			try
 			{
 				FileCopyUtils.copy(TemplateUtils.getTemplate(getClass(), relativePath), fileManager.createFile(pathResolver.getIdentifier(rootPath, relativePath)).getOutputStream());
 			}
 			catch (IOException e)
 			{
 				new IllegalStateException("Encountered an error during copying of template "+relativePath, e);
 			}
 		}
 
 		return fileExists;
 
 	}
 
 	/**
 	 * Utility method for returning Document object of an XML file.
 	 * @param path Absolute path of the XML file.
 	 * @return XML document object.
 	 */
 	private Document getXmlDocument(String path) {
 		InputStream docInputStream = fileManager.getInputStream(path);
 		Document doc;
 		try {
 			doc = XmlUtils.getDocumentBuilder().parse(docInputStream);
 		} catch (Exception ex) {
 			throw new IllegalStateException("Failed to open XML document "+path,ex);
 		}
 		return doc;
 	}
 
 	/**
 	 * Utility method for returning Document object of a template file.
 	 * @param relativePath Relative path of the template file.
 	 * @return XML document object.
 	 */
 	private Document getTemplateDocument(String relativePath) {
 
 		InputStream templateInputStream = TemplateUtils.getTemplate(getClass(), relativePath);
 
 		Document doc;
 		try {
 			doc = XmlUtils.getDocumentBuilder().parse(templateInputStream);
 		} catch (Exception e) {
 			throw new IllegalStateException("Faile to open template document "+relativePath+e);
 		}
 		return doc;
 	}
 
 	/**
 	 * Utility method for updating an XML file with a Document object.
 	 * @param path
 	 * @param document
 	 */
 	private void updateXmlDocument(String path,Document document) {
 		MutableFile urlrewriteMutableFile = fileManager.updateFile(path);
 		XmlUtils.writeXml(urlrewriteMutableFile.getOutputStream(), document);
 		fileManager.scan();
 	}
 
 }