// File: ContentRule.java
package com.example.filecleaner.rule;
 
/** 內(nèi)容刪除規(guī)則接口 */
public interface ContentRule {
    /** 判斷該行是否應(yīng)被刪除 */
    boolean matches(String line);
}
 
// File: StringRule.java
package com.example.filecleaner.rule;
 
/** 簡(jiǎn)單字符串匹配規(guī)則 */
public class StringRule implements ContentRule {
    private final String target;
    public StringRule(String target) { this.target = target; }
    @Override public boolean matches(String line) {
        return line.contains(target);
    }
}
 
// File: RegexRule.java
package com.example.filecleaner.rule;
 
import java.util.regex.*;
 
/** 正則表達(dá)式匹配規(guī)則 */
public class RegexRule implements ContentRule {
    private final Pattern pattern;
    public RegexRule(String regex) { this.pattern = Pattern.compile(regex); }
    @Override public boolean matches(String line) {
        return pattern.matcher(line).find();
    }
}
 
// File: PrefixRule.java
package com.example.filecleaner.rule;
 
/** 行首匹配規(guī)則 */
public class PrefixRule implements ContentRule {
    private final String prefix;
    public PrefixRule(String prefix) { this.prefix = prefix; }
    @Override public boolean matches(String line) {
        return line.startsWith(prefix);
    }
}
 
// File: SuffixRule.java
package com.example.filecleaner.rule;
 
/** 行尾匹配規(guī)則 */
public class SuffixRule implements ContentRule {
    private final String suffix;
    public SuffixRule(String suffix) { this.suffix = suffix; }
    @Override public boolean matches(String line) {
        return line.endsWith(suffix);
    }
}
 
// File: BlankRule.java
package com.example.filecleaner.rule;
 
/** 空行匹配規(guī)則 */
public class BlankRule implements ContentRule {
    private final boolean trimOnly;
    public BlankRule(boolean trimOnly) { this.trimOnly = trimOnly; }
    @Override public boolean matches(String line) {
        return trimOnly ? line.trim().isEmpty() : line.isEmpty();
    }
}
 
// File: FileCleanTask.java
package com.example.filecleaner.task;
 
import com.example.filecleaner.rule.ContentRule;
import org.slf4j.*;
import java.io.*;
import java.nio.charset.*;
import java.nio.file.*;
import java.util.concurrent.*;
 
/** 單文件清理任務(wù) */
public class FileCleanTask implements Callable<FileCleanResult> {
    private static final Logger logger = LoggerFactory.getLogger(FileCleanTask.class);
    private final Path file;
    private final ContentRule rule;
    private final Charset charset;
    private final boolean backup;
 
    public FileCleanTask(Path file, ContentRule rule, Charset charset, boolean backup) {
        this.file = file; this.rule = rule; this.charset = charset; this.backup = backup;
    }
 
    @Override
    public FileCleanResult call() {
        long total = 0, deleted = 0;
        Path temp = file.resolveSibling(file.getFileName()+".tmp");
        try (BufferedReader br = Files.newBufferedReader(file, charset);
             BufferedWriter bw = Files.newBufferedWriter(temp, charset)) {
            String line;
            while ((line = br.readLine()) != null) {
                total++;
                if (rule.matches(line)) {
                    deleted++;
                } else {
                    bw.write(line); bw.newLine();
                }
            }
        } catch (IOException e) {
            logger.error("處理文件出錯(cuò) {}", file, e);
            return new FileCleanResult(file, total, deleted, false);
        }
        try {
            if (backup) Files.copy(file, file.resolveSibling(file.getFileName()+".bak"),
                                   StandardCopyOption.REPLACE_EXISTING);
            Files.move(temp, file, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException e) {
            logger.error("替換原文件出錯(cuò) {}", file, e);
            return new FileCleanResult(file, total, deleted, false);
        }
        return new FileCleanResult(file, total, deleted, true);
    }
}
 
// File: FileCleanResult.java
package com.example.filecleaner.task;
 
import java.nio.file.*;
 
/** 單文件清理結(jié)果 */
public class FileCleanResult {
    public final Path file;
    public final long totalLines;
    public final long deletedLines;
    public final boolean success;
    public FileCleanResult(Path file, long totalLines, long deletedLines, boolean success) {
        this.file = file; this.totalLines = totalLines;
        this.deletedLines = deletedLines; this.success = success;
    }
}
 
// File: FileCleaner.java
package com.example.filecleaner.core;
 
import com.example.filecleaner.rule.*;
import com.example.filecleaner.task.*;
import org.slf4j.*;
import java.nio.charset.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
 
/** 核心清理器，管理任務(wù)調(diào)度 */
public class FileCleaner {
    private static final Logger logger = LoggerFactory.getLogger(FileCleaner.class);
    private final ContentRule rule;
    private final Charset charset;
    private final boolean backup;
    private final ExecutorService pool;
 
    public FileCleaner(ContentRule rule, Charset charset, boolean backup, int threads) {
        this.rule = rule; this.charset = charset; this.backup = backup;
        this.pool = Executors.newFixedThreadPool(threads);
    }
 
    public List<FileCleanResult> clean(Path root) throws IOException, InterruptedException {
        List<Path> files = new ArrayList<>();
        Files.walkFileTree(root, new SimpleFileVisitor<>() {
            @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                if (Files.isRegularFile(file)) files.add(file);
                return FileVisitResult.CONTINUE;
            }
        });
        List<Future<FileCleanResult>> futures = new ArrayList<>();
        for (Path f : files) {
            futures.add(pool.submit(new FileCleanTask(f, rule, charset, backup)));
        }
        pool.shutdown(); pool.awaitTermination(1, TimeUnit.HOURS);
 
        List<FileCleanResult> results = new ArrayList<>();
        for (Future<FileCleanResult> f : futures) {
            try { results.add(f.get()); }
            catch (ExecutionException e) {
                logger.error("任務(wù)執(zhí)行異常", e.getCause());
            }
        }
        return results;
    }
}
 
// File: FileCleanerCLI.java
package com.example.filecleaner;
 
import com.example.filecleaner.rule.*;
import com.example.filecleaner.core.FileCleaner;
import org.apache.commons.cli.*;
import java.nio.charset.*;
import java.nio.file.*;
import java.util.*;
 
/** 命令行入口 */
public class FileCleanerCLI {
    public static void main(String[] args) {
        Options opts = new Options();
        opts.addRequiredOption("p","path",true,"文件或目錄路徑");
        opts.addRequiredOption("t","ruleType",true,"規(guī)則類型: string|regex|prefix|suffix|blank");
        opts.addRequiredOption("r","rule",true,"規(guī)則內(nèi)容");
        opts.addOption("b","backup",true,"是否備份原文件，默認(rèn)true");
        opts.addOption("e","encoding",true,"文件編碼，默認(rèn)UTF-8");
        opts.addOption("n","threads",true,"線程數(shù)，默認(rèn)4");
        opts.addOption("h","help",false,"幫助");
        try {
            CommandLine cmd = new DefaultParser().parse(opts, args);
            if (cmd.hasOption("h")) {
                new HelpFormatter().printHelp("file-cleaner", opts);
                return;
            }
            Path path = Paths.get(cmd.getOptionValue("p"));
            String type = cmd.getOptionValue("t");
            String ruleText = cmd.getOptionValue("r");
            boolean backup = Boolean.parseBoolean(cmd.getOptionValue("b","true"));
            Charset cs = Charset.forName(cmd.getOptionValue("e","UTF-8"));
            int threads = Integer.parseInt(cmd.getOptionValue("n","4"));
 
            ContentRule rule = switch(type) {
                case "string" -> new StringRule(ruleText);
                case "regex"  -> new RegexRule(ruleText);
                case "prefix" -> new PrefixRule(ruleText);
                case "suffix" -> new SuffixRule(ruleText);
                case "blank"  -> new BlankRule(Boolean.parseBoolean(ruleText));
                default -> throw new IllegalArgumentException("未知規(guī)則類型");
            };
 
            FileCleaner cleaner = new FileCleaner(rule, cs, backup, threads);
            List<?> results = cleaner.clean(path);
            results.forEach(r -> System.out.println(r));
        } catch (Exception e) {
            System.err.println("執(zhí)行出錯(cuò): " + e.getMessage());
        }
    }
}
 
// File: FileCleanerTest.java
package com.example.filecleaner;
 
import com.example.filecleaner.rule.*;
import com.example.filecleaner.core.*;
import org.junit.jupiter.api.*;
import java.nio.charset.*;
import java.nio.file.*;
import java.util.*;
import static org.junit.jupiter.api.Assertions.*;
 
/** JUnit 單元測(cè)試 */
public class FileCleanerTest {
    @TempDir Path tmp;
 
    @Test
    void testStringRuleDeletion() throws Exception {
        Path file = tmp.resolve("test.txt");
        Files.writeString(file, "keep\nremove me\nkeep");
        FileCleaner cleaner = new FileCleaner(new StringRule("remove"), 
            StandardCharsets.UTF_8, true, 1);
        List<?> results = cleaner.clean(tmp);
        String content = Files.readString(file);
        assertFalse(content.contains("remove me"));
        assertTrue(Files.exists(tmp.resolve("test.txt.bak")));
    }
 
    @Test
    void testRegexRuleDeletion() throws Exception {
        Path file = tmp.resolve("r.txt");
        Files.writeString(file, "123 abc\n456 def\n789 ghi");
        FileCleaner cleaner = new FileCleaner(new RegexRule("\\d{3} abc"), 
            StandardCharsets.UTF_8, false, 1);
        cleaner.clean(tmp);
        String content = Files.readString(file);
        assertFalse(content.contains("abc"));
    }
 
    @Test
    void testBlankRuleDeletion() throws Exception {
        Path file = tmp.resolve("b.txt");
        Files.writeString(file, "\n\nline\n \n");
        FileCleaner cleaner = new FileCleaner(new BlankRule(true), 
            StandardCharsets.UTF_8, false, 1);
        cleaner.clean(tmp);
        String content = Files.readString(file);
        assertTrue(content.contains("line"));
        assertFalse(content.split("\n")[0].isBlank());
    }
}