package com.kj.test;

import cn.hutool.core.io.IoUtil;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.Locale;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 输入两个文件夹名称，将A文件夹内容全部拷贝到B文件夹，要求使用多线程来操作。
 */
public class FileTest10 {
    /**
     * 1、输入文件夹名称获得文件列表，可以使用之前写的类，不再重写。也可使用commons.io的方法
     * 2、多线程的使用，直接在方法中新建线程
     * 3、对整个文件夹复制，文件夹分隔符可以用\\或/，其他的都不对
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要复制的文件夹：");
        String fromDir = scanner.next();

        System.out.println("请输入复制文件夹存放位置：");
        String toDir = scanner.next();

        // 把输入地址转换为文件类型
        File fromFile = new File(fromDir);
        File toFile = new File(toDir);

        // 新建线程
       Thread thread =  new Thread(() -> {
            // 判断是否为文件，是则直接复制
            if (fromFile.isFile()) {
                System.out.println("复制单个文件");
                copy(fromFile, toFile);
            } else {
                // 要复制的是文件夹
                // 要防止一种无法复制的情况，如，把当前文件复制到自己的子文件夹中，
                // 把D:/java/jsp文件夹复制到D:/java/jsp/js文件夹里面，：这会是一个死循环，子文件夹增加的同时父文件夹也增加
                // 而反过来则没事，相当于简单的覆盖
                // 具体实现时，如果目标地址包含复制地址的文件夹，则不允许操作
                if (toDir.replace("/", "\\").toLowerCase(Locale.ROOT)
                        .startsWith(fromDir.replace("/", "\\").toLowerCase(Locale.ROOT))) {
                    return;
                }

                // 复制文件，包括文件和文件夹的操作
                //先获取所有的文件
                Collection<File> files = FileUtils.listFiles(fromFile, null, true);
                // 创建一个线程池，加快复制速度
                ExecutorService threadPool = Executors.newFixedThreadPool(20);

                for (File file : files) {
                    // 复制文件名
                    String name = file.getAbsolutePath();
                    // 把原来的文件路径换成新的文件路径
                    String toName = name.replace(fromFile.getParent(), toDir + "/");
                    System.out.println(name + "变成了 " + toName);

                    // 如果是文件夹，直接创建
                    if (file.isDirectory()) {
                        new File(toName).mkdirs();
                    } else {
                        // 如果是文件，在线程里面复制
                        threadPool.execute(new Runnable() {
                            @Override
                            public void run() {
                                File copyFile = new File(toName);
                                // 先要有父文件夹
                                copyFile.getParentFile().mkdirs();
                                // 开始复制文件
                                copy(file, copyFile);
                            }
                        });
                    }
                }
            }
            IoUtil.close(scanner);
        });

       // 开启线程
        thread.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
    }

    /**
     * 复制文件
     *
     * @param fromFile
     * @param toFile
     */
    private static void copy(File fromFile, File toFile) {
        // 定义一个输入流
        FileInputStream fis = null;
        // 定义一个输出流
        FileOutputStream fos = null;

        try {
            // 把复制的dir的文件，封装后赋值给输入流对象
            fis = new FileInputStream(fromFile);
            // 把目标地址的文件，封装后，赋值给输出流对象
            fos = new FileOutputStream(toFile);
            // 创建容器
            byte[] but = new byte[1024];
            int len = 0;
            while ((len = fis.read(but)) != -1) {
                // 边读边写,把输入流的内容写入输出流
                fos.write(but, 0, len);
            }

        } catch (IOException e) {
            e.getMessage();
        } finally {
            IoUtil.close(fis);
            IoUtil.close(fos);
        }
    }
}