/*
    * Copyright 2004-2006 the Seasar Foundation and the Others.
    *
    * 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 com.isenshi.util;
  
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.UnsupportedEncodingException;
  import java.io.Writer;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLDecoder;
  import java.util.jar.JarEntry;
  import java.util.jar.JarInputStream;
  import java.util.jar.JarOutputStream;
  import java.util.zip.ZipEntry;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.seasar.tuigwaa.system.Constants;
  
  public class ResourceUtils {
  
  	private static Log log = LogFactory.getLog(ResourceUtils.class);
  
  	public static final void writeJar(JarOutputStream jOutput, String directory, String prefix, String ignorePath){		
  		File file = getFile(directory);
  		addFile(jOutput, file, prefix, ignorePath);		
  	}
  
  	public static final void readJar(JarInputStream jinput, String directory) {
  		try {
  			JarEntry jar;
  			while ((jar = jinput.getNextJarEntry()) != null) {
  				String path = PathUtils.join(directory, jar.getName());
  				if (jar.isDirectory()) {
  					File savePath = getFile(path);
  					savePath.mkdir();
  				} else {
  					int length = 0;
  					int bufsize = 1024;
  					byte[] buf = new byte[bufsize];
  					OutputStream fos = getOutputStream(path);
  					while (jinput.available() > 0
  							&& (length = jinput.read(buf, 0, bufsize)) != -1) {
  						fos.write(buf, 0, length);
  					}
  					fos.close();
  				}
  			}
  		} catch (FileNotFoundException e) {
  			e.printStackTrace();
  		} catch (IOException e) {
  			e.printStackTrace();
  		}
  	}
  
  	public static final void deleteDirectory(String path) {
  		File file = getFile(path);
  		deleteDirectory(file);
  	}
  
  	public static final void deleteDirectory(File file) {
  
  		try {
  			if (file.exists()) {
  				FileUtils.deleteDirectory(file);
  			}
  		} catch (IOException ioe) {
  			// do nothing
  			log.error(ioe.getMessage());
  		}
  	}
  
  	public static final String[] getChildrenNames(String path) {
  		File file = getFile(path);
 		return file.list();
 	}
 		
 	public static Writer getWriter(String path) {
 		try {
 			return new OutputStreamWriter(getOutputStream(path), "Windows-31J");
 		} catch (UnsupportedEncodingException e) {
 			// do nothing
 			return null;
 		}
 	}
 
 	public static InputStream getInputStream(String path) {
 		File file = getFile(path);
 		InputStream stream = null;
 		try {
 			stream = new FileInputStream(file);
 		} catch (FileNotFoundException e) {
 			// Do nothing
 		}
 		return stream;
 	}
 
 	public static boolean isExist(String path) {
 		return getFile(path).exists();
 	}
 
 	public static OutputStream getOutputStream(String path) {
 		File file = getFile(path);
 		return getOutputStream(file);
 	}
 		
 	public static OutputStream getOutputStream(File file) {
 				checkNewParent(file);
 		OutputStream os = null;
 		try {
 			os = new FileOutputStream(file);
 		} catch (FileNotFoundException e) {
 			e.printStackTrace();
 			throw new RuntimeException(e);
 		}
 		return os;
 	}
 
 	public static void checkNewParent(File file) {
 		File parent = file.getParentFile();
 
 		if (parent.exists()) {
 			return;
 		}
 		checkNewParent(parent);
 		parent.mkdir();
 	}
 
 	public static String getPath(String path) {
 		if (path == null) {
 			return null;
 		}
 		URL url = null;
 		try {
 			url = getFile(path).toURL();
 		} catch (MalformedURLException e) {
 			e.printStackTrace();
 		}
 		return getFileName(url);
 	}
 
 	public static File getFile(final String path) {
 		URL url = getClassLoader().getResource("");
 		return new File(getFileName(url) + File.separator + path);
 	}
 
 	public static InputStream getResourceAsStream(final String path) {
 		return getClassLoader().getResourceAsStream("Domain.xml");
 	}
 
 	public static ClassLoader getClassLoader() {
 		return Thread.currentThread().getContextClassLoader();
 	}
 
 	public static String getFileName(URL url) {
 		String s = url.getFile();
 		try {
 			return URLDecoder.decode(s, "UTF8");
 		} catch (UnsupportedEncodingException ex) {
 			ex.printStackTrace();
 			throw new RuntimeException(ex);
 		}
 	}
 
 	public static void writeContent(File file, String content) {
 	
 	}
 	
 	public static void writeContent(String path, String content) {
 		BufferedWriter writer = null;
 		try {
 			writer = new BufferedWriter(getWriter(path));
 			writer.write(content);
 		} catch (UnsupportedEncodingException e) {
 			e.printStackTrace();
 		} catch (FileNotFoundException e) {
 			e.printStackTrace();
 		} catch (IOException e) {
 			e.printStackTrace();
 		} finally {
 			IOUtils.closeQuietly(writer);
 		}
 	}
 
 	public static String readContent(String path) {
 		File file = getFile(path);
 		return readContent(file);
 	}
 	
 	public static InputStream readContentAsStream(String path){
 		File file = getFile(path);		
 		InputStream is = null;
 		try{
 			is = new FileInputStream(file);
 		}catch(IOException ioe){
 			throw new RuntimeException(ioe);
 		}
 		return is;
 	}	
 	
 	public static String readContent(File file) {
 		StringBuffer buf = new StringBuffer();
 	
 
 		if (!file.exists()) {
 			return null;
 		}
 
 		BufferedReader reader = null;
 		try {
 			reader = new BufferedReader(new InputStreamReader(
 					new FileInputStream(file), "Windows-31J"));
 			String line = null;
 			while ((line = reader.readLine()) != null) {
 				buf.append(line);
 				// buf.append(System.getProperty("line.separator"));
 				buf.append(Constants.LINEBREAK_CODE);
 			}
 		} catch (UnsupportedEncodingException e) {
 			e.printStackTrace();
 			throw new RuntimeException(e);
 		} catch (FileNotFoundException e) {
 			e.printStackTrace();
 			throw new RuntimeException(e);
 		} catch (IOException e) {
 			e.printStackTrace();
 			throw new RuntimeException(e);
 		} finally {
 			IOUtils.closeQuietly(reader);
 		}
 		return buf.toString();
 	}
 
 	public static void removeContent(String path) {
 		boolean success = true;
 		File file = getFile(path);
 		if (file.isDirectory()) {
 			String[] names = file.list();
 			for (int i = 0; i < names.length; i++) {
 				String childpath = PathUtils.join(path, names[i]);
 				removeContent(childpath);
 			}
 		}
 		success = file.delete();
 		// FileUtils.
 		if (!success)
 			throw new RuntimeException("deleting " + path + " failed.");
 	}
 
 	/***
 	 * Provides File object with the given name which exists on upward path to
 	 * the directory the current thread resides. This returns the first object
 	 * with the given name, for example, the name is "foo", and current thread
 	 * directory "/home/foo/xxx/foo/classes", returns "/home/foo/xxx/foo".
 	 * FIXME: want to use FileUtils wild card, needs commons.io update.
 	 * 
 	 * @param name
 	 *            specifies the file or directory name
 	 * @return file object if the given name exists, if not return null
 	 */
 	public static final File getUpwardFileByName(String name) {
 		File file = getFile("");
 		
 		while (true) {
 			if (file.getName().equals(name)) {
 				break;
 			}
 			file = file.getParentFile();
 			if (file == null) {// root
 				break;
 			}
 		}
 		return file;
 	}
 
 	public static boolean createDirectory(String filepath) {
 		return createDirectory(new File(filepath));
 	}
 
 	public static boolean createDirectory(File file) {
 		boolean flag = true;
 		if (!file.exists()) {
 			flag = file.mkdirs();
 		}
 		return flag;
 	}
 	
 	
 	public static void copyDirectory(String srcDirectoryPath, String destDirectoryPath) throws IOException{
 		
 		File src = new File(srcDirectoryPath);
 		if(!src.isDirectory()){
 			throw new IOException(srcDirectoryPath + " should be directory");
 		}
 		
 		File[] childrens = src.listFiles();
 		for(int i=0;i<childrens.length;i++){
 			copyFile(childrens[i].getPath(),destDirectoryPath);
 		}		
 	}	
 
 	public static void copyFile(String srcpath, String destpath)
 			throws IOException {
 
 		File src = new File(srcpath);
 		File dest = new File(destpath);
 
 		if (src.exists()) {
 
 			if (!dest.exists()) {
 				createDirectory(dest);
 			}
 			if (src.isDirectory()) {
 				File[] childrens = src.listFiles();
 				String newdest = destpath + "/" + src.getName();
 				for (int i = 0; i < childrens.length; i++) {
 					copyFile(childrens[i].getPath(), newdest);
 				}
 			} else {
 				if (dest.isDirectory()) {
 					FileUtils.copyFileToDirectory(src, dest);
 				} else {
 					FileUtils.copyFile(src, dest);
 				}
 			}
 		}
 	}
 
 	public static void writeFile(String outputPath, InputStream is)
 			throws IOException {
 
 		try {
 			FileOutputStream fos = new FileOutputStream(outputPath, false);
 			byte[] buf = new byte[8192];
 			while (true) {
 				int length = is.read(buf);
 				if (length == -1)
 					break;
 				fos.write(buf, 0, length);
 			}
 			fos.flush();
 			fos.close();
 		} catch (FileNotFoundException fnfe) {
 			log.error("couldn't open file " + outputPath + " : "
 					+ fnfe.getMessage());
 			throw fnfe;
 		} catch (IOException ioe) {
 			log.error(ioe.getMessage());
 			throw ioe;
 		}
 	}
 	
 	private static final void addFile(JarOutputStream jOutput, File file, String prefix, String ignorePath){
 		
 		prefix = CharUtil.chartrim(prefix, '/');
 		String path = ("".equals(prefix)) ? file.getName() : prefix + "/"
 				+ file.getName();
 		if (file.isDirectory()) {
 			path = path + "/";
 		}
 		
 		if(ignorePath != null && path.indexOf(ignorePath) != -1){
 			return;
 		}
 		
 		try {
 			jOutput.putNextEntry(new ZipEntry(path));
 			if (file.isDirectory()) {
 				File[] files = file.listFiles();
 				for (int i = 0; i < files.length; i++) {
 					addFile(jOutput, files[i], path, ignorePath);
 				}
 			} else {
 				InputStream is = new FileInputStream(file);
 				int length = 0;
 				int bufsize = 1024;
 				byte[] buf = new byte[bufsize];
 				while ((length = is.read(buf, 0, bufsize)) != -1) {
 					jOutput.write(buf, 0, length);
 				}
 			}
 		} catch (IOException e) {
 			e.printStackTrace();
 		}		
 		
 	}
 	
 }