/**
    * 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.page;
  
  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.template.TemplateOperations;
  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 Page related operations.
   *
   * @author Yong Qu
   * @since 1.0
   */
  @ScopeDevelopment
  public class PageOperations {
  
  	Logger logger = Logger.getLogger(PageOperations.class.getName());
  
  	private FileManager fileManager;
  	private PathResolver pathResolver;
  	private MetadataService metadataService;
  	private ProjectOperations projectOperations;
  
  	private SurfOperations surfOperations;
  	private String pageXmlRootPath;
  
  	/**
  	 * @param fileManager
  	 * @param pathResolver
  	 * @param metadataService
  	 * @param projectOperations
  	 */
  	public PageOperations(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.pageXmlRootPath = pathResolver.getRoot(Path.SRC_MAIN_WEBAPP) + "/"+Constants.WEB_INF;
  	}
  
  
  
  	/**
  	 * Checks if page related operations are available.
  	 * @return true if page related operations are available
  	 */
  	public boolean isPageOperationAvailable() {
  		return surfOperations.isManageSurfAvailable();
  	}
  
  	/**
  	 * Creates a new Surf page using a specified template instance or template.
  	 * @param pageId Page Id.
  	 * @param pagePath Page path.
 	 * @param templateInstance Name of the template instance for creating the new page.
 	 * @param templatePath Path of the template for creating the new page.
 	 * @param urls Page urls.
 	 * @param title Page title.
 	 */
 	public void createPage(String pageId, String pagePath, String templateInstance,String templatePath,String urls,String title) {
 
 		Assert.hasText(pageId, "Page id required.");
 		Assert.hasText(pagePath, "Page path required.");
 
 		// Get the full path.
 		if (pagePath.equals("pages")) {
 			pagePath = pagePath+File.separator+pageId+File.separator+pageId;
 		} else {
 			pagePath = pagePath+File.separator+pageId;
 		}
 		
 		// This will make sure the user input path will be valid.
 		pagePath = pagePath.replace("/", File.separator).replace("\\", File.separator);
 		
 		// Get template name from template path
 		String templateName = SurfUtils.getNameFromPath(templatePath);
 
 		// Check if the page with same path exists
 		if (this.findSurfPageByPath(pagePath) != null) {
 			//file exists, so nothing to do
 			logger.warning("Page with path "+pagePath+" exists. Please select different path.");
 			return;
 		}
 
 		// Check if the page with same id exists
 		if (this.findSurfPageById(pageId) != null) {
 			//file exists, so nothing to do
 			logger.warning("Page with id "+pageId+" exists. Please select different id.");
 			return;
 		}
 
 		TemplateOperations templateOperations = new TemplateOperations(fileManager, pathResolver, metadataService, projectOperations);
 
 		// Check if the page will be created from template instance.
 		if ( templateInstance != null && !templateInstance.equals("")) {
 			if (templateOperations.findSurfTemplateInstanceByName(templateInstance) == null) {
 				// Template instance doesn't exist. Do a check on the template path input.
 				if ( templatePath!= null && !templatePath.equals("") ) {
 					// Check if the template exists.
 					if ( templateOperations.findSurfTemplateByPath(templatePath) != null ) {
 						// Template exists. Let us figure out where to put that template instance.
 						// Template instance will be placed in the template directory.
 						// For instance name, if the templateInstance is set, we will use that as the name.
 						// Otherwise, the template name will be used.
 						String templateInstancePath = templatePath;
 						if ( templateInstance != null && !templateInstance.equals("")){
 							templateInstancePath = SurfUtils.getRelativePath(templatePath);
 							logger.warning(templateInstancePath);
 						}
 						if (templateOperations.newTemplateInstance(templateInstance,templateInstancePath, templatePath)) {
 							// We are good. New template instance is created.
 							logger.warning("Template instance created.");
 						} else {
 							// We failed to create the instance.
 							logger.warning("No new template instance will be created. Existing template instance will be used.");
 						}
 					}
 				} else {
 					logger.warning("Either a template instance or a template needs to be provided.");
 					return;
 				}
 			}
 		} else {
 			// Template instance doesn't exist. Do a check on the template path input.
 			if ( templatePath!= null && !templatePath.equals("") ) {
 				// Check if template exists.
 				if ( templateOperations.findSurfTemplateByPath(templatePath) != null ) {
 					// Template exists. Let us figure out where to put that template instance.
 					// Template instance will be placed in the template directory.
 					// For instance name, if the templateInstance is set, we will use that as the name.
 					// Otherwise, the template name will be used.
 					String templateInstancePath = templatePath;
 					if ( templateInstance != null && !templateInstance.equals("")){
 						templateInstancePath = SurfUtils.getRelativePath(templatePath);
 						logger.warning(templateInstancePath);
 					} else {
 						templateInstance = templateName;
 					}
 					if (templateOperations.newTemplateInstance(templateInstance,templateInstancePath, templatePath)) {
 						// We are good. New template instance is created.
 						logger.warning("New template instance created.");
 					} else {
 						// We failed to create the instance.
 						logger.warning("No new template instance will be created. Existing template instance will be used.");
 					}
 				} else {
 					logger.warning("Template "+templatePath+" doesn't exist.");
 					return;
 				}
 			} else {
 				logger.warning("Either template instance or template needs to be provided.");
 				return;
 			}
 		}
 
 		String pageXmlFilename = Constants.WEB_INF+pagePath+".xml";
 		InputStream templateInputStream = TemplateUtils.getTemplate(getClass(), "page-template.xml");
 		Document page;
 		try {
 			page = XmlUtils.getDocumentBuilder().parse(templateInputStream);
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 		Element rootElement = (Element) page.getFirstChild();
 		XmlUtils.findFirstElementByName("template-instance", rootElement).setTextContent(templateInstance);
 
 		if (title!=null && !title.equals("")){
 			XmlUtils.findFirstElementByName("title", rootElement).setTextContent(title);
 		} else {
 			XmlUtils.findFirstElementByName("title", rootElement).setTextContent(pageId);			
 		}
 
 		XmlUtils.findFirstElementByName("id", rootElement).setTextContent(pageId);
 
 		//Process urls.
 		if ( urls!= null && !urls.equals("")) {
 			for (String url : urls.split(";|,|\\s+|\\|")) {
 				Element urlElem = page.createElement("url");
 				urlElem.setTextContent(url);
 				rootElement.appendChild(urlElem);
 			}
 		}
 
 		MutableFile mutableFile = fileManager.createFile(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, pageXmlFilename));
 		XmlUtils.writeXml(mutableFile.getOutputStream(), page);
 		fileManager.scan();
 
 		try {
 			templateInputStream.close();
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 	}
 
 	/**
 	 * Returns ids and paths of all Surf pages.
 	 * @return Id/path list of all Surf pages..
 	 */
 	public SortedSet<String> listSurfPages() {
 
 		SortedSet<String> pageInfoList = new TreeSet<String>();
 
 		for (String pageId : getSurfPages().keySet()) {
 			StringBuffer sb = new StringBuffer();
 			sb.append("Id: ");
 			sb.append(pageId);
 			sb.append(" Path: ");
 			sb.append( getSurfPages().get(pageId).getFile().getPath().substring(pageXmlRootPath.length()));
 			pageInfoList.add(sb.toString());
 		}
 
 		return pageInfoList;
 	}
 
 	/**
 	 * Returns true if the page id is available.
 	 * @param pageId Page Id.
 	 * @return True if the page id is available.
 	 */
 	public boolean isSurfPageAvailable(String pageId) {
 		return getSurfPages().containsKey(pageId);
 	}
 
 	/**
 	 * Lists associated pages of a specified Surf page.
 	 * @param pageId Page id.
 	 * @return Lists of associated pages.
 	 */
 	public SortedSet<String> listSurfPageAssociations(String pageId) {
 
 		SortedSet<String> pageAssocsList = new TreeSet<String>();
 		FileDetails page = this.findSurfPageById(pageId);
 		Document pageDoc = SurfUtils.getSurfXMLDoc(fileManager, page);
 
 		for (Element assocElem : XmlUtils.findElements("/page/associations/page-association", pageDoc.getDocumentElement()) ) {
 
 			StringBuffer sb = new StringBuffer();
 
 			Element descIdElem = XmlUtils.findFirstElementByName("dest-id", assocElem);
 			if ( descIdElem != null ) {
 				sb.append("Page: ");
 				sb.append(descIdElem.getTextContent().trim());
 			}
 
 			Element typeElem = XmlUtils.findFirstElementByName("assoc-type", assocElem);
 			if ( typeElem != null ) {
 				sb.append(" Type: ");
 				sb.append(typeElem.getTextContent().trim());
 				pageAssocsList.add(sb.toString());
 			}
 		}
 
 		return pageAssocsList;
 	}
 
 	/**
 	 * Returns template instance path of a given page.
 	 * @param pagePath Page path.
 	 * @return Template instance path.
 	 */
 	public String getTemplateInstance(String pageName) {
 		Assert.hasText(pageName, "Page path required");
 
 		FileDetails pageXml = findSurfPageById(pageName);
 		if ( pageXml == null) {
 			logger.warning("Page "+pageName+" doesn't exist.");
 			return null;
 		}
 
 		InputStream pageInputStream = fileManager.getInputStream(pageXml.getCanonicalPath());
 		Document pom;
 		try {
 			pom = XmlUtils.getDocumentBuilder().parse(pageInputStream);
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 		Element rootElement = (Element) pom.getFirstChild();
 		String templateInstanceName = XmlUtils.findFirstElementByName("template-instance", rootElement).getTextContent();
 
 		try {
 			pageInputStream.close();
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 		return templateInstanceName;
 
 	}
 
 	/**
 	 * Returns template path of the given template instance.
 	 * @param instanceName Template instance name.
 	 * @return Template path.
 	 */
 	public String getInstanceTemplatePath(String instanceName) {
 		// Locate page instance
 		String surfTemplatesRootPath = pathResolver.getRoot(Path.SRC_MAIN_WEBAPP) + "/"+Constants.WEB_INF;
 		String antPath = (surfTemplatesRootPath+"**/"+instanceName+".xml").replace("/", File.separator);
 
 		SortedSet<FileDetails> entries = fileManager.findMatchingAntPath(antPath);
 
 		if (entries.size() == 0 ) {
 			return null;
 		} else {
 
 			Document pom;
 
 			InputStream templateInstanceInputStream = fileManager.getInputStream(entries.first().getCanonicalPath());
 			try {
 				pom = XmlUtils.getDocumentBuilder().parse(templateInstanceInputStream);
 			} catch (Exception ex) {
 				throw new IllegalStateException(ex);
 			}
 
 			Element rootElement = (Element) pom.getFirstChild();
 			String templateName = XmlUtils.findFirstElementByName("template-type", rootElement).getTextContent();
 
 			try {
 				templateInstanceInputStream.close();
 			} catch (Exception ex) {
 				throw new IllegalStateException(ex);
 			}
 
 			return templateName;
 		}
 	}
 
 	/**
 	 * Returns template path of a Surf page with a given id.
 	 * @param pageId Page Id.
 	 * @return Page template path.
 	 */
 	public String getTemplatePath(String pageId) {
 		String instanceName = this.getTemplateInstance(pageId);
 		if ( instanceName == null ) {
 			return null;
 		} else {
 			return this.getInstanceTemplatePath(instanceName);
 		}
 	}
 
 	/**
 	 * Creates a new legacy page association which is stored as a seperated XML file.
 	 * @param name Association name.
 	 * @param srcPageId Source page id.
 	 * @param desPageId Destination page id.
 	 * @param type Association type.
 	 */
 	public void createPageAssociationAsFile(String name, String srcPageId, String desPageId,String type) {
 
 		Assert.hasText(srcPageId, "Source page id required");
 		Assert.hasText(desPageId, "Destination page id required");
 
 		if ( name==null || name.equals("")) {
 			name = srcPageId+"-"+desPageId;
 		}
 
 		String pageAssocXmlFilename = Constants.SURF_SITEDATA_PAGE_ASSOC_CP+name+".xml";
 
 		if (fileManager.exists(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, pageAssocXmlFilename))) {
 			//file exists, so nothing to do
 			logger.warning("Page association "+pageAssocXmlFilename+" exists.");
 			return;
 		}
 
 		InputStream templateInstanceInputStream = TemplateUtils.getTemplate(getClass(), "page-association-template.xml");
 		Document pom;
 		try {
 			pom = XmlUtils.getDocumentBuilder().parse(templateInstanceInputStream);
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 
 		Element rootElement = (Element) pom.getFirstChild();
 		XmlUtils.findFirstElementByName("source-id", rootElement).setTextContent(srcPageId);
 		XmlUtils.findFirstElementByName("dest-id", rootElement).setTextContent(desPageId);
 		XmlUtils.findFirstElementByName("assoc-type", rootElement).setTextContent(type);
 
 		MutableFile mutableFile = fileManager.createFile(pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, pageAssocXmlFilename));
 		XmlUtils.writeXml(mutableFile.getOutputStream(), pom);
 
 		fileManager.scan();
 
 		try {
 			templateInstanceInputStream.close();
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 	}
 
 	/**
 	 * Creates a new page association.
 	 * @param name Association name.
 	 * @param srcPageId Source page id.
 	 * @param desPageId Destination page id.
 	 * @param type Association type.
 	 */
 	public void createPageAssociation(String name, String srcPageId, String desPageId,String type) {
 
 		Assert.hasText(srcPageId, "Source page id required");
 		Assert.hasText(desPageId, "Destination page id required");
 
 		FileDetails srcPage = this.findSurfPageById(srcPageId);
 		if (srcPage ==null) {
 			logger.warning("Source Page "+srcPageId+" doesn't exist.");
 		} else {
 			Document pageDoc = SurfUtils.getSurfXMLDoc(fileManager, srcPage);
 			Element assocElem = XmlUtils.findFirstElement("/page/associations/page-association[dest-id='"+desPageId+"']",pageDoc.getDocumentElement());
 			FileDetails destPage = this.findSurfPageById(desPageId);
 			if (destPage == null) {
 				logger.warning("Destination Page "+desPageId+" doesn't exist.");
 			} else {
 				if (assocElem != null) {
 					logger.warning("The association exists.");
 				} else {
 					Element assocsElem = XmlUtils.findFirstElement("/page/associations",pageDoc.getDocumentElement());
 					if (assocsElem == null) {
 						assocsElem = pageDoc.createElement("associations");
 						pageDoc.getFirstChild().appendChild(assocsElem);
 					}
 					assocElem = pageDoc.createElement("page-association");
 					Element destIdElem = pageDoc.createElement("dest-id");
 					destIdElem.setTextContent(desPageId);
 					Element typeElem = pageDoc.createElement("assoc-type");
 					typeElem.setTextContent(type);
 					assocElem.appendChild(destIdElem);
 					assocElem.appendChild(typeElem);
 					assocsElem.appendChild(assocElem);
 					XmlUtils.writeXml(fileManager.updateFile(srcPage.getCanonicalPath()).getOutputStream(), pageDoc);
 					fileManager.scan();
 				}
 			}
 		}
 
 	}
 	/**
 	 * Find Surf page by path.
 	 * @param path Page path.
 	 * @return Surf page.
 	 */
 	public FileDetails findSurfPageByPath(String path) {
 		String antPath = (this.pageXmlRootPath+path+".xml").replace("/", File.separator);
 		SortedSet<FileDetails> entries = fileManager.findMatchingAntPath(antPath);
 		if (entries.size()==0 ){
 			//Also check the legacy directory for Surf pages.
 			String surfTemplatesRootPath = pathResolver.getRoot(Path.SRC_MAIN_WEBAPP) + "/" + Constants.SURF_SITEDATA_PAGE_CP;
 			antPath = (surfTemplatesRootPath+path+".xml").replace("/", File.separator);
 			entries = fileManager.findMatchingAntPath(antPath);
 		}
 		if (entries.size()==0 ){
 			return null;
 		}else{
 			for (FileDetails file: entries) {
 				if (SurfUtils.fileContainsString(fileManager.getInputStream(file.getCanonicalPath()), "<page>"))
 					return file;
 			}
 			return null;
 		}
 	}
 
 	/**
 	 * Finds Surf page by id.
 	 * @param pageId Page Id
 	 * @return Surf page.
 	 */
 	public FileDetails findSurfPageById(String pageId) {
 		String antPath = (this.pageXmlRootPath+"**/"+pageId+".xml").replace("/", File.separator);
 		SortedSet<FileDetails> entries = fileManager.findMatchingAntPath(antPath);
 		if (entries.size()==0 ){
 			return null;
 		}else{
 			for (FileDetails file: entries) {
 				if (SurfUtils.fileContainsString(fileManager.getInputStream(file.getCanonicalPath()), "<page>"))
 					return file;
 			}
 			return null;
 		}
 	}
 
 	/**
 	 * Returns PageId/FileDetails pairs of Surf pages.
 	 * @return List of PageId/FileDetails pairs of Surf pages.
 	 */
 	public Hashtable <String,FileDetails> getSurfPages() {
 
 		String antPath = (pageXmlRootPath + "**/*.xml").replace("/", File.separator);
 		SortedSet<FileDetails> entries = fileManager.findMatchingAntPath(antPath);
 
 		Hashtable <String,FileDetails> pageList = new Hashtable <String,FileDetails>();
 
 		for (FileDetails fileIdentifier : entries) {
 			if ( SurfUtils.checkSurfXMLType(fileManager, fileIdentifier.getCanonicalPath(),"page") ) {
 				String pageId = fileIdentifier.getFile().getName().replace(".xml","");
 				pageList.put(pageId,fileIdentifier);
 			}
 		}
 
 		return pageList;
 	}
 
 
 
 	public String getPageXmlRootPath() {
 		return pageXmlRootPath;
 	}
 
 }