package com.mini.capi.utils;

import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.UUID;

public class FileUtils {

    // 附件根目录（需求指定）
    public static final String ATTACHMENT_ROOT_DIR = "/ogsapp/mailFiles";

    /**
     * 检查目录是否存在，不存在则创建
     */
    public static void checkDirExists(String dirPath) {
        File dir = new File(dirPath);
        if (!dir.exists()) {
            boolean mkdirs = dir.mkdirs();
            if (!mkdirs) {
                throw new RuntimeException("创建目录失败：" + dirPath);
            }
        }
    }

    /**
     * 保存文件到指定路径
     *
     * @param inputStream 输入流（附件流）
     * @param savePath    保存路径（含文件名）
     */
    public static void saveFile(InputStream inputStream, String savePath) {
        checkDirExists(Paths.get(savePath).getParent().toString()); // 检查父目录
        try (OutputStream os = new FileOutputStream(savePath);
             BufferedInputStream bis = new BufferedInputStream(inputStream);
             BufferedOutputStream bos = new BufferedOutputStream(os)) {

            byte[] buffer = new byte[1024 * 8];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            bos.flush();
        } catch (IOException e) {
            throw new RuntimeException("保存文件失败：" + savePath, e);
        }
    }

    /**
     * 生成32位随机文件名（UUID去掉横线）+ 原始文件后缀
     *
     * @param originalFileName 原始文件名
     * @return 32位随机文件名（如：a1b2c3d4...1234.txt）
     */
    public static String generate32RandomFileName(String originalFileName) {
        // 获取文件后缀（如.txt）
        String suffix = "";
        if (StringUtils.hasText(originalFileName) && originalFileName.contains(".")) {
            suffix = originalFileName.substring(originalFileName.lastIndexOf("."));
        }
        // 生成32位UUID（去掉横线）
        String random32Str = UUID.randomUUID().toString().replace("-", "");
        return random32Str + suffix;
    }

    /**
     * 获取文件大小（字节）
     */
    public static long getFileSize(File file) {
        try {
            return Files.size(file.toPath());
        } catch (IOException e) {
            throw new RuntimeException("获取文件大小失败", e);
        }
    }


    public static MultipartFile[] getMultipartFiles(String filePath) {
        // 1. 校验路径合法性
        if (filePath == null || filePath.trim().isEmpty()) {
            throw new IllegalArgumentException("文件路径不能为空");
        }
        File dir = new File(filePath);
        if (!dir.exists()) {
            throw new IllegalArgumentException("目录不存在：" + filePath);
        }
        if (!dir.isDirectory()) {
            throw new IllegalArgumentException("路径不是目录：" + filePath);
        }

        // 2. 筛选目录下的所有文件（排除子目录）
        File[] localFiles = dir.listFiles(File::isFile);
        if (localFiles == null || localFiles.length == 0) {
            return new MultipartFile[0];
        }

        // 3. 包装本地File为MultipartFile并组装数组
        MultipartFile[] result = new MultipartFile[localFiles.length];
        for (int i = 0; i < localFiles.length; i++) {
            File file = localFiles[i];
            result[i] = new MultipartFile() {
                @Override
                public String getName() {
                    return file.getName(); // 文件名（与原始文件名一致，满足基础场景）
                }

                @Override
                public String getOriginalFilename() {
                    return file.getName(); // 原始文件名（本地文件即自身文件名）
                }

                @Override
                public String getContentType() {
                    // 推断文件MIME类型，失败时返回默认二进制类型
                    try {
                        return Files.probeContentType(file.toPath());
                    } catch (IOException e) {
                        return "application/octet-stream";
                    }
                }

                @Override
                public boolean isEmpty() {
                    return file.length() == 0; // 空文件判断（大小为0）
                }

                @Override
                public long getSize() {
                    return file.length(); // 文件大小（字节）
                }

                @Override
                public byte[] getBytes() throws IOException {
                    return Files.readAllBytes(file.toPath()); // 读取文件字节数组
                }

                @Override
                public InputStream getInputStream() throws IOException {
                    return Files.newInputStream(file.toPath()); // 获取文件输入流
                }

                @Override
                public void transferTo(File dest) throws IOException, IllegalStateException {
                    Files.copy(file.toPath(), dest.toPath()); // 复制文件到目标路径
                }
            };
        }
        return result;
    }

    public static String getFileType(String fileName) {
        if (fileName == null || fileName.isEmpty()) {
            return "unknown";
        }

        String extension = fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();

        switch (extension) {
            case "pdf":
                return "pdf";
            case "doc":
            case "docx":
                return "word";
            case "xls":
            case "xlsx":
                return "excel";
            case "ppt":
            case "pptx":
                return "ppt";
            case "jpg":
            case "jpeg":
            case "png":
            case "gif":
                return "image";
            case "mp4":
            case "avi":
            case "mov":
                return "video";
            case "mp3":
            case "wav":
                return "audio";
            default:
                // 如果没有扩展名，视为文件夹
                if (!fileName.contains(".")) {
                    return "folder";
                }
                return "unknown";
        }
    }

    // 格式化文件大小（字节转人类可读格式）
    public static String formatFileSize(long bytes) {
        if (bytes < 1024) {
            return bytes + " B";
        } else if (bytes < 1024 * 1024) {
            return String.format("%.1f KB", bytes / 1024.0);
        } else if (bytes < 1024 * 1024 * 1024) {
            return String.format("%.1f MB", bytes / (1024.0 * 1024));
        } else {
            return String.format("%.1f GB", bytes / (1024.0 * 1024 * 1024));
        }
    }
}