import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
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.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.URL;
import java.net.URLEncoder;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class FileUtil
{
 private static Log logger = LogFactory.getLog(FileUtil.class);
 
 public static void writeFile(String paramString1, String paramString2)
 {
  writeFile(paramString1, paramString2, "utf-8");
 }
 
 public static void writeFile(String paramString1, String paramString2, String paramString3)
 {
  try
  {
   createFolder(paramString1, true);
   BufferedWriter localBufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(paramString1), paramString3));
   localBufferedWriter.write(paramString2);
   localBufferedWriter.close();
  }
  catch (IOException localIOException)
  {
   localIOException.printStackTrace();
  }
 }
 
 public static void writeFile(String paramString, InputStream paramInputStream)
  throws IOException
 {
  FileOutputStream localFileOutputStream = new FileOutputStream(paramString);
  byte[] arrayOfByte = new byte['Ȁ'];
  int i = 0;
  while ((i = paramInputStream.read(arrayOfByte)) != -1) {
   localFileOutputStream.write(arrayOfByte, 0, i);
  }
  paramInputStream.close();
  localFileOutputStream.close();
 }
 
 public static String readFile(String paramString)
  throws IOException
 {
  try
  {
   File localFile = new File(paramString);
   String str1 = getCharset(localFile);
   StringBuffer localStringBuffer = new StringBuffer();
   BufferedReader localBufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(paramString), str1));
   String str2;
   while ((str2 = localBufferedReader.readLine()) != null) {
    localStringBuffer.append(str2 + "\r\n");
   }
   localBufferedReader.close();
   return localStringBuffer.toString();
  }
  catch (IOException localIOException)
  {
   throw localIOException;
  }
 }
 
 public static boolean isExistFile(String paramString)
 {
  boolean bool = false;
  File localFile = new File(paramString);
  if (localFile.isDirectory())
  {
   File[] arrayOfFile = localFile.listFiles();
   if ((arrayOfFile != null) && (arrayOfFile.length != 0)) {
    bool = true;
   }
  }
  return bool;
 }
 
 public static String getCharset(File paramFile)
 {
  String str = "GBK";
  byte[] arrayOfByte = new byte[3];
  try
  {
   int i = 0;
   BufferedInputStream localBufferedInputStream = new BufferedInputStream(new FileInputStream(paramFile));
   localBufferedInputStream.mark(0);
   int j = localBufferedInputStream.read(arrayOfByte, 0, 3);
   if (j == -1) {
    return str;
   }
   if ((arrayOfByte[0] == -1) && (arrayOfByte[1] == -2))
   {
    str = "UTF-16LE";
    i = 1;
   }
   else if ((arrayOfByte[0] == -2) && (arrayOfByte[1] == -1))
   {
    str = "UTF-16BE";
    i = 1;
   }
   else if ((arrayOfByte[0] == -17) && (arrayOfByte[1] == -69) && (arrayOfByte[2] == -65))
   {
    str = "UTF-8";
    i = 1;
   }
   localBufferedInputStream.reset();
   if (i == 0)
   {
    int k = 0;
    while ((j = localBufferedInputStream.read()) != -1)
    {
     k++;
     if ((j < 240) && ((128 > j) || (j > 191))) {
      if ((192 <= j) && (j <= 223))
      {
       j = localBufferedInputStream.read();
       if (128 > j) {
        break;
       }
       if (j > 191) {
        break;
       }
      }
      else if ((224 <= j) && (j <= 239))
      {
       j = localBufferedInputStream.read();
       if ((128 <= j) && (j <= 191))
       {
        j = localBufferedInputStream.read();
        if ((128 <= j) && (j <= 191)) {
         str = "UTF-8";
        }
       }
      }
     }
    }
   }
   localBufferedInputStream.close();
  }
  catch (Exception localException)
  {
   localException.printStackTrace();
  }
  return str;
 }
 
 public static byte[] readByte(InputStream paramInputStream)
 {
  try
  {
   byte[] arrayOfByte = new byte[paramInputStream.available()];
   paramInputStream.read(arrayOfByte);
   return arrayOfByte;
  }
  catch (FileNotFoundException localFileNotFoundException)
  {
   logger.error("文件路徑不存在：" + localFileNotFoundException.getMessage());
  }
  catch (Exception localException)
  {
   localException.printStackTrace();
  }
  return null;
 }
 
 public static byte[] readByte(String paramString)
 {
  try
  {
   FileInputStream localFileInputStream = new FileInputStream(paramString);
   byte[] arrayOfByte = new byte[localFileInputStream.available()];
   localFileInputStream.read(arrayOfByte);
   localFileInputStream.close();
   return arrayOfByte;
  }
  catch (FileNotFoundException localFileNotFoundException)
  {
   logger.error("文件路徑不存在：" + paramString);
  }
  catch (Exception localException)
  {
   localException.printStackTrace();
  }
  return null;
 }
 
 public static boolean writeByte(String paramString, byte[] paramArrayOfByte)
 {
  try
  {
   BufferedOutputStream localBufferedOutputStream = new BufferedOutputStream(new FileOutputStream(paramString));
   localBufferedOutputStream.write(paramArrayOfByte);
   localBufferedOutputStream.close();
   return true;
  }
  catch (Exception localException)
  {
   localException.printStackTrace();
  }
  return false;
 }
 
 public static boolean deleteDir(File paramFile)
 {
  if (paramFile.isDirectory())
  {
   String[] arrayOfString = paramFile.list();
   for (int i = 0; i < arrayOfString.length; i++)
   {
    boolean bool = deleteDir(new File(paramFile, arrayOfString[i]));
    if (!bool) {
     return false;
    }
   }
  }
  return paramFile.delete();
 }
 
 public static void serializeToFile(Object paramObject, String paramString)
 {
  try
  {
   ObjectOutputStream localObjectOutputStream = new ObjectOutputStream(new FileOutputStream(paramString));
   localObjectOutputStream.writeObject(paramObject);
   localObjectOutputStream.close();
  }
  catch (IOException localIOException)
  {
   localIOException.printStackTrace();
  }
 }
 
 public static Object deserializeFromFile(String paramString)
 {
  try
  {
   File localFile = new File(paramString);
   ObjectInputStream localObjectInputStream = new ObjectInputStream(new FileInputStream(localFile));
   Object localObject = localObjectInputStream.readObject();
   localObjectInputStream.close();
   return localObject;
  }
  catch (Exception localException)
  {
   localException.printStackTrace();
  }
  return null;
 }
 
 public static String inputStream2String(InputStream paramInputStream, String paramString)
  throws IOException
 {
  BufferedReader localBufferedReader = new BufferedReader(new InputStreamReader(paramInputStream, paramString));
  StringBuffer localStringBuffer = new StringBuffer();
  String str = "";
  while ((str = localBufferedReader.readLine()) != null) {
   localStringBuffer.append(str + "\n");
  }
  return localStringBuffer.toString();
 }
 
 public static String inputStream2String(InputStream paramInputStream)
  throws IOException
 {
  return inputStream2String(paramInputStream, "utf-8");
 }
 
 public static File[] getFiles(String paramString)
 {
  File localFile = new File(paramString);
  return localFile.listFiles();
 }
 
 public static void createFolderFile(String paramString)
 {
  createFolder(paramString, true);
 }
 
 public static void createFolder(String paramString, boolean paramBoolean)
 {
  if (paramBoolean) {
   paramString = paramString.substring(0, paramString.lastIndexOf(File.separator));
  }
  File localFile = new File(paramString);
  if (!localFile.exists()) {
   localFile.mkdirs();
  }
 }
 
 public static void createFolder(String paramString1, String paramString2)
 {
  paramString1 = StringUtil.trimSufffix(paramString1, File.separator) + File.separator + paramString2;
  File localFile = new File(paramString1);
  localFile.mkdir();
 }
 
 public static void renameFolder(String paramString1, String paramString2)
 {
  File localFile = new File(paramString1);
  if (localFile.exists()) {
   localFile.renameTo(new File(paramString2));
  }
 }
 
 public static ArrayList<File> getDiretoryOnly(File paramFile)
 {
  ArrayList localArrayList = new ArrayList();
  if ((paramFile != null) && (paramFile.exists()) && (paramFile.isDirectory()))
  {
   File[] arrayOfFile = paramFile.listFiles(new FileFilter()
   {
    public boolean accept(File paramAnonymousFile)
    {
     return paramAnonymousFile.isDirectory();
    }
   });
   for (int i = 0; i < arrayOfFile.length; i++) {
    localArrayList.add(arrayOfFile[i]);
   }
  }
  return localArrayList;
 }
 
 public ArrayList<File> getFileOnly(File paramFile)
 {
  ArrayList localArrayList = new ArrayList();
  File[] arrayOfFile = paramFile.listFiles(new FileFilter()
  {
   public boolean accept(File paramAnonymousFile)
   {
    return paramAnonymousFile.isFile();
   }
  });
  for (int i = 0; i < arrayOfFile.length; i++) {
   localArrayList.add(arrayOfFile[i]);
  }
  return localArrayList;
 }
 
 public static boolean deleteFile(String paramString)
 {
  File localFile = new File(paramString);
  return localFile.delete();
 }
 
 public static boolean copyFile(String paramString1, String paramString2)
 {
  File localFile1 = new File(paramString1);
  File localFile2 = new File(paramString2);
  FileInputStream localFileInputStream = null;
  FileOutputStream localFileOutputStream = null;
  try
  {
   localFileInputStream = new FileInputStream(localFile1);
   localFileOutputStream = new FileOutputStream(localFile2);
   byte[] arrayOfByte = new byte['က'];
   int i;
   while ((i = localFileInputStream.read(arrayOfByte)) != -1) {
    localFileOutputStream.write(arrayOfByte, 0, i);
   }
   localFileOutputStream.flush();
   localFileOutputStream.close();
   localFileInputStream.close();
  }
  catch (IOException localIOException)
  {
   localIOException.printStackTrace();
   return false;
  }
  return true;
 }
 
 public static void backupFile(String paramString)
 {
  String str = paramString + ".bak";
  File localFile = new File(str);
  if (localFile.exists()) {
   localFile.delete();
  }
  copyFile(paramString, str);
 }
 
 public static String getFileExt(File paramFile)
 {
  if (paramFile.isFile()) {
   return getFileExt(paramFile.getName());
  }
  return "";
 }
 
 public static String getFileExt(String paramString)
 {
  int i = paramString.lastIndexOf(".");
  if (i > -1) {
   return paramString.substring(i + 1).toLowerCase();
  }
  return "";
 }
 
 public static void copyDir(String paramString1, String paramString2)
  throws IOException
 {
  new File(paramString2).mkdirs();
  File[] arrayOfFile = new File(paramString1).listFiles();
  for (int i = 0; i < arrayOfFile.length; i++)
  {
   if (arrayOfFile[i].isFile())
   {
    String str1 = arrayOfFile[i].getAbsolutePath();
    String str2 = paramString2 + "/" + arrayOfFile[i].getName();
    copyFile(str1, str2);
   }
   if (arrayOfFile[i].isDirectory()) {
    copyDirectiory(paramString1 + "/" + arrayOfFile[i].getName(), paramString2 + "/" + arrayOfFile[i].getName());
   }
  }
 }
 
 private static void copyDirectiory(String paramString1, String paramString2)
  throws IOException
 {
  new File(paramString2).mkdirs();
  File[] arrayOfFile = new File(paramString1).listFiles();
  for (int i = 0; i < arrayOfFile.length; i++)
  {
   if (arrayOfFile[i].isFile())
   {
    String str1 = arrayOfFile[i].getAbsolutePath();
    String str2 = paramString2 + "/" + arrayOfFile[i].getName();
    copyFile(str1, str2);
   }
   if (arrayOfFile[i].isDirectory()) {
    copyDirectiory(paramString1 + "/" + arrayOfFile[i].getName(), paramString2 + "/" + arrayOfFile[i].getName());
   }
  }
 }
 
 public static String getFileSize(File paramFile)
  throws IOException
 {
  if (paramFile.isFile())
  {
   FileInputStream localFileInputStream = new FileInputStream(paramFile);
   int i = localFileInputStream.available();
   localFileInputStream.close();
   return getSize(i);
  }
  return "";
 }
 
 public static String getSize(double paramDouble)
 {
  DecimalFormat localDecimalFormat = new DecimalFormat("0.00");
  double d;
  if (paramDouble > 1048576.0D)
  {
   d = paramDouble / 1048576.0D;
   return localDecimalFormat.format(d) + " M";
  }
  if (paramDouble > 1024.0D)
  {
   d = paramDouble / 1024.0D;
   return localDecimalFormat.format(d) + " KB";
  }
  return paramDouble + " bytes";
 }
 
 public static void downLoadFile(HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse, String paramString1, String paramString2)
  throws IOException
 {
  ServletOutputStream localServletOutputStream = paramHttpServletResponse.getOutputStream();
  File localFile = new File(paramString1);
  if (localFile.exists())
  {
   paramHttpServletResponse.setContentType("APPLICATION/OCTET-STREAM");
   String str1 = getFileExt(paramString1);
   if ((!Validation.isEmpty(str1)) && (str1.toLowerCase().equals("apk"))) {
    paramHttpServletResponse.setContentType("application/vnd.android.package-archive");
   }
   String str2 = paramString2;
   String str3 = paramHttpServletRequest.getHeader("USER-AGENT");
   if ((str3 != null) && (str3.indexOf("MSIE") == -1))
   {
    try
    {
     String localObject1 = transCharacter(paramHttpServletRequest, str2);
     paramHttpServletResponse.setHeader("Content-Disposition", "attachment; filename=" + (String)localObject1);
    }
    catch (Exception localException1)
    {
     localException1.printStackTrace();
    }
   }
   else
   {
    str2 = URLEncoder.encode(str2, "utf-8");
    paramHttpServletResponse.addHeader("Content-Disposition", "attachment;filename=" + str2);
   }
   Object localObject1 = null;
   try
   {
    localServletOutputStream = paramHttpServletResponse.getOutputStream();
    localObject1 = new FileInputStream(paramString1);
    byte[] arrayOfByte = new byte['Ѐ'];
    int i = 0;
    while ((i = ((FileInputStream)localObject1).read(arrayOfByte)) > 0) {
     localServletOutputStream.write(arrayOfByte, 0, i);
    }
    localServletOutputStream.flush();
   }
   catch (Exception localException2)
   {
    localException2.printStackTrace();
   }
   finally
   {
    if (localObject1 != null)
    {
     ((FileInputStream)localObject1).close();
     localObject1 = null;
    }
    if (localServletOutputStream != null)
    {
     localServletOutputStream.close();
     localServletOutputStream = null;
     paramHttpServletResponse.flushBuffer();
    }
   }
  }
  else
  {
   localServletOutputStream.write("文件不存在!".getBytes("utf-8"));
  }
 }
 
 private static String transCharacter(HttpServletRequest paramHttpServletRequest, String paramString)
  throws Exception
 {
  if (paramHttpServletRequest.getHeader("USER-AGENT").toLowerCase().indexOf("msie") > 0) {
   return URLEncoder.encode(paramString, "UTF-8");
  }
  if (paramHttpServletRequest.getHeader("USER-AGENT").toLowerCase().indexOf("firefox") > 0) {
   return new String(paramString.getBytes("UTF-8"), "ISO8859-1");
  }
  return new String(paramString.getBytes("gbk"), "ISO8859-1");
 }
 
 public static String getParentDir(String paramString1, String paramString2)
 {
  File localFile = new File(paramString2);
  String str1 = localFile.getParent();
  String str2 = str1.replace(paramString1, "");
  return str2.replace(File.separator, "/");
 }
 
 public static String getClassesPath()
 {
  String str = StringUtil.trimSufffix(AppUtil.getRealPath("/"), File.separator) + "\\WEB-INF\\classes\\".replace("\\", File.separator);
  return str;
 }
 
 public static String getRootPath()
 {
  String str = StringUtil.trimSufffix(AppUtil.getRealPath("/"), File.separator) + File.separator;
  return str;
 }
 
 public static String readFromProperties(String paramString1, String paramString2)
 {
  String str1 = "";
  BufferedInputStream localBufferedInputStream = null;
  try
  {
   localBufferedInputStream = new BufferedInputStream(new FileInputStream(paramString1));
   Properties localProperties = new Properties();
   localProperties.load(localBufferedInputStream);
   str1 = localProperties.getProperty(paramString2);
   String str2 = str1;
   return str2;
  }
  catch (Exception localException)
  {
   localException.printStackTrace();
  }
  finally
  {
   if (localBufferedInputStream != null) {
    try
    {
     localBufferedInputStream.close();
    }
    catch (IOException localIOException3)
    {
     localIOException3.printStackTrace();
    }
   }
  }
  return str1;
 }
 
 public static boolean saveProperties(String paramString1, String paramString2, String paramString3)
 {
  StringBuffer localStringBuffer = new StringBuffer();
  int i = 0;
  BufferedReader localBufferedReader = null;
  try
  {
   localBufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(paramString1), "utf-8"));
   String str;
   while ((str = localBufferedReader.readLine()) != null) {
    if (str.startsWith(paramString2))
    {
     localStringBuffer.append(paramString2 + "=" + paramString3 + "\r\n");
     i = 1;
    }
    else
    {
     localStringBuffer.append(str + "\r\n");
    }
   }
   if (i == 0) {
    localStringBuffer.append(paramString2 + "=" + paramString3 + "\r\n");
   }
   writeFile(paramString1, localStringBuffer.toString(), "utf-8");
   boolean bool1 = true;
   return bool1;
  }
  catch (Exception localException)
  {
   localException.printStackTrace();
   boolean bool2 = false;
   return bool2;
  }
  finally
  {
   if (localBufferedReader != null) {
    try
    {
     localBufferedReader.close();
    }
    catch (IOException localIOException3)
    {
     localIOException3.printStackTrace();
    }
   }
  }
 }
 
 public static boolean delProperties(String paramString1, String paramString2)
 {
  StringBuffer localStringBuffer = new StringBuffer();
  BufferedReader localBufferedReader = null;
  try
  {
   localBufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(paramString1), "utf-8"));
   String str;
   while ((str = localBufferedReader.readLine()) != null) {
    if (!str.startsWith(paramString2)) {
     localStringBuffer.append(str + "\r\n");
    }
   }
   writeFile(paramString1, localStringBuffer.toString(), "utf-8");
   boolean bool1 = true;
   return bool1;
  }
  catch (Exception localException)
  {
   localException.printStackTrace();
   boolean bool2 = false;
   return bool2;
  }
  finally
  {
   if (localBufferedReader != null) {
    try
    {
     localBufferedReader.close();
    }
    catch (IOException localIOException3)
    {
     localIOException3.printStackTrace();
    }
   }
  }
 }
 
 public static List<Class<?>> getAllClassesByInterface(Class<?> paramClass, boolean paramBoolean)
  throws IOException, ClassNotFoundException, IllegalStateException
 {
  if (!paramClass.isInterface()) {
   throw new IllegalStateException("Class not a interface.");
  }
  ClassLoader localClassLoader = paramClass.getClassLoader();
  String str = paramBoolean ? paramClass.getPackage().getName() : "/";
  return findClasses(paramClass, localClassLoader, str);
 }
 
 private static List<Class<?>> findClasses(Class<?> paramClass, ClassLoader paramClassLoader, String paramString)
  throws IOException, ClassNotFoundException
 {
  ArrayList localArrayList = new ArrayList();
  String str = paramString.replace(".", "/");
  Object localObject;
  if (!str.equals("/"))
  {
   localObject = paramClassLoader.getResources(str);
   while (((Enumeration)localObject).hasMoreElements())
   {
    URL localURL = (URL)((Enumeration)localObject).nextElement();
    localArrayList.addAll(findResources(paramClass, new File(localURL.getFile()), paramString));
   }
  }
  else
  {
   localObject = paramClassLoader.getResource("").getPath();
   localArrayList.addAll(findResources(paramClass, new File((String)localObject), paramString));
  }
  return localArrayList;
 }
 
 private static List<Class<?>> findResources(Class<?> paramClass, File paramFile, String paramString)
  throws ClassNotFoundException
 {
  ArrayList localArrayList = new ArrayList();
  if (!paramFile.exists()) {
   return Collections.EMPTY_LIST;
  }
  File[] arrayOfFile1 = paramFile.listFiles();
  for (File localFile : arrayOfFile1) {
   if (localFile.isDirectory())
   {
    if (!localFile.getName().contains(".")) {
     if (!paramString.equals("/")) {
      localArrayList.addAll(findResources(paramClass, localFile, paramString + "." + localFile.getName()));
     } else {
      localArrayList.addAll(findResources(paramClass, localFile, localFile.getName()));
     }
    }
   }
   else if (localFile.getName().endsWith(".class"))
   {
    Class localClass = null;
    if (!paramString.equals("/")) {
     localClass = Class.forName(paramString + "." + localFile.getName().substring(0, localFile.getName().length() - 6));
    } else {
     localClass = Class.forName(localFile.getName().substring(0, localFile.getName().length() - 6));
    }
    if ((paramClass.isAssignableFrom(localClass)) && (!paramClass.equals(localClass))) {
     localArrayList.add(localClass);
    }
   }
  }
  return localArrayList;
 }
 
 public static Object cloneObject(Object paramObject)
  throws Exception
 {
  ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream();
  ObjectOutputStream localObjectOutputStream = new ObjectOutputStream(localByteArrayOutputStream);
  localObjectOutputStream.writeObject(paramObject);
  ByteArrayInputStream localByteArrayInputStream = new ByteArrayInputStream(localByteArrayOutputStream.toByteArray());
  ObjectInputStream localObjectInputStream = new ObjectInputStream(localByteArrayInputStream);
  return localObjectInputStream.readObject();
 }
 
 public static boolean isFileType(String paramString1, String paramString2)
 {
  boolean bool = false;
  if (("IMAGE".equals(paramString2)) && ((paramString1.toUpperCase().equals("JPG")) || (paramString1.toUpperCase().equals("PNG")) || (paramString1.toUpperCase().equals("GIF")) || (paramString1.toUpperCase().equals("JPEG")))) {
   bool = true;
  }
  return bool;
 }
 
 public static boolean isFileType(String paramString, String[] paramArrayOfString)
 {
  boolean bool = false;
  if ((paramArrayOfString != null) && (paramArrayOfString.length > 0)) {
   for (int i = 0; i < paramArrayOfString.length; i++) {
    if (paramString.toUpperCase().equals(paramArrayOfString[i].toUpperCase())) {
     return true;
    }
   }
  }
  return bool;
 }
 
 public static boolean isErrorFileType(String paramString)
 {
  String[] arrayOfString = null;
  String str = AppConfigUtil.get("File_Filter_Val");
  if ((AppConfigUtil.getICache("FILEFILTER_KEY") == null) && (str != null))
  {
   arrayOfString = str.split("\\|");
   AppConfigUtil.setICache("FILEFILTER_KEY", arrayOfString);
  }
  else
  {
   arrayOfString = (String[])AppConfigUtil.getICache("FILEFILTER_KEY");
  }
  return isFileType(paramString, arrayOfString);
 }
}