package es.inteco.eni.utils;
   
   import java.io.BufferedReader;
   import java.io.BufferedWriter;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.nio.charset.Charset;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.commons.codec.binary.Base64;
  
  
  /**
   * Clase de utilidad para la gestión de ficheros
   * 
   *
   */
  public final class FileUtils {
  
  	/**
  	 * Extension de los ficheros XML
  	 */
  	public static final String XML_EXTENSION = "xml";
  
  	/**
  	 * Extension de los schemas XSD
  	 */
  	private static final String XSD_EXTENSION = "xsd";
  
  	/**
  	 * Número de caracteres del buffer para lectura de un fichero
  	 */
  	private static final int BUFFER_CHARS_NUMBER = 1024;
  
  	/**
  	 * Número de bytes del buffer para lectura 
  	 */
  	private static final int BUFFER_BYTES_NUMBER = 4096;
  
  
  	/**
  	 * Constructor privado, no se puede instanciar
  	 */
  	private FileUtils(){
  
  	}
  
  
  	/**
  	 * Devuelve la lista de ficheros existentes en una carpeta
  	 * @param folder Carpeta
  	 * @return lista de ficheros existentes en una carpeta
  	 */
  	public static List<File> getXsdFilesInFolder(File folder){
  		return getFilesInFolder(folder, XSD_EXTENSION);
  	}
  
  	/**
  	 * Lectura de un fichero
  	 * @param filePath Ruta del fichero a leer
  	 * @return String con el contenido del fichero
  	 * @throws IOException 
  	 * @throws IOException Error en la lectura
  	 */
  	public static String readFileAsString(String filePath) throws IOException{
  		if(filePath==null || !new File(filePath).exists()){
  			return null;
  		}
  		StringBuffer fileData = new StringBuffer();
  		BufferedReader reader = null;
  		try{
  			reader = new BufferedReader( new InputStreamReader(
  					new FileInputStream(filePath),
  					Charset.forName("UTF-8")));
  
  			char[] buf = new char[BUFFER_CHARS_NUMBER];
  
  			int numRead=0;
  			while((numRead=reader.read(buf)) != -1){
  				fileData.append(buf, 0, numRead);
  			}
  		}finally{
  			if(reader!=null){
  				reader.close();
  			}
  		}
  
  		return fileData.toString();
  	}
  
  
  	/**
  	 * Devuelve la lista de ficheros existentes en una carpeta con una determina extensión
 	 * @param folder Carpeta
 	 * @param extension Extension
 	 * @return lista de ficheros existentes en una carpeta con una determina extensión
 	 */
 	private static List<File> getFilesInFolder(File folder, String extension){
 		List<File> result = new ArrayList<File>();
 		//Comprobamos que el fichero existe y que es un directorio
 		boolean notExistFolder =folder==null || !folder.exists() || folder.isFile();
 		if(notExistFolder){
 			return result;
 		}
 		//Lista de ficheros de un directorio
 		File[] listFiles = folder.listFiles();
 		for (int i=0; listFiles!=null && i<listFiles.length; i++){
 			File file = listFiles[i];
 			String fileExtension = getFileExtension(file);
 			boolean isSearchedFile = file.isFile() && (extension==null || extension.toUpperCase().equals(fileExtension.toUpperCase()));
 			if (isSearchedFile){
 				result.add(file);
 			}else if (file.isDirectory()&& !file.isHidden()){
 				List<File> folderFiles = getFilesInFolder(file, extension);
 				if (folderFiles!=null && folderFiles.size()>0){
 					result.addAll(folderFiles);
 				}
 			}
 		}
 		return result;
 	}
 
 	/**
 	 * Extension de un fichero
 	 * @param file Fichero
 	 * @return Extension de un fichero
 	 */
 	public static String getFileExtension(File file){
 		String fileName = file.getName();
 		return fileName.indexOf('.')!=-1 ? fileName.substring(fileName.lastIndexOf('.')+1) : null;
 
 	}
 
 	/**
 	 * Escribe una cadena de texto en un fichero
 	 * @param file Fichero
 	 * @param dataString Cadena de texto
 	 * @throws IOException
 	 */
 	public static void writeFile(File file, String dataString) throws IOException {
 		PrintWriter out = null;
 		try {
 			out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF8")));
 			out.print (dataString);
 			out.flush ();
 		}
 		finally{
 			if(out!=null){
 				out.close ();
 			}
 		}
 	}
 
 
 	/**
 	 * Escribe y devuelve los bytes en un fichero temporal
 	 * @param byteContent Contenido del fichero
 	 * @return Fichero temporal con los bytes escirtos
 	 * @throws IOException
 	 */
 	public static File getTempFileFromBytes(String extension, byte[] byteContent) throws IOException {
 		FileOutputStream  fos = null;
 		File tempFile = File.createTempFile(System.nanoTime()+"", extension==null || "".equals(extension) ? "" : "."+extension);
 		try {
 			fos = new FileOutputStream(tempFile);
 			fos.write(byteContent);
 		}finally{
 			fos.close();
 		}
 
 		return tempFile;
 	}
 
 	/**
 	 * Escribe y devuelve un fichero temporal a partir de una cadena de texto en base64 decodificada
 	 * @param extension Extension del fichero
 	 * @param base64Str Cadena de texto codificada en Base64
 	 * @return Fichero temporal a partir de una cadena de texto en base64 decodificada
 	 * @throws IOException 
 	 */
 	public static File getTempFileFromBase64String(String extension,String base64Str) throws IOException{
 		return getTempFileFromBytes(extension, Base64.decodeBase64(base64Str));
 	}
 
 
 	/**
 	 * Copia un fichero a una nueva ruta
 	 * @param fromFile Fichero origen
 	 * @param toFile Fichero destino
 	 * @throws IOException Excepcion
 	 */
 	public static void copy(File fromFile, File toFile)throws IOException {
 
 		//Comprobaciones
 		if (!fromFile.exists()){
 			throw new IOException("No existe el fichero: " + fromFile.getAbsolutePath());
 		}
 		if (!fromFile.isFile()){
 			throw new IOException("No se puede copiar el directorio: " + fromFile.getAbsolutePath());
 		}
 		if (!fromFile.canRead()){
 			throw new IOException("No se puede leer el fichero : " + fromFile.getAbsolutePath());
 		}
 		if (toFile.isDirectory()){
 			toFile = new File(toFile, fromFile.getName());
 		}
 		if (toFile.exists()) {
 			if (!toFile.canWrite()){
 				throw new IOException("No se puede sobreescribir el fichero : " + toFile.getAbsolutePath());
 			}
 		} else {
 			String parent = toFile.getParent();
 			if (parent == null){
 				parent = System.getProperty("user.dir");
 			}
 			File dir = new File(parent);
 			if (!dir.exists()){
 				throw new IOException("El directorio: " + parent + " de destino del fichero no existe");
 			}
 			if (dir.isFile()){
 				throw new IOException("El destino: " + parent + " no es un directorio");
 			}
 			if (!dir.canWrite())
 				throw new IOException("No se puede escribir el fichero en el directorio: " + parent );
 		}
 
 		//Copia el fichero
 		FileInputStream from = null;
 		FileOutputStream to = null;
 		try {
 			from = new FileInputStream(fromFile);
 			to = new FileOutputStream(toFile);
 			byte[] buffer = new byte[BUFFER_BYTES_NUMBER];
 			int bytesRead;
 
 			while ((bytesRead = from.read(buffer)) != -1){
 				to.write(buffer, 0, bytesRead); 
 			}
 		} finally {
 			if (from != null){
 				from.close();
 			}
 			if (to != null){
 				to.close();
 			}
 		}
 	}
 }