package com.yumu.noveltranslator.domain.service;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import jakarta.annotation.PreDestroy;

/**
 * 翻译后处理服务：检测译文中的残留中文并补充翻译
 */
@Service
@Slf4j
public class TranslationPostProcessingService {

    /** 残留中文检测正则：连续 2+ 个中文字符 */
    private static final Pattern CHINESE_PATTERN = Pattern.compile("[\u4e00-\u9fff\u3400-\u4dbf]{2,}");

    /** \u6b8b\u7559\u4e2d\u6587\u7edd\u5bf9\u4e0a\u9650\uff08\u5b57\u7b26\u6570\uff09\uff0c\u8d85\u8fc7\u6b64\u503c\u653e\u5f03\u540e\u5904\u7406\u4ee5\u907f\u514d\u6210\u672c\u5931\u63a7 */
    private static final int MAX_REMEDIAL_CHARS = 500;

    /** \u6b8b\u7559\u4e2d\u6587\u76f8\u5bf9\u4e0a\u9650\uff08\u5360\u8bd1\u6587\u603b\u957f\u5ea6\u7684\u767e\u5206\u6bd4\uff09\uff0c\u8d85\u8fc7\u6b64\u503c\u6807\u8bb0\u4e3a\u7ffb\u8bd1\u5931\u8d25 */
    private static final double MAX_REMEDIAL_RATIO = 0.15;

    private final HttpClient httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5))
            .build();

    @Value("${translation.python.url:http://llm-engine:8000/translate}")
    private String pythonTranslateUrl;

    @Value("${translation.python.api-key:}")
    private String pythonApiKey;

    /**
     * 检测并修复译文中的残留中文
     * @return 修复后的译文
     */
    public String fixUntranslatedChinese(String sourceText, String translatedText, String targetLang, String engine) {
        // 日语、韩语、中文目标语言使用 CJK 统一表意文字，与中文共享 Unicode 范围，
        // 后处理的中文检测会产生大量误报，直接跳过
        if (isJapaneseTarget(targetLang) || isKoreanTarget(targetLang) || isChineseTarget(targetLang)) {
            log.debug("[后处理] 目标语言为 {}，跳过残留中文检测（CJK 文字共享 Unicode 范围）", targetLang);
            return translatedText;
        }

        var segments = detectChineseSegments(translatedText);
        if (!segments.isEmpty()) {
            int totalChineseChars = segments.stream().mapToInt(String::length).sum();

            // 成本熔断：残留中文超过阈值时放弃后处理，避免 API 账单击穿
            if (totalChineseChars > MAX_REMEDIAL_CHARS) {
                log.warn("[后处理] 残留中文 {} 字超过绝对上限({})，放弃后处理以避免成本失控", totalChineseChars, MAX_REMEDIAL_CHARS);
                return translatedText;
            }
            if (translatedText.length() > 0 && (double) totalChineseChars / translatedText.length() > MAX_REMEDIAL_RATIO) {
                log.warn("[后处理] 残留中文占比 {:.1f}% 超过阈值({:.0f}%)，译文可能翻译失败，放弃后处理",
                        (double) totalChineseChars / translatedText.length() * 100, MAX_REMEDIAL_RATIO * 100);
                return translatedText;
            }

            log.info("[后处理] 检测到 {} 段残留中文 (共 {} 字): {}", segments.size(), totalChineseChars, segments);

            try {
                String remedied = remediateSegments(segments, targetLang, engine);
                if (remedied != null) {
                    translatedText = applyRemediation(translatedText, segments, remedied);
                    log.info("[后处理] 补救完成，原文长度={}, 修复后长度={}", translatedText.length(), translatedText.length());
                }
            } catch (Exception e) {
                log.warn("[后处理] 补救失败: {}，保留原始译文", e.getMessage());
            }
        }

        // 注意：在逐行翻译场景下（streamTextTranslate），行级结构由 TranslationService 处理
        // 后处理只负责检测残留中文，不做任何结构重排
        return translatedText;
    }

    /**
     * 检测译文中连续的中文字符段
     * 日语目标语言使用排除法：日语使用 CJK 统一表意文字（汉字），需排除常见日语汉字
     */
    private List<String> detectChineseSegments(String text) {
        List<String> segments = new ArrayList<>();
        Matcher matcher = CHINESE_PATTERN.matcher(text);
        while (matcher.find()) {
            segments.add(matcher.group());
        }
        return segments.stream().distinct().toList();
    }

    /**
     * 判断目标语言是否为日语（日语使用 CJK 统一表意文字，与中文共享 Unicode 范围）
     */
    private static boolean isJapaneseTarget(String targetLang) {
        return targetLang != null && (targetLang.equalsIgnoreCase("ja") || targetLang.equalsIgnoreCase("japanese"));
    }

    private static boolean isKoreanTarget(String targetLang) {
        return targetLang != null && (targetLang.equalsIgnoreCase("ko") || targetLang.equalsIgnoreCase("korean"));
    }

    private static boolean isChineseTarget(String targetLang) {
        return targetLang != null && (
                targetLang.equalsIgnoreCase("zh") ||
                targetLang.equalsIgnoreCase("zh-CN") ||
                targetLang.equalsIgnoreCase("zh-TW") ||
                targetLang.equalsIgnoreCase("chinese"));
    }

    /**
     * 日语常见独有/高频汉字（简化判断：含假名或日语特有汉字则跳过）
     * 完整策略：如果片段中包含平假名/片假名，则视为日语而非残留中文
     */
    private static final Pattern JAPANESE_KANA = Pattern.compile("[぀-ゟ゠-ヿㇰ-ㇿ]");

    /**
     * 判断一个片段是否应视为日语（非残留中文）
     */
    private boolean isJapaneseSegment(String segment, String targetLang) {
        if (!isJapaneseTarget(targetLang)) {
            return false;
        }
        // 包含假名 → 日语
        if (JAPANESE_KANA.matcher(segment).find()) {
            return true;
        }
        // 日语中纯汉字的片段很难区分，但结合目标语言为日语，
        // 纯汉字片段很可能是正常的日文汉字，不应视为残留中文
        return true;
    }

    /**
     * 调用 LLM 补充翻译残留中文段
     */
    private String remediateSegments(List<String> segments, String targetLang, String engine) throws Exception {
        String sourceText = String.join("\n", segments);

        String baseUrl = pythonTranslateUrl.replace("/translate", "");
        String url = baseUrl + "/translate";

        // 只发送需要翻译的文本，不加额外指令，避免 LLM 混淆指令和待翻译文本
        var body = new LinkedHashMap<String, Object>();
        body.put("text", sourceText);
        body.put("target_lang", targetLang);
        body.put("engine", engine != null ? engine : "openai");
        body.put("fallback", true);

        String jsonBody = JSON.toJSONString(body);
        var reqBuilder = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type", "application/json; charset=UTF-8")
                .timeout(Duration.ofSeconds(60))
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody, StandardCharsets.UTF_8));
        if (pythonApiKey != null && !pythonApiKey.isEmpty()) {
            reqBuilder.header("X-Service-Key", pythonApiKey);
        }
        HttpRequest request = reqBuilder.build();

        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
        String responseBody = response.body();
        if (responseBody == null || responseBody.isBlank()) {
            throw new RuntimeException("Python服务返回空响应体, status=" + response.statusCode());
        }

        JSONObject json = JSON.parseObject(responseBody);
        String data = json.getString("data");
        if (data == null || data.isBlank()) {
            throw new RuntimeException("补救翻译返回空数据");
        }

        // 过滤：如果返回结果包含 prompt 关键词（LLM 原样返回了指令文本），视为翻译失败
        if (data.contains("以下文本包含") || data.contains("未翻译的中文") || data.contains("请将它们翻译")) {
            throw new RuntimeException("补救翻译返回了指令文本，LLM 未正确翻译");
        }

        return data;
    }

    /**
     * 将补救翻译结果应用到原文
     * 关键修复：使用逐个替换，避免 String.replace() 的全局替换导致内容混乱
     */
    private String applyRemediation(String translatedText, List<String> segments, String remedied) {
        String result = translatedText;
        String[] remediedSegments = remedied.split("\n", -1);

        for (int i = 0; i < segments.size(); i++) {
            String original = segments.get(i);
            String translated = (i < remediedSegments.length) ? remediedSegments[i].trim() : original;
            if (!translated.isBlank()) {
                // 只替换第一次出现，避免全局替换导致内容混乱
                int idx = result.indexOf(original);
                if (idx >= 0) {
                    result = result.substring(0, idx) + translated + result.substring(idx + original.length());
                }
            }
        }
        return result;
    }

    @PreDestroy
    public void shutdown() {
        httpClient.close();
        log.info("TranslationPostProcessingService HTTP client closed");
    }
}
