import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.*;
import java.security.GeneralSecurityException;
import java.security.SecureRandom;

/**
 * 文件/目录加解密相关
 * @author: Nemo
 * @date: 2019/3/19.
 */
public class FileCrote {

  /**
   * 加密后的文件后缀
   */
  private static final String SUBFIX = ".enc";

  /**
   * 执行路径
   */
  private static String path = "";

  /**
   * 执行模式 1加密 2解密
   */
  private static String mode = "1";

  /**
   * 执行密码
   */
  private static String pass = "";

  private static String currentFilePath = null;

  /**
   * 根据路径加密文件
   * 1、如果是目录，则找它下面的文件进行加密
   * 2、如果是文件，则直接加密
   * @param path
   * @throws IOException
   */
  private static void encrypt(String path) throws IOException, GeneralSecurityException {
    System.out.println("开始处理"+path);
    File file = new File(path);
    if(!file.exists()){
      System.out.println("需加密的路径不存在:"+path);
      return;
    }
    if(file.isDirectory()){
      //目录则遍历其下的文件
      File[] files = file.listFiles();
      if(files == null){
        return;
      }
      for (File subFile : files) {
        encrypt(subFile.getAbsolutePath());
      }
    }else{
      //文件则直接加密
      encrypt(file);
    }
  }

  /**
   * 文件加密
   * @param file
   * @throws IOException
   */
  private static void encrypt(File file) throws IOException, GeneralSecurityException {
    String path = file.getAbsolutePath();
    if(path.endsWith(SUBFIX)){
      System.out.println("已加密文件不需再次加密"+path);
      return;
    }

    String encFilePath = path + SUBFIX;
    File encFile = new File(encFilePath);

    System.out.println("开始加密文件"+path);
    encryptFile(file,encFile,Cipher.ENCRYPT_MODE);
  }

  /**
   * 加解密文件操作
   * @param srcFile
   * @param encFile
   * @throws IOException
   */
  private static void encryptFile(File srcFile, File encFile,int mode) throws IOException, GeneralSecurityException {
    if(!srcFile.exists()){
      System.out.println("source file not exixt");
      return;
    }

    currentFilePath = srcFile.getAbsolutePath();

    //密码
    Cipher cipher = getCipher(mode);

    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
      fis = new FileInputStream(srcFile);
      fos = new FileOutputStream(encFile);

      //真正处理
      crypt(fis, fos, cipher);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      if (fis != null) {
        fis.close();
      }
      if (fos != null) {
        fos.close();
      }
    }

    //源文件删除
    srcFile.delete();
  }

  /**
   * 得到加解密Cipher
   * @param mode
   * @return
   * @throws GeneralSecurityException
   */
  private static Cipher getCipher(int mode) throws GeneralSecurityException {
    String type = "AES";
    Cipher cipher = Cipher.getInstance(type+"/ECB/PKCS5Padding");
    KeyGenerator kgen = KeyGenerator.getInstance(type);
    kgen.init(128, new SecureRandom(pass.getBytes()));
    SecretKey key = kgen.generateKey();
    cipher.init(mode,key);
    return cipher;
  }

  /**
   * 加密解密流
   * @param in    加密解密前的流
   * @param out    加密解密后的流
   * @param cipher  加密解密
   * @throws IOException
   * @throws GeneralSecurityException
   */
  private static void crypt(InputStream in, OutputStream out, Cipher cipher) throws IOException, GeneralSecurityException {
    int blockSize = cipher.getBlockSize() * 1000;
    int outputSize = cipher.getOutputSize(blockSize);

    byte[] inBytes = new byte[blockSize];
    byte[] outBytes = new byte[outputSize];

    int inLength = 0;
    boolean more = true;
    while (more) {
      inLength = in.read(inBytes);
      if (inLength == blockSize) {
        int outLength = cipher.update(inBytes, 0, blockSize, outBytes);
        out.write(outBytes, 0, outLength);
      } else {
        more = false;
      }
    }
    if (inLength > 0) {
      outBytes = cipher.doFinal(inBytes, 0, inLength);
    } else {
      outBytes = cipher.doFinal();
    }
    out.write(outBytes);
  }

  /**
   * 根据路径解密
   * 1、如果是目录，则找它下面的加密文件进行解密
   * 2、如果是文件，并且它是加密文件，则直接解密
   * @param path
   * @throws IOException
   */
  private static void decrypt(String path) throws IOException, GeneralSecurityException {
    System.out.println("开始处理"+path);
    File file = new File(path);
    if(!file.exists()){
      System.out.println("需解密的路径不存在:"+path);
      return;
    }
    if(file.isDirectory()){
      //目录则遍历其下的文件
      File[] files = file.listFiles();
      if(files == null){
        return;
      }
      for (File subFile : files) {
        decrypt(subFile.getAbsolutePath());
      }
    }else{
      decrypt(file);
    }
  }

  /**
   * 文件解密
   * @param file
   * @throws IOException
   */
  private static void decrypt(File file) throws IOException, GeneralSecurityException {
    String path = file.getAbsolutePath();
    if(!path.endsWith(SUBFIX)){
      System.out.println("非加密文件不需解密"+path);
      return;
    }
    System.out.println("开始解密文件"+path);

    String newPath = path.substring(0,path.length() - SUBFIX.length());
    encryptFile(file,new File(newPath),Cipher.DECRYPT_MODE);
  }

  /**
   * 字符串是否非空
   * @param s
   * @return
   */
  private static boolean isNotEmpty(String s){
    if (s == null || "".equals(s)) {
      return false;
    }
    return true;
  }

  /**
   * 开始处理
   * @throws IOException
   * @throws GeneralSecurityException
   */
  private static void deal() throws IOException, GeneralSecurityException {
    while (true) {
      print();
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
      String s = reader.readLine();
      if("path".equals(s)) {
        System.out.println("\r\n请输入执行路径\r\n");
        while (true) {
          reader = new BufferedReader(new InputStreamReader(System.in));
          s = reader.readLine();
          if (!isNotEmpty(s)) {
            System.out.println("\r\n请输入执行路径\r\n");
            continue;
          }else {
            File file = new File(s);
            if(!file.exists()){
              System.out.println("\r\n该路径不存在，请重新输入\r\n");
              continue;
            }
          }
          path = s;
          break;
        }
      } else if("pass".equals(s)) {
        System.out.println("\r\n请输入加/解密密码\r\n");
        while (true) {
          reader = new BufferedReader(new InputStreamReader(System.in));
          s = reader.readLine();
          if (!isNotEmpty(s)) {
            System.out.println("\r\n请输入加/解密密码\r\n");
            continue;
          }
          pass = s;
          break;
        }
      } else if ("1".equals(s)) {
        mode = s;
        System.out.println("\r\n当前已选模式：加密\n");
      } else if ("2".equals(s)) {
        mode = s;
        System.out.println("\r\n当前已选模式：解密\r\n");
      }else if("start".equals(s)){
        if(!isNotEmpty(path)) {
          System.out.println("\r\n请输入加/解密密码再开始\r\n");
          continue;
        }

        if(!isNotEmpty(pass)) {
          System.out.println("\r\n请输入执行路径后再开始\r\n");
          continue;
        }

        if ("1".equals(mode)) {
          encrypt(path);
          System.out.println("\r\n\r\n操作完成\r\n\r\n");
        } else {
          try {
            decrypt(path);
            System.out.println("\r\n\r\n操作完成\r\n\r\n");
          }catch (BadPaddingException e) {
            System.out.println("文件："+currentFilePath+"解密失败，密码错误");
          }
        }
      }else if("quit".equals(s)){
        System.exit(-1);
      } else {
        System.out.println("\r\n输入错误\r\n");
      }
    }
  }

  /**
   * 输出提示语
   */
  private static void print(){
    System.out.println("\r\n" +
        "输入path开始选择执行路径\r\n" +
        "输入pass开始选择加/解密密码\r\n" +
        "输入如下数字以选择处理模式：1 加密 2 解密\r\n" +
        "输入start则开始执行已选操作\r\n" +
        "输入quit则退出程序\r\n" +
        "当前选择路径："+path+"\r\n" +
        "当前选择模式："+mode+"\r\n" +
        "当前选择密码："+pass+"\r\n");
  }

  public static void main(String args[]) throws IOException, GeneralSecurityException {
    deal();
  }

}