import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.text.DateFormat;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.Locale;
import java.util.StringTokenizer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 *
 * @author IBM
 *
 */

public class FileUtil {

 public static String dirSplit = "\\";//linux windows
 /**
  * save file accroding to physical directory infomation
  *
  * @param physicalDir
  *            physical directory
  * @param fname
  *            file name of destination
  * @param istream
  *            input stream of destination file
  * @return
  */

 public static boolean SaveFileByPhysicalDir(String physicalPath,
   InputStream istream) {

  boolean flag = false;
  try {
   OutputStream os = new FileOutputStream(physicalPath);
   int readBytes = 0;
   byte buffer[] = new byte[8192];
   while ((readBytes = istream.read(buffer, 0, 8192)) != -1) {
    os.write(buffer, 0, readBytes);
   }
   os.close();
   flag = true;
  } catch (FileNotFoundException e) {

   e.printStackTrace();
  } catch (IOException e) {

   e.printStackTrace();
  }
  return flag;
 }

 public static boolean CreateDirectory(String dir){
  File f = new File(dir);
  if (!f.exists()) {
   f.mkdirs();
  }
  return true;
 }

 
 public static void saveAsFileOutputStream(String physicalPath,String content) {
    File file = new File(physicalPath);
    boolean b = file.getParentFile().isDirectory();
    if(!b){
     File tem = new File(file.getParent());
     // tem.getParentFile().setWritable(true);
     tem.mkdirs();// 創(chuàng)建目錄
    }
    //Log.info(file.getParent()+";"+file.getParentFile().isDirectory());
    FileOutputStream foutput =null;
    try {
     foutput = new FileOutputStream(physicalPath);

     foutput.write(content.getBytes("UTF-8"));
     //foutput.write(content.getBytes());
    }catch(IOException ex) {
     ex.printStackTrace();
     throw new RuntimeException(ex);
    }finally{
     try {
      foutput.flush();
      foutput.close();
     }catch(IOException ex){
      ex.printStackTrace();
      throw new RuntimeException(ex);
     }
    }
     //Log.info("文件保存成功:"+ physicalPath);
   }

  /**
     * COPY文件
     * @param srcFile String
     * @param desFile String
     * @return boolean
     */
    public boolean copyToFile(String srcFile, String desFile) {
        File scrfile = new File(srcFile);
        if (scrfile.isFile() == true) {
            int length;
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(scrfile);
            }
            catch (FileNotFoundException ex) {
                ex.printStackTrace();
            }
            File desfile = new File(desFile);

            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(desfile, false);
            }
            catch (FileNotFoundException ex) {
                ex.printStackTrace();
            }
            desfile = null;
            length = (int) scrfile.length();
            byte[] b = new byte[length];
            try {
                fis.read(b);
                fis.close();
                fos.write(b);
                fos.close();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            scrfile = null;
            return false;
        }
        scrfile = null;
        return true;
    }

    /**
     * COPY文件夾
     * @param sourceDir String
     * @param destDir String
     * @return boolean
     */
    public boolean copyDir(String sourceDir, String destDir) {
        File sourceFile = new File(sourceDir);
        String tempSource;
        String tempDest;
        String fileName;
        File[] files = sourceFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            fileName = files[i].getName();
            tempSource = sourceDir + "/" + fileName;
            tempDest = destDir + "/" + fileName;
            if (files[i].isFile()) {
                copyToFile(tempSource, tempDest);
            } else {
                copyDir(tempSource, tempDest);
            }
        }
        sourceFile = null;
        return true;
    }

    /**
     * 刪除指定目錄及其中的所有內(nèi)容。
     * @param dir 要刪除的目錄
     * @return 刪除成功時返回true，否則返回false。
     */
    public boolean deleteDirectory(File dir) {
        File[] entries = dir.listFiles();
        int sz = entries.length;
        for (int i = 0; i < sz; i++) {
            if (entries[i].isDirectory()) {
                if (!deleteDirectory(entries[i])) {
                    return false;
                }
            } else {
                if (!entries[i].delete()) {
                    return false;
                }
            }
        }
        if (!dir.delete()) {
            return false;
        }
        return true;
    }

   

    /**
     * File exist check
     *
     * @param sFileName File Name
     * @return boolean true - exist<br>
     *                 false - not exist
     */
    public static boolean checkExist(String sFileName) {

     boolean result = false;

       try {
        File f = new File(sFileName);

        //if (f.exists() && f.isFile() && f.canRead()) {
    if (f.exists() && f.isFile()) {
      result = true;
    } else {
      result = false;
    }
    } catch (Exception e) {
         result = false;
    }

        /* return */
        return result;
    }

    /**
     * Get File Size
     *
     * @param sFileName File Name
     * @return long File's size(byte) when File not exist return -1
     */
    public static long getSize(String sFileName) {

        long lSize = 0;

        try {
      File f = new File(sFileName);

              //exist
      if (f.exists()) {
       if (f.isFile() && f.canRead()) {
        lSize = f.length();
       } else {
        lSize = -1;
       }
              //not exist
      } else {
          lSize = 0;
      }
    } catch (Exception e) {
         lSize = -1;
    }
    /* return */
    return lSize;
    }

 /**
  * File Delete
  *
  * @param sFileName File Nmae
  * @return boolean true - Delete Success<br>
  *                 false - Delete Fail
  */
    public static boolean deleteFromName(String sFileName) {

        boolean bReturn = true;

        try {
            File oFile = new File(sFileName);

           //exist
           if (oFile.exists()) {
            //Delete File
            boolean bResult = oFile.delete();
            //Delete Fail
            if (bResult == false) {
                bReturn = false;
            }

            //not exist
           } else {

           }

   } catch (Exception e) {
    bReturn = false;
   }

   //return
   return bReturn;
    }

 /**
  * File Unzip
  *
  * @param sToPath  Unzip Directory path
  * @param sZipFile Unzip File Name
  */
 @SuppressWarnings("rawtypes")
public static void releaseZip(String sToPath, String sZipFile) throws Exception {

  if (null == sToPath ||("").equals(sToPath.trim())) {
    File objZipFile = new File(sZipFile);
    sToPath = objZipFile.getParent();
  }
  ZipFile zfile = new ZipFile(sZipFile);
  Enumeration zList = zfile.entries();
  ZipEntry ze = null;
  byte[] buf = new byte[1024];
  while (zList.hasMoreElements()) {

    ze = (ZipEntry) zList.nextElement();
    if (ze.isDirectory()) {
     continue;
    }

    OutputStream os =
    new BufferedOutputStream(
    new FileOutputStream(getRealFileName(sToPath, ze.getName())));
    InputStream is = new BufferedInputStream(zfile.getInputStream(ze));
    int readLen = 0;
    while ((readLen = is.read(buf, 0, 1024)) != -1) {
     os.write(buf, 0, readLen);
    }
    is.close();
    os.close();
  }
  zfile.close();
 }

 /**
  * getRealFileName
  *
  * @param  baseDir   Root Directory
  * @param  absFileName  absolute Directory File Name
  * @return java.io.File     Return file
  */
 @SuppressWarnings({ "rawtypes", "unchecked" })
private static File getRealFileName(String baseDir, String absFileName) throws Exception {

  File ret = null;

  List dirs = new ArrayList();
  StringTokenizer st = new StringTokenizer(absFileName, System.getProperty("file.separator"));
  while (st.hasMoreTokens()) {
   dirs.add(st.nextToken());
  }

  ret = new File(baseDir);
  if (dirs.size() > 1) {
   for (int i = 0; i < dirs.size() - 1; i++) {
    ret = new File(ret, (String) dirs.get(i));
   }
  }
  if (!ret.exists()) {
   ret.mkdirs();
  }
  ret = new File(ret, (String) dirs.get(dirs.size() - 1));
  return ret;
 }

 /**
  * copyFile
  *
  * @param  srcFile   Source File
  * @param  targetFile   Target file
  */
 @SuppressWarnings("resource")
 static public void copyFile(String srcFile , String targetFile) throws IOException
  {

   FileInputStream reader = new FileInputStream(srcFile);
   FileOutputStream writer = new FileOutputStream(targetFile);

   byte[] buffer = new byte [4096];
   int len;

   try
   {
    reader = new FileInputStream(srcFile);
    writer = new FileOutputStream(targetFile);

    while((len = reader.read(buffer)) > 0)
    {
     writer.write(buffer , 0 , len);
    }
   }
   catch(IOException e)
   {
    throw e;
   }
   finally
   {
    if (writer != null)writer.close();
    if (reader != null)reader.close();
   }
  }

 /**
  * renameFile
  *
  * @param  srcFile   Source File
  * @param  targetFile   Target file
  */
 static public void renameFile(String srcFile , String targetFile) throws IOException
  {
   try {
    copyFile(srcFile,targetFile);
    deleteFromName(srcFile);
   } catch(IOException e){
    throw e;
   }
  }

 public static void write(String tivoliMsg,String logFileName) {
  try{
    byte[]  bMsg = tivoliMsg.getBytes();
    FileOutputStream fOut = new FileOutputStream(logFileName, true);
    fOut.write(bMsg);
    fOut.close();
  } catch(IOException e){
   //throw the exception     
  }

 }
 /**
 * This method is used to log the messages with timestamp,error code and the method details
 * @param errorCd String
 * @param className String
 * @param methodName String
 * @param msg String
 */
 public static void writeLog(String logFile, String batchId, String exceptionInfo) {

  DateFormat df = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.JAPANESE);

  Object args[] = {df.format(new Date()), batchId, exceptionInfo};

  String fmtMsg = MessageFormat.format("{0} : {1} : {2}", args);

  try {

   File logfile = new File(logFile);
   if(!logfile.exists()) {
    logfile.createNewFile();
   }

      FileWriter fw = new FileWriter(logFile, true);
      fw.write(fmtMsg);
      fw.write(System.getProperty("line.separator"));

      fw.flush();
      fw.close();

  } catch(Exception e) {
  }
 }

 public static String readTextFile(String realPath) throws Exception {
  File file = new File(realPath);
   if (!file.exists()){
    System.out.println("File not exist!");
    return null;
   }
   BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(realPath),"UTF-8"));  
   String temp = "";
   String txt="";
   while((temp = br.readLine()) != null){
    txt+=temp;
    }  
   br.close();
  return txt;
 }
}