/**
    * 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.util;
  
  import java.io.InputStream;
  import java.util.Enumeration;
  import java.util.Scanner;
  import java.util.logging.Logger;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipFile;
  
  import org.springframework.roo.file.monitor.event.FileDetails;
  import org.springframework.roo.process.manager.FileManager;
  import org.springframework.roo.support.util.Assert;
  import org.springframework.roo.support.util.FileCopyUtils;
  import org.springframework.roo.support.util.XmlUtils;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  /**
   * @author Yong Qu
   */
  public class SurfUtils {
  
  	static Logger logger = Logger.getLogger(SurfUtils.class.getName());
   
  	public static String getElementValue (FileManager fileManager,FileDetails xmlFile, String xPath){
  		InputStream docInputStream = fileManager.getInputStream(xmlFile.getCanonicalPath());
  		Document doc;
  		try {
  			doc = XmlUtils.getDocumentBuilder().parse(docInputStream);
  		} catch (Exception ex) {
  			throw new IllegalStateException(ex);
  		}
  		if ( XmlUtils.findFirstElement(xPath, doc.getDocumentElement()) != null ) {
  			return XmlUtils.findFirstElement(xPath, doc.getDocumentElement()).getTextContent().trim();
  		} else {
  			return null;			
  		}
  
  	}
  
  	
  	public static Document getSurfXMLDoc(FileManager fileManager,FileDetails xmlFile){
  		InputStream docInputStream = fileManager.getInputStream(xmlFile.getCanonicalPath());
  		Document doc;
  		try {
  			doc = XmlUtils.getDocumentBuilder().parse(docInputStream);
  		} catch (Exception ex) {
  			throw new IllegalStateException(ex);
  		}
  		return doc;
  	}
  
  	/**
  	 * @param fileManager
  	 * @param filePath
  	 * @param type
  	 * @return
  	 */
  	public static boolean checkSurfXMLType (FileManager fileManager, String filePath, String type) {
  		Assert.notNull(fileManager, "File manager required");
  		Assert.hasText(filePath, "File path required");
  		Assert.hasText(type, "Surf type name required");
  
  		InputStream pageInputStream;
  		Document pom;
  		try {
  			pageInputStream = fileManager.getInputStream(filePath);
  			pom = XmlUtils.getDocumentBuilder().parse(pageInputStream);
  		} catch (Exception ex) {
  			//throw new IllegalStateException(ex);
  			return false;
  		}
  
  		Element rootElement = pom.getDocumentElement();
  
  		try {
  			pageInputStream.close();
  		} catch (Exception ex) {
  			throw new IllegalStateException(ex);
  		}
  
 		return rootElement.getTagName().equals(type);
 	}
 
 	/**
 	 * @param fileManager
 	 * @param zipFilePath
 	 * @param descPath
 	 */
 	public static void unzip (FileManager fileManager, String zipFilePath, String descPath) {
 		try {
 			ZipFile zipfile = new ZipFile(zipFilePath);
 			Enumeration<? extends ZipEntry> e = zipfile.entries();
 			while(e.hasMoreElements()) {
 				ZipEntry entry = (ZipEntry) e.nextElement();
 				if ( !entry.isDirectory()){
 					//logger.warning(entry.getName());
 					String path = descPath+"/"+entry.getName();
 					if (fileManager.exists(path)){
 						FileCopyUtils.copy(zipfile.getInputStream(entry),fileManager.updateFile(path).getOutputStream());
 					} else {
 						FileCopyUtils.copy(zipfile.getInputStream(entry),fileManager.createFile(path).getOutputStream());
 					}
 				}
 			}
 			zipfile.close();
 		} catch (Exception ex) {
 			throw new IllegalStateException(ex);
 		}
 	}
 
 
 	/**
 	 * @param inputStream
 	 * @param str
 	 * @return
 	 */
 	public static boolean fileContainsString(InputStream inputStream, String str) {
 		Scanner templateScanner = new Scanner(inputStream);
 		String matchStr= templateScanner.findWithinHorizon(str, 0);
 		templateScanner.close();
 		if ( matchStr != null ) {
 			return true;
 		} else {
 			return false;
 		}
 	}
 
 	/**
 	 * @param path
 	 * @return
 	 */
 	public static String getNameFromPath(String path) {
 
 		if (path==null || path.equals("")) return "";
 		String name = path;
 		if (path.lastIndexOf("/") != -1) {
 			name = path.substring(path.lastIndexOf("/")+1);
 		} else if (path.lastIndexOf("\\") != -1) {
 			name = path.substring(path.lastIndexOf("\\")+1);
 		}
 		return name;
 	}
 
 	/**
 	 * @param path
 	 * @return
 	 */
 	public static String getRelativePath(String path) {
 
 		if (path==null || path.equals("")) return "";
 		if (path.lastIndexOf("/") != -1) {
 			return path.substring(0,path.lastIndexOf("/"));
 		} else if (path.lastIndexOf("\\") != -1) {
 			return path.substring(0,path.lastIndexOf("\\"));
 		}
 		return "";
 	}
 }