/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 opennlp.tools.similarity.apps.utils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Logger;

/**
 * This class responsible to save data to files as well as read out! It is
 * capable to handle text and binary files.
 */
public class FileHandler {

  private static Logger LOG = Logger
      .getLogger("opennlp.tools.similarity.apps.utils.FileHandler");

  public void writeToTextFile(String data, String filepath, boolean append)
      throws IOException {
    try {
      BufferedWriter out = new BufferedWriter(new FileWriter(filepath, append));
      out.write(data + "\n");
      out.close();
    } catch (IOException e) {
      LOG.severe(e.toString());
      e.printStackTrace();
    }
  }

  /**
   * Writes data from an arrayList<String> to a text-file where each line of the
   * text represented by an element in the list.
   * 
   * @param list
   * @param filePath
   * @param append
   * @throws Exception
   */
  public void writeToTextFile(ArrayList<String> list, String filePath,
      boolean append) throws Exception {
    FileWriter outFile = null;
    Iterator<String> it = list.iterator();
    if (!append) {
      outFile = new FileWriter(filePath);
      PrintWriter out = new PrintWriter(outFile);
      while (it.hasNext()) {
        out.println((String) it.next());
      }
      outFile.close();
    } else {
      int tmp = 0;
      while (it.hasNext()) {
        if (tmp == 0) {
          appendtofile("\n" + (String) it.next(), filePath);
        } else {
          appendtofile((String) it.next(), filePath);
        }
        tmp++;
      }
    }
  }

  public void writeObjectToFile(Object obj, String filepath, boolean append) {
    if (!isFileOrDirectoryExists(getDirPathfromFullPath(filepath))) {
      createFolder(getDirPathfromFullPath(filepath));
    }
    ObjectOutputStream outputStream = null;
    try {
      outputStream = new ObjectOutputStream(new FileOutputStream(filepath));
      outputStream.writeObject(obj);
    } catch (IOException e) {
      LOG.severe(e.toString());
    }
  }

  public Object readObjectfromFile(String filePath) {
    ObjectInputStream inputStream = null;
    try {
      // Construct the ObjectInputStream object
      inputStream = new ObjectInputStream(new FileInputStream(filePath));
      Object obj = null;
      while ((obj = inputStream.readObject()) != null) {
        return obj;
      }
    } catch (EOFException ex) { // This exception will be caught when EOF is
                                // reached
      LOG.severe("End of file reached.\n" + ex.toString());
    } catch (ClassNotFoundException ex) {
      LOG.severe(ex.toString());
    } catch (FileNotFoundException ex) {
      LOG.severe(ex.toString());
    } catch (IOException ex) {
      LOG.severe(ex.toString());
    } finally {
      // Close the ObjectInputStream
      try {
        if (inputStream != null) {
          inputStream.close();
        }
      } catch (IOException ex) {
        LOG.severe(ex.toString());
      }
    }
    return null;
  }

  /**
   * Creates a byte array from any object.
   * 
   * I wanted to use it when I write out object to files! (This is not in use
   * right now, I may move it into other class)
   * 
   * @param obj
   * @return
   * @throws java.io.IOException
   */
  public byte[] getBytes(Object obj) throws java.io.IOException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(obj);
    oos.flush();
    oos.close();
    bos.close();
    byte[] data = bos.toByteArray();
    return data;
  }

  /**
   * Fetches all content from a text file, and return it as a String.
   * 
   * @return
   */
  public String readFromTextFile(String filePath) {
    StringBuilder contents = new StringBuilder();
    // ...checks on aFile are edited
    File aFile = new File(filePath);

    try {
      // use buffering, reading one line at a time
      // FileReader always assumes default encoding is OK!
      // TODO be sure that the default encoding is OK!!!!! Otherwise
      // change it

      BufferedReader input = new BufferedReader(new FileReader(aFile));
      try {
        String line = null; // not declared within while loop
        /*
         * readLine is a bit quirky : it returns the content of a line MINUS the
         * newline. it returns null only for the END of the stream. it returns
         * an empty String if two newlines appear in a row.
         */
        while ((line = input.readLine()) != null) {
          contents.append(line);
          contents.append(System.getProperty("line.separator"));
        }
      } finally {
        input.close();
      }
    } catch (IOException ex) {
      LOG.severe("fileName: " + filePath +"\n " + ex);
    }
    return contents.toString();
  }

  /**
   * Reads text file line-wise each line will be an element in the resulting
   * list
   * 
   * @param filePath
   * @return
   */
  public List<String> readLinesFromTextFile(String filePath) {
    List<String> lines = new ArrayList<String>();
    // ...checks on aFile are edited
    File aFile = new File(filePath);
    try {
      // use buffering, reading one line at a time
      // FileReader always assumes default encoding is OK!
      // TODO be sure that the default encoding is OK!!!!! Otherwise
      // change it

      BufferedReader input = new BufferedReader(new FileReader(aFile));
      try {
        String line = null; // not declared within while loop
        /*
         * readLine is a bit quirky : it returns the content of a line MINUS the
         * newline. it returns null only for the END of the stream. it returns
         * an empty String if two newlines appear in a row.
         */
        while ((line = input.readLine()) != null) {
          lines.add(line);
        }
      } finally {
        input.close();
      }
    } catch (IOException ex) {
      LOG.severe(ex.toString());
    }
    return lines;
  }

  private void appendtofile(String data, String filePath) {
    try {
      BufferedWriter out = new BufferedWriter(new FileWriter(filePath, true));
      out.write(data + "\n");
      out.close();
    } catch (IOException e) {
    }
  }

  public void createFolder(String path) {
    if (!isFileOrDirectoryExists(path)) {
      File file = new File(path);
      try {
        file.mkdirs();
      } catch (Exception e) {
        LOG.severe("Directory already exists or the file-system is read only");
      }
    }
  }

  public boolean isFileOrDirectoryExists(String path) {
    File file = new File(path);
    boolean exists = file.exists();
    return exists;
  }

  /**
   * Separates the directory-path from a full file-path
   * 
   * @param filePath
   * @return
   */
  private String getDirPathfromFullPath(String filePath) {
    String dirPath = "";
    if (filePath != null) {
      if (filePath != "" && filePath.contains("\\"))
        dirPath = filePath.substring(0, filePath.lastIndexOf("\\"));
    }
    return dirPath;
  }

  /**
   * Returns the file-names of the files in a folder (not paths only names) (Not
   * recursive)
   * 
   * @param dirPath
   * @return
   */
  public ArrayList<String> getFileNamesInFolder(String dirPath) {
    ArrayList<String> fileNames = new ArrayList<String>();

    File folder = new File(dirPath);
    File[] listOfFiles = folder.listFiles();

    for (int i = 0; i < listOfFiles.length; i++) {
      if (listOfFiles[i].isFile()) {
        fileNames.add(listOfFiles[i].getName());
      } else if (listOfFiles[i].isDirectory()) {
        // TODO if I want to use it recursive I should handle this case
      }
    }
    return fileNames;
  }

  public void deleteAllfilesinDir(String dirName) {
    ArrayList<String> fileNameList = getFileNamesInFolder(dirName);
    if (fileNameList != null) {
      for (int i = 0; i < fileNameList.size(); i++) {
        try {
          deleteFile(dirName + fileNameList.get(i));
        } catch (IllegalArgumentException e) {
          LOG.severe("No way to delete file: " + dirName + fileNameList.get(i) + "\n"+
              e);
        }
      }
    }
  }

  public void deleteFile(String filePath) throws IllegalArgumentException {
    // A File object to represent the filename
    File f = new File(filePath);
    // Make sure the file or directory exists and isn't write protected
    if (!f.exists())
      throw new IllegalArgumentException("Delete: no such file or directory: "
          + filePath);

    if (!f.canWrite())
      throw new IllegalArgumentException("Delete: write protected: " + filePath);
    // If it is a directory, make sure it is empty
    if (f.isDirectory()) {
      String[] files = f.list();
      if (files.length > 0)
        throw new IllegalArgumentException("Delete: directory not empty: "
            + filePath);
    }
    // Attempt to delete it
    boolean success = f.delete();
    if (!success)
      throw new IllegalArgumentException("Delete: deletion failed");
  }

  public boolean deleteDirectory(File path) {
    if (path.exists()) {
      File[] files = path.listFiles();
      for (int i = 0; i < files.length; i++) {
        if (files[i].isDirectory()) {
          deleteDirectory(files[i]);
        } else {
          files[i].delete();
        }
      }
    }
    return (path.delete());
  }

  /**
   * Returns the absolute-file-paths of the files in a directory (not recursive)
   * 
   * @param dirPath
   * @return
   */
  public ArrayList<String> getFilePathsInFolder(String dirPath) {
    ArrayList<String> filePaths = new ArrayList<String>();

    File folder = new File(dirPath);
    File[] listOfFiles = folder.listFiles();
    if (listOfFiles == null)
      return null;
    for (int i = 0; i < listOfFiles.length; i++) {
      if (listOfFiles[i].isFile()) {
        filePaths.add(listOfFiles[i].getAbsolutePath());
      } else if (listOfFiles[i].isDirectory()) {
        // TODO if I want to use it recursive I should handle this case
      }
    }
    return filePaths;
  }

  /**
   * Returns the number of individual files in a directory (Not ercursive)
   * 
   * @param dirPath
   * @return
   */
  public int getFileNumInFolder(String dirPath) {
    int num = 0;
    try {
      num = getFileNamesInFolder(dirPath).size();
    } catch (Exception e) {
      num = 0;
    }
    return num;
  }

}