/**
    * 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.component;
  
  import java.io.File;
  import java.io.InputStream;
  import java.util.Hashtable;
  import java.util.SortedSet;
  import java.util.TreeSet;
  import java.util.logging.Logger;
  
  import org.springframework.roo.addon.surf.Constants;
  import org.springframework.roo.addon.surf.SurfOperations;
  import org.springframework.roo.addon.surf.page.PageOperations;
  import org.springframework.roo.addon.surf.region.RegionConfig;
  import org.springframework.roo.addon.surf.template.TemplateOperations;
  import org.springframework.roo.addon.surf.util.ComponentConfigUtils;
  import org.springframework.roo.addon.surf.util.SurfUtils;
  import org.springframework.roo.file.monitor.event.FileDetails;
  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.Path;
  import org.springframework.roo.project.PathResolver;
  import org.springframework.roo.project.ProjectOperations;
  import org.springframework.roo.support.lifecycle.ScopeDevelopment;
  import org.springframework.roo.support.util.Assert;
  import org.springframework.roo.support.util.TemplateUtils;
  import org.springframework.roo.support.util.XmlUtils;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  /**
   * Provides Surf component related operations.
   *
   * @author Yong Qu
   * @since 1.0
   */
  @ScopeDevelopment
  public class ComponentOperations {
  
  	Logger logger = Logger.getLogger(ComponentOperations.class.getName());
  
  	private FileManager fileManager;
  	private PathResolver pathResolver;
  	private MetadataService metadataService;
  	private ProjectOperations projectOperations;
  
  	private String surfComponentsRootPath;
  
  	private SurfOperations surfOperations;
  
  
  	/**
  	 * @param fileManager
  	 * @param pathResolver
  	 * @param metadataService
  	 * @param projectOperations
  	 */
  	public ComponentOperations(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;
  
  		this.surfOperations = new SurfOperations(fileManager, pathResolver, metadataService, projectOperations);
  		this.surfComponentsRootPath = pathResolver.getRoot(Path.SRC_MAIN_WEBAPP) + "/"+Constants.SURF_SITEDATA_COMPONENT_CP;
  
  	}
  
  	/**
  	 * Checks if Surf component related operations are available.
  	 * @return true if Surf component related operations are available.
  	 */
  	public boolean isSurfComponentOperationsAvailable() {
  		return surfOperations.isManageSurfAvailable();
  	}
  
 	/**
 	 * Returns list of global scoped Surf components.
 	 * @return List of global scoped Surf components.
 	 */
 	public SortedSet<String> listGlobalScopedSurfComponents() {
 
 		String antPath = (surfComponentsRootPath+"*.xml").replace("/", File.separator);
 		SortedSet<FileDetails> entries = fileManager.findMatchingAntPath(antPath);
 		SortedSet<String> componentList = new TreeSet<String>();
 
 		// Global-scope components.
 		for (FileDetails fileIdentifier : entries) {
 			Document componentDoc = SurfUtils.getSurfXMLDoc(fileManager, fileIdentifier);
 			Element componentElem = ComponentConfigUtils.getComponentElem( componentDoc);
 			if (componentElem != null )
 				componentList.add("Scope:"+Constants.SURF_SCOPE_GLOBAL+" "+ComponentConfigUtils.componentToString(componentElem));
 		}
 
 		return componentList;
 	}	
 
 	/**
 	 * List of page scoped Surf components.
 	 * @param pageId Page id.
 	 * @return List of page scoped Surf components.
 	 */
 	public SortedSet<String> listPageScopedSurfComponents(String pageId) {
 
 		SortedSet<String> componentList = new TreeSet<String>();
 
 		// Page-scope components.
 		PageOperations pageOperations = new PageOperations(fileManager, pathResolver, metadataService, projectOperations);
 		for (FileDetails page:pageOperations.getSurfPages().values()) {
 
 			Document pageDoc = SurfUtils.getSurfXMLDoc(fileManager, page);
 			String componentPageId = XmlUtils.findFirstElementByName("id", (Element) pageDoc.getFirstChild()).getTextContent();
 
 			for (Element componentElem : ComponentConfigUtils.getComponentsElems(pageDoc)) {
 				if ( pageId == null || pageId.equals("")) {
 					componentList.add("Scope:"+Constants.SURF_SCOPE_PAGE+" Page Id:"+componentPageId+" "+ComponentConfigUtils.componentToString(componentElem));					
 				} else if (pageId.equals(componentPageId) ) {
 					componentList.add("Scope:"+Constants.SURF_SCOPE_PAGE+" Page Id:"+componentPageId+" "+ComponentConfigUtils.componentToString(componentElem));
 				}
 			}
 		}		
 
 		return componentList;
 	}	
 
 	/**
 	 * Returns list of template scoped Surf component.
 	 * @param templateId Template id.
 	 * @return List of template scoped Surf component.
 	 */
 	public SortedSet<String> listTemplateScopedSurfComponents(String templateId) {
 
 		SortedSet<String> componentList = new TreeSet<String>();
 
 		// Page-scope components.
 		TemplateOperations templateOperations = new TemplateOperations(fileManager, pathResolver, metadataService, projectOperations);
 		for (FileDetails template:templateOperations.getSurfTemplateInstances().values()) {
 
 			Document templateDoc = SurfUtils.getSurfXMLDoc(fileManager, template);
 			String componentTemplateId = XmlUtils.findFirstElementByName("id", (Element) templateDoc.getFirstChild()).getTextContent();
 
 			for (Element componentElem : ComponentConfigUtils.getComponentsElems(templateDoc)) {
 				if ( templateId ==null || templateId.equals("")) {
 					componentList.add("Scope:"+Constants.SURF_SCOPE_TEMPLATE+" Template Id:"+componentTemplateId+" "+ComponentConfigUtils.componentToString(componentElem));					
 				} else if ( templateId.equals(componentTemplateId)) {
 					componentList.add("Scope:"+Constants.SURF_SCOPE_TEMPLATE+" Template Id:"+componentTemplateId+" "+ComponentConfigUtils.componentToString(componentElem));
 				}
 			}
 		}		
 
 		return componentList;
 	}	
 
 	/**
 	 * Returns all available components.
 	 * @param scopeId Component scope.
 	 * @param pageId Page id.
 	 * @param templateId Template id.
 	 * @return List of components.
 	 */
 	public SortedSet<String> listSurfComponents(String scopeId,String pageId,String templateId) {
 
 		SortedSet<String> componentList = new TreeSet<String>();
 
 		if (pageId != null && !pageId.equals("")){
 			// Page-scope components.
 			componentList.addAll(listPageScopedSurfComponents(pageId));			
 		} else if (templateId != null && !templateId.equals("")) {
 			// Template-scope components.
 			componentList.addAll(listTemplateScopedSurfComponents(templateId));			
 		} else if (scopeId != null && scopeId.equals(Constants.SURF_SCOPE_GLOBAL)) {
 			// Global-scope components.
 			componentList.addAll(listGlobalScopedSurfComponents());			
 		} else if (scopeId != null && scopeId.equals(Constants.SURF_SCOPE_PAGE)) {
 			// Page-scope components.
 			componentList.addAll(listPageScopedSurfComponents(pageId));
 		} else if (scopeId != null && scopeId.equals(Constants.SURF_SCOPE_TEMPLATE)) {
 			// Template-scope components.
 			componentList.addAll(listTemplateScopedSurfComponents(templateId));			
 		} else {
 			// Global-scope components.
 			componentList.addAll(listGlobalScopedSurfComponents());
 			// Page-scope components.
 			componentList.addAll(listPageScopedSurfComponents(pageId));
 			// Template-scope components.
 			componentList.addAll(listTemplateScopedSurfComponents(templateId));
 		}
 		return componentList;
 	}
 	/**
 	 * Returns list of all available component types.
 	 * @return List of component types.
 	 */
 	public SortedSet<String> listSurfComponentTypes() {
 
 		String surfComponentsRootPath = pathResolver.getRoot(Path.SRC_MAIN_WEBAPP)+"/"+Constants.WEB_INF+"/";
 		String antPath = surfComponentsRootPath+"**/*.desc.xml";
 		antPath = antPath.replace("/", File.separator);
 
 		SortedSet<FileDetails> entries = fileManager.findMatchingAntPath(antPath);
 		SortedSet<String> componentList = new TreeSet<String>();
 
 		for (FileDetails fileIdentifier : entries) {
 			InputStream templateInstanceInputStream = fileManager.getInputStream(fileIdentifier.getCanonicalPath());
 			Document pom;
 			try {
 				pom = XmlUtils.getDocumentBuilder().parse(templateInstanceInputStream);
 			} catch (Exception ex) {
 				throw new IllegalStateException(ex);
 			}
 			Element rootElement = (Element) pom.getFirstChild();
 			//Element familyElement = XmlUtils.findFirstElementByName("family", rootElement);
 
 			//if ( familyElement != null ) {
 			//if ( familyElement.getTextContent().equals("component") ) {
 			Element urlElement = XmlUtils.findFirstElementByName("url", rootElement);
 			if ( urlElement != null) {
 				componentList.add(urlElement.getTextContent());
 			}
 			//}
 			//}
 
 			try {
 				templateInstanceInputStream.close();
 			} catch (Exception ex) {
 				throw new IllegalStateException(ex);
 			}
 
 		}
 
 		return componentList;
 	}
 
 	/**
 	 * Checks if a Surf component exists or not.
 	 * @param componentId Component id.
 	 * @return True if it exists. False if it doesn't.
 	 */
 	public boolean isSurfComponentAvailable(String componentId) {
 		SortedSet<String> componentList = listSurfComponents(null,null,null);
 		return componentList.contains(componentId);
 	}
 
 	/**
 	 * Checks if the component type is available.
 	 * @param componentPath Component path .
 	 * @return True if it exists. False if it doesn't.
 	 */
 	public boolean isSurfComponentTypeAvailable(String componentPath) {
 		SortedSet<String> componentList = listSurfComponentTypes();
 		return componentList.contains(componentPath);
 	}
 
 	/**
 	 * Creates a new component.
 	 * @param pageId Page id.
 	 * @param templatePath Path of the template used for creating component.
 	 * @param regionId Region id.
 	 * @param componentType Component type.
 	 * @param options Additional options.
 	 */
 	public void createComponent(String pageId, String regionId, String componentType, String options) {
 		Assert.hasText(pageId, "Page name required");
 		Assert.hasText(regionId, "Region id required");
 		Assert.hasText(componentType, "Component url required");
 
 		PageOperations pageOperations = new PageOperations(fileManager, pathResolver, metadataService, projectOperations);
 
 		FileDetails pageXml = pageOperations.findSurfPageById(pageId);
 		if ( pageXml == null) {
 			logger.warning("Page "+pageId+" doesn't exist.");
 			return;
 		}
 		String templatePath = pageOperations.getTemplatePath(pageId);
 		if ( templatePath ==null || templatePath.equals("")) {
 			logger.warning("Can't find template for page "+pageId);
 			return;
 		}
 
 		// Check if the template exists.
 		TemplateOperations templateOperations = new TemplateOperations(fileManager, pathResolver, metadataService, projectOperations);
 
 		if ( templateOperations.findSurfTemplateByPath(templatePath) == null ) {
 			logger.warning("Template "+templatePath+" doesn't exist");
 			logger.warning("Available Templates:");
 			logger.warning(""+templateOperations.listSurfTemplates());
 			return;
 		}
 		// Check if the region exists.
 		Hashtable<String,RegionConfig> regionList = templateOperations.listSurfTemplateRegions(templatePath);
 		if ( ! regionList.containsKey(regionId) ) {
 			logger.warning("Region "+regionId+" doesn't exist");
 			logger.warning("Available Regions:");
 			logger.warning(""+regionList.values());
 			return;
 		}
 		// Check if the component type exists.
 		/*
 		SortedSet<String> componentTypes = listSurfComponentTypes();
 		if ( ! componentTypes.contains(componentType) ) {
 			logger.warning("Component Type "+componentType+" doesn't exist");
 			logger.warning("Available Component Types:");
 			logger.warning(""+componentTypes);
 			return;
 		}
 		 */
 		RegionConfig regionConfig = regionList.get(regionId);
 
 		String scope = regionConfig.getScope();
 
 		String componentInstanceName = "";
 		String sourceId ="";
 		InputStream componentInstanceInputStream;
 
 		if ( scope.equals("global") ) {
 			componentInstanceName = "global."+regionId;
 			sourceId ="global";
 			logger.warning(componentInstanceName);
 			//Find component template and fill up the xml file.
 			String componentInstanceXmlFilename = Constants.SURF_SITEDATA_COMPONENT_CP+componentInstanceName+".xml";
 			if (fileManager.exists(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, componentInstanceXmlFilename))) {
 				//file exists, so nothing to do
 				logger.warning("Component "+componentInstanceXmlFilename+" exists. Nothing will be created.");
 				return;
 			}
 			componentInstanceInputStream = TemplateUtils.getTemplate(getClass(), "component-template.xml");
 
 			Document pom;
 			try {
 				pom = XmlUtils.getDocumentBuilder().parse(componentInstanceInputStream);
 			} catch (Exception ex) {
 				throw new IllegalStateException(ex);
 			}
 
 			Element rootElement = (Element) pom.getFirstChild();
 			XmlUtils.findFirstElementByName("guid", rootElement).setTextContent(componentInstanceName);
 			XmlUtils.findFirstElementByName("title", rootElement).setTextContent(componentInstanceName);
 			XmlUtils.findFirstElementByName("description", rootElement).setTextContent(componentInstanceName);
 			XmlUtils.findFirstElementByName("url", rootElement).setTextContent(componentType);
 			XmlUtils.findFirstElementByName("scope", rootElement).setTextContent(scope);
 			XmlUtils.findFirstElementByName("source-id", rootElement).setTextContent(sourceId);
 			XmlUtils.findFirstElementByName("region-id", rootElement).setTextContent(regionId);
 
 			MutableFile mutableFile = fileManager.createFile(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, componentInstanceXmlFilename));
 			XmlUtils.writeXml(mutableFile.getOutputStream(), pom);
 
 			fileManager.scan();
 
 		} else if ( scope.equals("template") ){
 			String templateInstanceName = pageOperations.getTemplateInstance(pageId);
 			if ( templateInstanceName.equals("") ) {
 				logger.warning("Can't file template instance for template scope component");
 				return;
 			} else {
 				FileDetails templateInstanceXml = templateOperations.findSurfTemplateInstanceByName(templateInstanceName);
 				componentInstanceInputStream = fileManager.getInputStream(templateInstanceXml.getCanonicalPath());
 				Document pom;
 				try {
 					pom = XmlUtils.getDocumentBuilder().parse(componentInstanceInputStream);
 				} catch (Exception ex) {
 					throw new IllegalStateException(ex);
 				}
 				ComponentConfigUtils.updateComponentConfig(pom, regionId, componentType);
 				MutableFile mutableFile = fileManager.updateFile(templateInstanceXml.getCanonicalPath());
 				XmlUtils.writeXml(mutableFile.getOutputStream(), pom);
 
 				fileManager.scan();
 			}
 		} else if (scope.equals("page") ) {
 			componentInstanceInputStream = fileManager.getInputStream(pageXml.getCanonicalPath());
 			Document pom;
 			try {
 				pom = XmlUtils.getDocumentBuilder().parse(componentInstanceInputStream);
 			} catch (Exception ex) {
 				throw new IllegalStateException(ex);
 			}
 			ComponentConfigUtils.updateComponentConfig(pom, regionId, componentType);
 			MutableFile mutableFile = fileManager.updateFile(pageXml.getCanonicalPath());
 			XmlUtils.writeXml(mutableFile.getOutputStream(), pom);
 			fileManager.scan();
 		} else {
 			logger.warning("Unsupported scope type "+scope);
 			return;
 		}
 
 		if ( options!=null && ! options.equals("") ) {
 			// Do something with the options
 		}
 
 		return;
 	}
 	/**
 	 * Adds a new resource to the component configuration xml.
 	 * The format of attribute list looks like attr1:val1|attr2:val2|attr3:val3 .
 	 * @param componentName Component name.
 	 * @param attributeList List of attributes for the new resource.
 	 * @param contentBody Resource text content.
 	 */
 	public void createComponentResource(String componentName,String attributeList, String contentBody) {
 		Assert.hasText(componentName, "Component instance name required");
 		Assert.hasText(contentBody, "Content body required");
 		if (!isSurfComponentAvailable(componentName)){
 			logger.warning("Component "+componentName+" doesn't exist");
 		}
 		//Get hold of the content instance xml file.
 		String componentInstanceXmlFilename = Constants.SURF_SITEDATA_COMPONENT_CP+componentName+".xml";
 
 		InputStream componentInstanceInputStream = fileManager.getInputStream(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, componentInstanceXmlFilename));
 		Document pom;
 		try {
 			pom = XmlUtils.getDocumentBuilder().parse(componentInstanceInputStream);
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 		Element rootElement = (Element) pom.getFirstChild();
 
 		Element resourcesElement = XmlUtils.findFirstElementByName("resources", rootElement);
 		if (resourcesElement == null ) {
 			resourcesElement = pom.createElement("resources");
 			rootElement.appendChild(resourcesElement);
 		}
 
 		Element newResourceElement = pom.createElement("resource");
 		if (attributeList!=null && !attributeList.equals("")) {
 			Hashtable<String,String> attrList = parseAttributeList (attributeList);
 			for (String key : attrList.keySet() ) {
 				newResourceElement.setAttribute(key, attrList.get(key));
 			}
 		}
 
 		newResourceElement.setTextContent(contentBody);
 
 		resourcesElement.appendChild(newResourceElement);
 
 		MutableFile mutableFile = fileManager.updateFile(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, componentInstanceXmlFilename));
 		XmlUtils.writeXml(mutableFile.getOutputStream(), pom);
 
 		fileManager.scan();
 
 		try {
 			componentInstanceInputStream.close();
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 		return;
 	}
 
 	/**
 	 * Adds new properties to the component configuration xml.
 	 * The format of input string looks like name1:val1|name2:val2|name3:val3 .
 	 * @param componentName Component name.
 	 * @param propertyList List of new properties.
 	 */
 	public void createComponentProperty(String componentName,String propertyList) {
 		Assert.hasText(componentName, "Component instance name required");
 		Assert.hasText(propertyList, "Property list required");
 		if (!isSurfComponentAvailable(componentName)){
 			logger.warning("Component "+componentName+" doesn't exist");
 		}
 		//Get hold of the content instance xml file.
 		String componentInstanceXmlFilename = Constants.SURF_SITEDATA_COMPONENT_CP+componentName+".xml";
 
 		InputStream componentInstanceInputStream = fileManager.getInputStream(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, componentInstanceXmlFilename));
 		Document pom;
 		try {
 			pom = XmlUtils.getDocumentBuilder().parse(componentInstanceInputStream);
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 		Element rootElement = (Element) pom.getFirstChild();
 
 		Element propertiesElement = XmlUtils.findFirstElementByName("properties", rootElement);
 		if (propertiesElement == null ) {
 			propertiesElement = pom.createElement("properties");
 			rootElement.appendChild(propertiesElement);
 		}
 
 		if (propertyList!=null && !propertyList.equals("")) {
 			Hashtable<String,String> propList = parseAttributeList (propertyList);
 			for (String key : propList.keySet() ) {
 				Element newPropElement = pom.createElement(key);
 				newPropElement.setTextContent(propList.get(key));
 				propertiesElement.appendChild(newPropElement);
 			}
 		}
 
 		MutableFile mutableFile = fileManager.updateFile(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, componentInstanceXmlFilename));
 		XmlUtils.writeXml(mutableFile.getOutputStream(), pom);
 
 		fileManager.scan();
 		return;
 	}
 
 	/**
 	 * Returns component name.
 	 * @param pageInstanceName Page instance name.
 	 * @param templateInstanceName Template instance name.
 	 * @param regionId Region id.
 	 * @param scope Region scope.
 	 * @return Component name.
 	 */
 	public String getComponentInstanceName(String pageInstanceName, String templateInstanceName,String regionId, String scope) {
 
 		String componentInstanceName = "";
 
 		if ( scope.equals("global") ) {
 			componentInstanceName = "global."+regionId;
 		} else if ( scope.equals("template") ){
 			if ( templateInstanceName.equals("") ) {
 				logger.warning("For template scope component, you must specify template instance name");
 				return null;
 			} else {
 				componentInstanceName = "template."+regionId+"."+templateInstanceName;
 			}
 		} else if (scope.equals("page") ) {
 			if ( pageInstanceName == null || templateInstanceName.equals("") ) {
 				logger.warning("For page scope component, you must specify page name");
 				return null;
 			} else {
 				componentInstanceName = "page."+regionId+"."+pageInstanceName;
 			}
 		} else {
 			logger.warning("Unsupported scope type "+scope);
 			return null;
 		}
 
 		return componentInstanceName;
 	}
 
 	/**
 	 * Returns component url.
 	 * @param instanceName Component instance.
 	 * @return Component url.
 	 */
 	public String getComponentUrl(String instanceName){
 		//Get hold of the content instance xml file.
 		String componentInstanceXmlFilename = Constants.SURF_SITEDATA_COMPONENT_CP+instanceName+".xml";
 
 		String 	componentInstanceXmlFilePath = pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, componentInstanceXmlFilename);
 		if (!fileManager.exists(componentInstanceXmlFilePath))
 			return null;
 		InputStream componentInstanceInputStream = fileManager.getInputStream(componentInstanceXmlFilePath);
 		Document doc;
 		try {
 			doc = XmlUtils.getDocumentBuilder().parse(componentInstanceInputStream);
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 		Element rootElement = (Element) doc.getFirstChild();
 		if ( rootElement!=null ) {
 			return XmlUtils.findFirstElementByName("url", rootElement).getTextContent();
 		}else{
 			return null;
 		}
 	}
 
 	/**
 	 * Utility method for parsing attribute list.
 	 * @param attributeStr Attribute list string.
 	 * @return List of attributes.
 	 */
 	private Hashtable<String,String> parseAttributeList (String attributeStr) {
 		// Input string looks like attr1:value1|attr2:value2
 		Hashtable<String,String> attributeList = new Hashtable<String,String>();
 		for (String pair : attributeStr.split("\\|")) {
 			if (pair.indexOf(":") != -1) {
 				String[] temp = pair.split(":",2);
 				if (temp[1].startsWith("\"") && temp[1].endsWith("\""))
 					temp[1]=temp[1].substring(1,temp[1].length()-1);
 				attributeList.put(temp[0].trim(),temp[1].trim());
 			}
 		}
 		return attributeList;
 	}
 }