// File: src/main/java/com/example/Utf8ToUnicodeConverter.java
package com.example;
 
import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;
import java.nio.charset.*;
import java.nio.file.*;
import java.util.concurrent.*;
import java.util.function.Consumer;
 
/**
 * Utf8ToUnicodeConverter
 * 提供將 UTF-8 編碼的文本轉(zhuǎn)換為 Unicode 轉(zhuǎn)義字符串的靜態(tài)方法。
 */
public class Utf8ToUnicodeConverter {
 
    // 默認緩沖區(qū)大小 (8KB)
    private static final int DEFAULT_BUFFER_SIZE = 8192;
    // 默認線程數(shù) (可根據(jù) CPU 核心數(shù)調(diào)整)
    private static final int DEFAULT_THREAD_COUNT = Runtime.getRuntime().availableProcessors();
 
    /**
     * 單一字符串轉(zhuǎn)換，返回轉(zhuǎn)換結(jié)果
     * @param input 原始 UTF-8 文本
     * @return 轉(zhuǎn)換后的 Unicode 轉(zhuǎn)義文本
     */
    public static String convert(String input) {
        if (input == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder(input.length() * 2);
        for (int i = 0; i < input.length(); i++) {
            int codePoint = input.codePointAt(i);
            if (Character.isSupplementaryCodePoint(codePoint)) {
                // 對 Supplementary Plane 拆分代理對
                char[] surrogates = Character.toChars(codePoint);
                for (char ch : surrogates) {
                    sb.append(toUnicodeEscaped(ch));
                }
                i++; // 跳過低位代理
            } else {
                char ch = input.charAt(i);
                if (ch >= 0x20 && ch <= 0x7E) {
                    sb.append(ch);
                } else {
                    sb.append(toUnicodeEscaped(ch));
                }
            }
        }
        return sb.toString();
    }
 
    /**
     * 流式轉(zhuǎn)換 API
     * @param reader 任意字符讀取器
     * @param writer 任意字符寫出器
     * @param preserveAscii 是否保留 ASCII 可打印字符
     * @throws IOException IO 異常
     */
    public static void convert(Reader reader, Writer writer, boolean preserveAscii) throws IOException {
        BufferedReader br = new BufferedReader(reader);
        BufferedWriter bw = new BufferedWriter(writer);
        int ch;
        while ((ch = br.read()) != -1) {
            char c = (char) ch;
            if (preserveAscii && c >= 0x20 && c <= 0x7E) {
                bw.write(c);
            } else {
                bw.write(toUnicodeEscaped(c));
            }
        }
        bw.flush();
    }
 
    /**
     * 文件轉(zhuǎn)換，支持多線程
     * @param in 輸入文件路徑
     * @param out 輸出文件路徑
     * @param bufferSize 緩沖區(qū)大小
     * @param threadCount 線程數(shù)量
     * @param preserveAscii 是否保留 ASCII 可打印字符
     * @throws Exception 拋出異常
     */
    public static void convert(Path in, Path out, int bufferSize, int threadCount, boolean preserveAscii) throws Exception {
        long fileSize = Files.size(in);
        long chunkSize = fileSize / threadCount;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        ConcurrentMap<Integer, String> results = new ConcurrentHashMap<>();
        // 分片處理
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            final long start = index * chunkSize;
            final long end = (index == threadCount - 1) ? fileSize : (start + chunkSize);
            executor.submit(() -> {
                try (FileChannel fc = FileChannel.open(in, StandardOpenOption.READ)) {
                    ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
                    fc.position(start);
                    StringBuilder partSb = new StringBuilder((int) (end - start) * 2);
                    while (fc.position() < end) {
                        buffer.clear();
                        fc.read(buffer);
                        buffer.flip();
                        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
                        CharBuffer cb = decoder.decode(buffer);
                        for (int i1 = 0; i1 < cb.length(); i1++) {
                            char c = cb.get(i1);
                            if (preserveAscii && c >= 0x20 && c <= 0x7E) {
                                partSb.append(c);
                            } else {
                                partSb.append(toUnicodeEscaped(c));
                            }
                        }
                    }
                    results.put(index, partSb.toString());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        }
        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        // 按順序?qū)懭?
        try (BufferedWriter bw = Files.newBufferedWriter(out, StandardCharsets.UTF_8)) {
            for (int i = 0; i < threadCount; i++) {
                bw.write(results.get(i));
            }
        }
    }
 
    /**
     * 異步回調(diào)轉(zhuǎn)換
     * @param input 原始文本
     * @param callback 轉(zhuǎn)換完成后的回調(diào)
     */
    public static void convertAsync(String input, Consumer<String> callback) {
        CompletableFuture.supplyAsync(() -> convert(input))
                .thenAccept(callback);
    }
 
    /**
     * 將單個字符轉(zhuǎn)為 Unicode 轉(zhuǎn)義形式
     * @param ch 字符
     * @return 對應的 \\uXXXX 格式字符串
     */
    private static String toUnicodeEscaped(char ch) {
        return String.format("\\u%04X", (int) ch);
    }
}
 
// File: src/test/java/com/example/Utf8ToUnicodeConverterTest.java
package com.example;
 
import org.junit.jupiter.api.*;
import java.nio.file.*;
import static org.junit.jupiter.api.Assertions.*;
 
/**
 * Utf8ToUnicodeConverterTest
 * 單元測試，覆蓋 ASCII、中文、Supplementary Plane、空串等場景
 */
public class Utf8ToUnicodeConverterTest {
 
    @Test
    public void testAscii() {
        String input = "Hello, World!";
        String expected = "Hello, World!";
        assertEquals(expected, Utf8ToUnicodeConverter.convert(input));
    }
    
    @Test
    public void testChinese() {
        String input = "中文測試";
        String expected = "\\u4E2D\\u6587\\u6D4B\\u8BD5";
        assertEquals(expected, Utf8ToUnicodeConverter.convert(input));
    }
 
    @Test
    public void testSupplementaryPlane() {
        String input = "??"; // U+1F60A
        String result = Utf8ToUnicodeConverter.convert(input);
        assertTrue(result.contains("\\uD83D") && result.contains("\\uDE0A"));
    }
 
    @Test
    public void testEmpty() {
        assertNull(Utf8ToUnicodeConverter.convert((String) null));
        assertEquals("", Utf8ToUnicodeConverter.convert(""));
    }
}