public static List<File> filterBySize(File directory, long minBytes, long maxBytes);

// ============================================================================
// 文件：SizeParser.java
// 包名：com.example.filesizefilter
// 功能：將用戶輸入的大小閾值字符串（如 "1.5GB"、"1024KB"）解析為字節(jié)數(shù)
// ============================================================================
package com.example.filesizefilter;

import java.util.regex.*;
import com.example.filesizefilter.exception.FilterException;

public class SizeParser {
    // 支持單位：B、KB、MB、GB（大小寫均可）
    private static final Pattern PATTERN = Pattern.compile(
        "\\s*([0-9]+(?:\\.[0-9]+)?)\\s*(B|KB|MB|GB)?\\s*", Pattern.CASE_INSENSITIVE);

    /**
     * 將字符串表示的大小轉(zhuǎn)換為字節(jié)數(shù)
     * @param sizeStr 大小字符串，如 "512MB", "1.5 GB", "1024"
     * @return 對應的字節(jié)數(shù)
     */
    public static long parse(String sizeStr) {
        Matcher m = PATTERN.matcher(sizeStr);
        if (!m.matches()) {
            throw new FilterException("無法解析大小閾值：" + sizeStr);
        }
        double value = Double.parseDouble(m.group(1));
        String unit = m.group(2);
        if (unit == null || unit.equalsIgnoreCase("B")) {
            return (long) value;
        } else if (unit.equalsIgnoreCase("KB")) {
            return (long) (value * 1024L);
        } else if (unit.equalsIgnoreCase("MB")) {
            return (long) (value * 1024L * 1024L);
        } else if (unit.equalsIgnoreCase("GB")) {
            return (long) (value * 1024L * 1024L * 1024L);
        } else {
            throw new FilterException("不支持的單位：" + unit);
        }
    }
}

// ============================================================================
// 文件：FilterResult.java
// 包名：com.example.filesizefilter
// 功能：封裝過濾后文件及其大小信息
// ============================================================================
package com.example.filesizefilter;

import java.io.File;

public class FilterResult {
    private final File file;
    private final long size;

    public FilterResult(File file, long size) {
        this.file = file;
        this.size = size;
    }
    public File getFile() { return file; }
    public long getSize() { return size; }
}

// ============================================================================
// 文件：FileSizeFilter.java
// 包名：com.example.filesizefilter
// 功能：核心過濾類，支持按最小、最大閾值對文件或目錄遞歸掃描并行過濾
// ============================================================================
package com.example.filesizefilter;

import java.io.File;
import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.*;
import java.util.concurrent.*;
import com.example.filesizefilter.exception.FilterException;

public class FileSizeFilter {
    /**
     * 按閾值過濾單個文件
     * @param file      文件對象
     * @param minBytes  最小字節(jié)數(shù)（null 表示不限制）
     * @param maxBytes  最大字節(jié)數(shù)（null 表示不限制）
     * @return 如果符合條件返回 FilterResult，否則返回 null
     */
    public static FilterResult filter(File file, Long minBytes, Long maxBytes) {
        if (!file.isFile()) {
            throw new FilterException("不是文件：" + file.getPath());
        }
        long size = file.length();
        if ((minBytes == null || size >= minBytes) && (maxBytes == null || size <= maxBytes)) {
            return new FilterResult(file, size);
        }
        return null;
    }

    /**
     * 遞歸掃描目錄并按大小過濾，單線程實現(xiàn)
     */
    public static List<FilterResult> filterDirectory(File dir, Long minBytes, Long maxBytes) {
        if (!dir.isDirectory()) {
            throw new FilterException("不是目錄：" + dir.getPath());
        }
        List<FilterResult> results = new ArrayList<>();
        try {
            Files.walkFileTree(dir.toPath(), new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) {
                    long size = attrs.size();
                    if ((minBytes == null || size >= minBytes) && (maxBytes == null || size <= maxBytes)) {
                        results.add(new FilterResult(path.toFile(), size));
                    }
                    return FileVisitResult.CONTINUE;
                }
                @Override
                public FileVisitResult visitFileFailed(Path path, IOException exc) {
                    // 記錄日志并繼續(xù)
                    System.err.println("無法訪問文件：" + path + "，原因：" + exc.getMessage());
                    return FileVisitResult.CONTINUE;
                }
            });
        } catch (IOException e) {
            throw new FilterException("目錄掃描失敗：" + dir.getPath(), e);
        }
        return results;
    }

    /**
     * 并行掃描多個路徑（文件或目錄），使用線程池
     */
    public static List<FilterResult> filterPaths(
            List<File> paths, Long minBytes, Long maxBytes, int threadCount) {
        ExecutorService pool = Executors.newFixedThreadPool(threadCount);
        List<Future<List<FilterResult>>> futures = new ArrayList<>();
        for (File path : paths) {
            futures.add(pool.submit(() -> {
                if (path.isDirectory()) {
                    return filterDirectory(path, minBytes, maxBytes);
                } else if (path.isFile()) {
                    FilterResult r = filter(path, minBytes, maxBytes);
                    return r != null ? Collections.singletonList(r) : Collections.emptyList();
                } else {
                    throw new FilterException("路徑不存在：" + path.getPath());
                }
            }));
        }
        List<FilterResult> all = new ArrayList<>();
        for (Future<List<FilterResult>> f : futures) {
            try {
                all.addAll(f.get());
            } catch (Exception e) {
                System.err.println("任務執(zhí)行失?。? + e.getMessage());
            }
        }
        pool.shutdown();
        return all;
    }
}

// ============================================================================
// 文件：Main.java
// 包名：com.example.filesizefilter
// 功能：命令行入口，解析參數(shù)、調(diào)用過濾邏輯、輸出結(jié)果（支持排序與格式化導出）
// ============================================================================
package com.example.filesizefilter;

import java.io.*;
import java.util.*;
import com.example.filesizefilter.exception.FilterException;

public class Main {
    private static void printHelp() {
        System.out.println("Usage: java -jar filesizefilter.jar [options] <path1> <path2> ...");
        System.out.println("Options:");
        System.out.println("  --min <size>       最小閾值，如 10MB");
        System.out.println("  --max <size>       最大閾值，如 1GB");
        System.out.println("  -t, --threads <n>  并行線程數(shù)，默認 4");
        System.out.println("  -s, --sort <asc|desc>  按大小升序或降序排序，默認 asc");
        System.out.println("  -o, --output <file>    導出結(jié)果到文件（CSV 格式），默認輸出到控制臺");
        System.out.println("  -h, --help         顯示幫助信息");
    }

    public static void main(String[] args) {
        if (args.length == 0) { printHelp(); return; }
        Long minBytes = null, maxBytes = null;
        int threads = 4;
        boolean asc = true;
        String outputPath = null;
        List<String> paths = new ArrayList<>();

        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
                case "--min": minBytes = SizeParser.parse(args[++i]); break;
                case "--max": maxBytes = SizeParser.parse(args[++i]); break;
                case "-t": case "--threads": threads = Integer.parseInt(args[++i]); break;
                case "-s": case "--sort":
                    asc = args[++i].equalsIgnoreCase("asc"); break;
                case "-o": case "--output": outputPath = args[++i]; break;
                case "-h": case "--help": printHelp(); return;
                default: paths.add(args[i]);
            }
        }
        if (paths.isEmpty()) { System.err.println("未指定路徑"); printHelp(); return; }

        List<File> fileList = new ArrayList<>();
        for (String p : paths) fileList.add(new File(p));

        try {
            List<FilterResult> results = FileSizeFilter.filterPaths(
                fileList, minBytes, maxBytes, threads);

            // 排序
            results.sort(Comparator.comparingLong(FilterResult::getSize));
            if (!asc) Collections.reverse(results);

            // 輸出
            if (outputPath == null) {
                for (FilterResult r : results) {
                    System.out.printf("%s, %d%n", r.getFile().getPath(), r.getSize());
                }
            } else {
                try (PrintWriter pw = new PrintWriter(new FileWriter(outputPath))) {
                    pw.println("文件路徑,大小(字節(jié))");
                    for (FilterResult r : results) {
                        pw.printf("%s,%d%n", r.getFile().getPath(), r.getSize());
                    }
                }
                System.out.println("已導出到 " + outputPath);
            }
        } catch (FilterException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

// ============================================================================
// 文件：FilterException.java
// 包名：com.example.filesizefilter.exception
// 功能：統(tǒng)一異常類型，用于包裝解析與過濾過程中的錯誤
// ============================================================================
package com.example.filesizefilter.exception;

public class FilterException extends RuntimeException {
    public FilterException(String msg) { super(msg); }
    public FilterException(String msg, Throwable cause) { super(msg, cause); }
}