package com.svnlog.web.service;

import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.FillPatternType;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.DefaultIndexedColorMap;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.svnlog.web.dto.AiAnalyzeRequest;
import com.svnlog.web.model.TaskResult;

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

@Service
public class AiWorkflowService {
    private static final Logger LOGGER = LoggerFactory.getLogger(AiWorkflowService.class);

    private static final String DEEPSEEK_API_URL = "https://api.deepseek.com/chat/completions";
    private static final String DEEPSEEK_MODEL_CHAT = "deepseek-chat";
    private static final String DEEPSEEK_MODEL_THINK = "deepseek-reasoner";
    private static final String DEFAULT_TEAM = "系统部";
    private static final String DEFAULT_CONTACT = "杨志强\n(系统平台组)";
    private static final String DEFAULT_DEVELOPER = "刘靖";
    private static final String[] FIXED_PROJECTS = {
            "PRS-7050场站智慧管控",
            "PRS-7950在线巡视",
            "PRS-7950在线巡视电科院测试版"
    };
    private static final String FIXED_PROJECT_VALUE =
            "PRS-7950在线巡视电科院测试版/PRS-7950在线巡视/PRS-7050场站智慧管控";
    private static final Pattern NUMBERED_ITEM_PATTERN = Pattern.compile("^\\s*(\\d+)[\\.、\\)]\\s*(.+)$");
    private static final Pattern BULLET_ITEM_PATTERN = Pattern.compile("^\\s*[-*•]\\s*(.+)$");
    private static final Pattern REVISION_ITEM_PATTERN = Pattern.compile("^\\s*(?:\\*\\s*)?r\\d+\\s*[-:：]+\\s*(.+)$");
    private static final Pattern FILE_SECTION_PATTERN =
            Pattern.compile("(?s)=== 文件:\\s*(.*?)\\s*===\\s*(.*?)(?=(?:\\n\\s*=== 文件:)|\\z)");
    private static final Pattern COMMIT_ENTRY_PATTERN =
            Pattern.compile("(?s)###\\s+r(\\d+)\\b.*?\\*\\*提交信息\\*\\*:\\s*```\\s*(.*?)\\s*```");
    private static final Pattern REVISION_REF_PATTERN = Pattern.compile("r\\d+");
    private static final Pattern TOTAL_RECORDS_PATTERN = Pattern.compile("总记录数\\*\\*:\\s*(\\d+)\\s*条");
    private static final Pattern REVISION_HEADING_PATTERN = Pattern.compile("^###\\s+r\\d+.*$");
    private static final int STREAM_PERSIST_INTERVAL = 8;
    private static final int SUMMARY_RECORDS_PER_ITEM = 4;
    private static final int SUMMARY_MIN_ITEMS = 2;
    private static final int SUMMARY_MAX_ITEMS = 200;
    private static final int DEEPSEEK_CHAT_MAX_TOKENS_PRIMARY = 8000;
    private static final int DEEPSEEK_CHAT_MAX_TOKENS_RETRY = 8000;
    private static final int DEEPSEEK_REASONER_MAX_TOKENS_PRIMARY = 64000;
    private static final int DEEPSEEK_REASONER_MAX_TOKENS_RETRY = 64000;
    private static final int EXCEL_CELL_MAX_LENGTH = 32767;

    private final OkHttpClient httpClient = new OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .writeTimeout(60, TimeUnit.SECONDS)
            .readTimeout(180, TimeUnit.SECONDS)
            .build();

    private final OutputFileService outputFileService;
    private final SettingsService settingsService;
    private final AiInputValidator aiInputValidator;
    private final RetrySupport retrySupport = new RetrySupport();

    public AiWorkflowService(OutputFileService outputFileService,
                             SettingsService settingsService,
                             AiInputValidator aiInputValidator) {
        this.outputFileService = outputFileService;
        this.settingsService = settingsService;
        this.aiInputValidator = aiInputValidator;
    }

    public TaskResult analyzeAndExport(AiAnalyzeRequest request, TaskContext context) throws Exception {
        final Path outputRoot = outputFileService.getOutputRoot();
        final List<String> requestedPaths = request.getFilePaths() == null
                ? java.util.Collections.<String>emptyList()
                : request.getFilePaths();
        context.setProgress(10, "正在读取 Markdown 文件，输出目录: " + outputRoot);
        context.setProgress(12, "待处理文件: " + joinPaths(requestedPaths));
        final List<Path> markdownFiles = resolveUserFiles(request.getFilePaths());
        context.setProgress(18, "路径解析完成: " + joinResolvedPaths(markdownFiles));
        aiInputValidator.validate(markdownFiles);
        final String content = readMarkdownFiles(markdownFiles);
        final Map<String, List<CommitEntry>> projectCommits = buildProjectCommitMap(content);
        final Map<String, Integer> projectLogCounts = buildProjectLogCountsFromCommits(projectCommits);
        final Map<String, Integer> projectMinItems = buildProjectMinItems(projectLogCounts);

        context.setProgress(35, "正在请求 DeepSeek 分析");
        final String period = request.getPeriod() != null && !request.getPeriod().trim().isEmpty()
                ? request.getPeriod().trim()
                : new SimpleDateFormat("yyyy年MM月").format(new Date());

        final String apiKey = settingsService.pickActiveKey(request.getApiKey());
        if (apiKey == null || apiKey.trim().isEmpty()) {
            throw new IllegalStateException("未配置 DeepSeek API Key（可在设置页配置或请求中传入）");
        }

        final Map<String, LinkedHashSet<String>> groupedFromAi = createGroupedItems();
        for (int i = 0; i < FIXED_PROJECTS.length; i++) {
            final String project = FIXED_PROJECTS[i];
            final int targetItems = projectMinItems.containsKey(project)
                    ? projectMinItems.get(project).intValue()
                    : SUMMARY_MIN_ITEMS;
            final List<CommitEntry> sourceCommits = projectCommits.get(project);
            final int stepProgress = 35 + (i * 10);
            context.setProgress(stepProgress, "正在执行 Chat 压缩总结: " + project);
            context.setAiStreamStatus("STREAMING");
            List<ProjectSummaryItem> stageOneItems = new ArrayList<ProjectSummaryItem>();
            try {
                final String stageOnePrompt = buildProjectCompressionPrompt(project, sourceCommits, period, targetItems);
                final String stageOneResponse = callDeepSeek(apiKey, stageOnePrompt, context, DEEPSEEK_MODEL_CHAT);
                stageOneItems = parseProjectSummaryItems(stageOneResponse, project);
            } catch (Exception ex) {
                LOGGER.warn("DeepSeek chat stage failed, fallback to local compression: project={}", project, ex);
                context.emitEvent("phase", buildEventPayload("Chat 压缩失败，已切换本地压缩: " + project));
            }

            if (stageOneItems.isEmpty()) {
                final LinkedHashSet<String> localStageOne = buildLocalSummariesFromCommits(
                        project,
                        sourceCommits,
                        Math.max(targetItems, Math.min(targetItems * 2, sourceCommits == null ? 0 : sourceCommits.size()))
                );
                for (String item : localStageOne) {
                    stageOneItems.add(new ProjectSummaryItem(item, new LinkedHashSet<String>()));
                }
            }

            context.setProgress(stepProgress + 5, "正在执行 Think 精炼总结: " + project);
            try {
                final String stageTwoPrompt = buildProjectRefinePrompt(project, period, targetItems, sourceCommits, stageOneItems);
                final String stageTwoResponse = callDeepSeek(apiKey, stageTwoPrompt, context, DEEPSEEK_MODEL_THINK);
                final List<ProjectSummaryItem> stageTwoItems = parseProjectSummaryItems(stageTwoResponse, project);
                groupedFromAi.get(project).addAll(mergeProjectItems(project, sourceCommits, stageTwoItems, targetItems));
            } catch (Exception ex) {
                LOGGER.warn("DeepSeek think stage failed, fallback to chat merge: project={}", project, ex);
                context.emitEvent("phase", buildEventPayload("Think 精炼失败，使用 Chat 压缩结果: " + project));
                groupedFromAi.get(project).addAll(mergeProjectItems(project, sourceCommits, stageOneItems, targetItems));
            }
        }

        final JsonObject payload = buildBasePayload(period);
        applyGroupedItemsToPayload(payload, groupedFromAi);
        enforceMinimumSummaryItems(payload, content, projectMinItems);

        context.setProgress(75, "正在生成 Excel 文件");
        final String filename = buildOutputFilename(request.getOutputFileName());
        final String relative = "excel/" + filename;
        final Path outputFile = outputFileService.resolveInOutput(relative);
        Files.createDirectories(outputFile.getParent());
        writeExcel(outputFile, payload, period);

        context.setProgress(100, "AI 分析已完成");
        final TaskResult result = new TaskResult("工作量统计已生成");
        result.addFile(relative);
        return result;
    }

    private String readMarkdownFiles(List<Path> filePaths) throws IOException {
        final StringBuilder builder = new StringBuilder();
        for (Path path : filePaths) {
            final String content = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
            builder.append("\n\n=== 文件: ").append(path.getFileName().toString()).append(" ===\n");
            builder.append(content);
        }
        return builder.toString();
    }

    private List<Path> resolveUserFiles(List<String> userPaths) throws IOException {
        java.util.ArrayList<Path> files = new java.util.ArrayList<Path>();
        if (userPaths == null) {
            return files;
        }
        for (String userPath : userPaths) {
            files.add(resolveUserFile(userPath));
        }
        return files;
    }

    private Path resolveUserFile(String userPath) throws IOException {
        if (userPath == null || userPath.trim().isEmpty()) {
            throw new IllegalArgumentException("文件路径不能为空");
        }

        final String normalizedInput = userPath.trim();
        final Path outputRoot = outputFileService.getOutputRoot();
        final Path rootPath = Paths.get("").toAbsolutePath().normalize();
        final Path docsRoot = rootPath.resolve("docs").normalize();

        // 优先按输出目录相对路径解析（例如 md/*.md、excel/*.xlsx）
        final Path outputCandidate = outputFileService.resolveInOutput(normalizedInput);
        if (Files.exists(outputCandidate) && Files.isRegularFile(outputCandidate)) {
            return outputCandidate;
        }

        // 兼容绝对路径或历史路径输入，但仍限制在允许目录内
        final Path raw = Paths.get(normalizedInput);
        final Path candidate = raw.isAbsolute() ? raw.normalize() : rootPath.resolve(raw).normalize();

        if (candidate.startsWith(outputRoot) || candidate.startsWith(docsRoot)) {
            if (Files.exists(candidate) && Files.isRegularFile(candidate)) {
                return candidate;
            }
        }

        final boolean outputCandidateExists = Files.exists(outputCandidate);
        final boolean outputCandidateIsFile = outputCandidateExists && Files.isRegularFile(outputCandidate);
        final boolean rootCandidateExists = Files.exists(candidate);
        final boolean rootCandidateIsFile = rootCandidateExists && Files.isRegularFile(candidate);

        throw new IllegalArgumentException(
                "文件不存在或不在允许目录：" + normalizedInput
                        + " | outputCandidate=" + outputCandidate
                        + " (exists=" + outputCandidateExists + ", file=" + outputCandidateIsFile + ")"
                        + " | rootCandidate=" + candidate
                        + " (exists=" + rootCandidateExists + ", file=" + rootCandidateIsFile + ")"
                        + " | outputRoot=" + outputRoot
                        + " | docsRoot=" + docsRoot
        );
    }

    private String joinPaths(List<String> paths) {
        if (paths == null || paths.isEmpty()) {
            return "(empty)";
        }
        final StringBuilder builder = new StringBuilder();
        for (int i = 0; i < paths.size(); i++) {
            if (i > 0) {
                builder.append(", ");
            }
            builder.append(paths.get(i));
        }
        return builder.toString();
    }

    private String joinResolvedPaths(List<Path> paths) {
        if (paths == null || paths.isEmpty()) {
            return "(empty)";
        }
        final StringBuilder builder = new StringBuilder();
        for (int i = 0; i < paths.size(); i++) {
            if (i > 0) {
                builder.append(", ");
            }
            builder.append(paths.get(i).toString());
        }
        return builder.toString();
    }

    private String buildProjectCompressionPrompt(String project,
                                                 List<CommitEntry> sourceCommits,
                                                 String period,
                                                 int targetItems) {
        final StringBuilder workItems = new StringBuilder();
        final LinkedHashSet<String> revisionSet = new LinkedHashSet<String>();
        int index = 1;
        if (sourceCommits != null) {
            for (CommitEntry entry : sourceCommits) {
                if (entry == null || entry.message.trim().isEmpty()) {
                    continue;
                }
                revisionSet.add(entry.revision);
                workItems.append(index++)
                        .append(". [")
                        .append(entry.revision)
                        .append("] ")
                        .append(entry.message.trim())
                        .append('\n');
            }
        }
        if (workItems.length() == 0) {
            workItems.append("1. 本项目本周期存在代码提交，请按变更点进行归纳。\n");
        }
        final String allRevisions = revisionSet.isEmpty() ? "(none)" : joinValues(revisionSet, ", ");

        final int compressedTarget = Math.max(targetItems, Math.min(Math.max(targetItems * 2, 6), Math.max(targetItems, revisionSet.size())));

        return "你是项目管理助手，请仅根据以下“提交信息”先做压缩归纳。\n"
                + "工作周期: " + period + "\n"
                + "项目: " + project + "\n"
                + "目标压缩条数: " + Math.max(1, compressedTarget) + "\n"
                + "总提交数: " + revisionSet.size() + "\n"
                + "必须覆盖全部 revision（不可遗漏）: " + allRevisions + "\n"
                + "要求：\n"
                + "1. 仅输出 JSON，不要输出额外文字\n"
                + "2. 不能包含 SVN 地址、账号、版本范围、作者、时间等元信息\n"
                + "3. 不要逐条复述提交，要把相近提交合并成压缩总结\n"
                + "4. 返回结构固定：{\"project\":\"" + project + "\",\"items\":[{\"summary\":\"...\",\"sources\":[\"r123\"]}]}\n"
                + "5. items 里每条都必须给出 sources；sources 只能来自上面给定 revision 列表\n"
                + "6. summary 仅描述功能开发/优化/修复，不输出流水账\n"
                + "提交信息列表:\n"
                + workItems.toString();
    }

    private String buildProjectRefinePrompt(String project,
                                            String period,
                                            int targetItems,
                                            List<CommitEntry> sourceCommits,
                                            List<ProjectSummaryItem> stageOneItems) {
        final LinkedHashSet<String> revisionSet = new LinkedHashSet<String>();
        if (sourceCommits != null) {
            for (CommitEntry commit : sourceCommits) {
                if (commit == null || commit.revision == null || commit.revision.trim().isEmpty()) {
                    continue;
                }
                revisionSet.add(commit.revision.trim());
            }
        }

        final StringBuilder stageOneBuilder = new StringBuilder();
        int index = 1;
        if (stageOneItems != null) {
            for (ProjectSummaryItem item : stageOneItems) {
                if (item == null || item.summary == null || item.summary.trim().isEmpty()) {
                    continue;
                }
                stageOneBuilder.append(index++)
                        .append(". ")
                        .append(item.summary.trim())
                        .append(" | sources=")
                        .append(item.sources == null || item.sources.isEmpty() ? "[]" : joinValues(item.sources, ","))
                        .append('\n');
            }
        }
        if (stageOneBuilder.length() == 0) {
            stageOneBuilder.append("1. 本项目存在有效提交，请按目标条数进行归纳。\n");
        }

        return "你是项目管理助手，请将“阶段一压缩结果”精炼为固定条数总结。\n"
                + "工作周期: " + period + "\n"
                + "项目: " + project + "\n"
                + "最终条数(必须严格等于): " + Math.max(1, targetItems) + "\n"
                + "必须覆盖全部 revision（不可遗漏）: "
                + (revisionSet.isEmpty() ? "(none)" : joinValues(revisionSet, ", "))
                + "\n"
                + "要求：\n"
                + "1. 仅输出 JSON，不要输出额外文字\n"
                + "2. 返回结构固定：{\"project\":\"" + project + "\",\"items\":[{\"summary\":\"...\",\"sources\":[\"r123\"]}]}\n"
                + "3. items 数量必须严格等于最终条数\n"
                + "4. 每条都必须有 sources，且 sources 仅可使用给定 revision\n"
                + "5. 不要逐条抄写提交，必须做合并归纳\n"
                + "阶段一压缩结果:\n"
                + stageOneBuilder.toString();
    }

    private List<ProjectSummaryItem> parseProjectSummaryItems(String aiResponse, String project) {
        final List<ProjectSummaryItem> items = new ArrayList<ProjectSummaryItem>();
        final JsonObject object = extractJson(aiResponse);

        if (object.has("items") && object.get("items").isJsonArray()) {
            final JsonArray rawItems = object.getAsJsonArray("items");
            for (JsonElement item : rawItems) {
                if (item == null || item.isJsonNull()) {
                    continue;
                }
                if (item.isJsonObject()) {
                    final JsonObject jsonItem = item.getAsJsonObject();
                    final String summary = cleanWorkItem(
                            firstNonBlank(
                                    firstNonBlank(
                                            optString(jsonItem, "summary"),
                                            optString(jsonItem, "content")
                                    ),
                                    optString(jsonItem, "text")
                            )
                    );
                    final LinkedHashSet<String> sources = parseSources(jsonItem.get("sources"));
                    if (!summary.isEmpty()) {
                        items.add(new ProjectSummaryItem(summary, sources));
                    }
                } else {
                    final String summary = cleanWorkItem(item.getAsString());
                    if (!summary.isEmpty()) {
                        items.add(new ProjectSummaryItem(summary, new LinkedHashSet<String>()));
                    }
                }
            }
        }

        if (object.has("content") && !object.get("content").isJsonNull()) {
            final String content = object.get("content").getAsString();
            final Map<String, LinkedHashSet<String>> tmp = createGroupedItems();
            collectItems(tmp, project, content);
            final LinkedHashSet<String> parsed = tmp.get(project);
            if (parsed != null) {
                for (String value : parsed) {
                    items.add(new ProjectSummaryItem(value, new LinkedHashSet<String>()));
                }
            }
        }

        if (object.has("records") && object.get("records").isJsonArray()) {
            final JsonArray records = object.getAsJsonArray("records");
            for (JsonElement element : records) {
                if (element == null || !element.isJsonObject()) {
                    continue;
                }
                final JsonObject record = element.getAsJsonObject();
                final String content = optString(record, "content");
                if (content == null || content.trim().isEmpty()) {
                    continue;
                }
                final Map<String, LinkedHashSet<String>> tmp = createGroupedItems();
                collectItems(tmp, project, content);
                final LinkedHashSet<String> parsed = tmp.get(project);
                if (parsed != null) {
                    for (String value : parsed) {
                        items.add(new ProjectSummaryItem(value, new LinkedHashSet<String>()));
                    }
                }
            }
        }
        return items;
    }

    private LinkedHashSet<String> mergeProjectItems(String project,
                                                    List<CommitEntry> sourceCommits,
                                                    List<ProjectSummaryItem> aiItems,
                                                    int targetItems) {
        final LinkedHashMap<String, String> revisionToMessage = new LinkedHashMap<String, String>();
        if (sourceCommits != null) {
            for (CommitEntry commit : sourceCommits) {
                if (commit == null || commit.revision == null || commit.revision.isEmpty()) {
                    continue;
                }
                if (commit.message == null || commit.message.trim().isEmpty()) {
                    continue;
                }
                revisionToMessage.put(commit.revision, commit.message);
            }
        }

        final LinkedHashSet<String> allRevisions = new LinkedHashSet<String>(revisionToMessage.keySet());
        final LinkedHashSet<String> covered = new LinkedHashSet<String>();
        final LinkedHashSet<String> merged = new LinkedHashSet<String>();
        final LinkedHashSet<String> aiItemsWithoutSources = new LinkedHashSet<String>();
        if (aiItems != null) {
            for (ProjectSummaryItem aiItem : aiItems) {
                if (aiItem == null || aiItem.summary == null || aiItem.summary.trim().isEmpty()) {
                    continue;
                }
                final LinkedHashSet<String> validSources = new LinkedHashSet<String>();
                for (String source : aiItem.sources) {
                    if (allRevisions.contains(source)) {
                        validSources.add(source);
                    }
                }
                if (validSources.isEmpty()) {
                    aiItemsWithoutSources.add(cleanWorkItem(aiItem.summary));
                    continue;
                }
                covered.addAll(validSources);
                merged.add(cleanWorkItem(aiItem.summary));
            }
        }

        if (merged.isEmpty() && !aiItemsWithoutSources.isEmpty()) {
            merged.addAll(aiItemsWithoutSources);
            covered.addAll(allRevisions);
        }

        final LinkedHashSet<String> uncovered = new LinkedHashSet<String>(allRevisions);
        uncovered.removeAll(covered);
        final List<CommitEntry> uncoveredCommits = new ArrayList<CommitEntry>();
        for (String revision : uncovered) {
            final String message = revisionToMessage.get(revision);
            if (message == null || message.trim().isEmpty()) {
                continue;
            }
            uncoveredCommits.add(new CommitEntry(revision, message));
        }
        if (!uncoveredCommits.isEmpty()) {
            merged.addAll(buildLocalSummariesFromCommits(project, uncoveredCommits, Math.max(1, targetItems)));
        }

        if (merged.isEmpty()) {
            merged.addAll(buildCommitFallbackItems(project, sourceCommits, targetItems));
        }
        return normalizeToTargetItemCount(project, merged, targetItems);
    }

    private LinkedHashSet<String> buildCommitFallbackItems(String project, List<CommitEntry> sourceCommits, int targetItems) {
        final LinkedHashSet<String> items = buildLocalSummariesFromCommits(project, sourceCommits, Math.max(1, targetItems));
        return normalizeToTargetItemCount(project, items, targetItems);
    }

    private LinkedHashSet<String> buildLocalSummariesFromCommits(String project,
                                                                  List<CommitEntry> commits,
                                                                  int targetItems) {
        final LinkedHashSet<String> items = new LinkedHashSet<String>();
        final List<String> messages = new ArrayList<String>();
        if (commits != null) {
            for (CommitEntry entry : commits) {
                if (entry == null || entry.message == null || entry.message.trim().isEmpty()) {
                    continue;
                }
                messages.add(entry.message.trim());
            }
        }
        if (messages.isEmpty()) {
            return items;
        }

        final int summaryCount = Math.max(1, Math.min(Math.max(1, targetItems), messages.size()));
        final int chunkSize = Math.max(1, (messages.size() + summaryCount - 1) / summaryCount);

        for (int i = 0; i < messages.size(); i += chunkSize) {
            final int to = Math.min(messages.size(), i + chunkSize);
            final LinkedHashSet<String> condensed = new LinkedHashSet<String>();
            for (int j = i; j < to; j++) {
                final String value = condenseMessageForSummary(messages.get(j));
                if (!value.isEmpty()) {
                    condensed.add(value);
                }
            }
            if (condensed.isEmpty()) {
                continue;
            }
            final String summary = joinValues(condensed, "；");
            items.add(cleanWorkItem(summary));
            if (items.size() >= summaryCount) {
                break;
            }
        }
        return items;
    }

    private LinkedHashSet<String> normalizeToTargetItemCount(String project,
                                                             LinkedHashSet<String> rawItems,
                                                             int targetItems) {
        final int safeTarget = Math.max(1, targetItems);
        final List<String> values = new ArrayList<String>();
        if (rawItems != null) {
            for (String item : rawItems) {
                final String cleaned = cleanWorkItem(item);
                if (!cleaned.isEmpty()) {
                    values.add(cleaned);
                }
            }
        }

        final LinkedHashSet<String> result = new LinkedHashSet<String>();
        if (values.isEmpty()) {
            int index = 1;
            while (result.size() < safeTarget) {
                result.add(buildFallbackItem(project, index++));
            }
            return result;
        }

        if (values.size() <= safeTarget) {
            result.addAll(values);
            int index = 1;
            while (result.size() < safeTarget) {
                result.add(buildFallbackItem(project, index++));
            }
            return result;
        }

        final int chunkSize = Math.max(1, (values.size() + safeTarget - 1) / safeTarget);
        for (int i = 0; i < values.size(); i += chunkSize) {
            final int to = Math.min(values.size(), i + chunkSize);
            final LinkedHashSet<String> condensed = new LinkedHashSet<String>();
            for (int j = i; j < to; j++) {
                condensed.add(condenseMessageForSummary(values.get(j)));
            }
            final String merged = cleanWorkItem(joinValues(condensed, "；"));
            if (!merged.isEmpty()) {
                result.add(merged);
            }
            if (result.size() >= safeTarget) {
                break;
            }
        }
        int index = 1;
        while (result.size() < safeTarget) {
            result.add(buildFallbackItem(project, index++));
        }
        return result;
    }

    private String condenseMessageForSummary(String message) {
        if (message == null) {
            return "";
        }
        String value = message.trim();
        value = value.replaceAll("(?i)^(feat|fix|chore|refactor|test|docs)(\\([^)]*\\))?:\\s*", "");
        value = value.replaceAll("\\s+", " ");
        value = value.replaceAll("[；;。]+$", "");
        return cleanWorkItem(value);
    }

    private LinkedHashSet<String> parseSources(JsonElement element) {
        final LinkedHashSet<String> sources = new LinkedHashSet<String>();
        if (element == null || element.isJsonNull()) {
            return sources;
        }
        if (element.isJsonArray()) {
            for (JsonElement source : element.getAsJsonArray()) {
                if (source == null || source.isJsonNull()) {
                    continue;
                }
                addRevisionFromText(sources, source.getAsString());
            }
            return sources;
        }
        addRevisionFromText(sources, element.getAsString());
        return sources;
    }

    private void addRevisionFromText(LinkedHashSet<String> sources, String text) {
        if (sources == null || text == null || text.trim().isEmpty()) {
            return;
        }
        final Matcher matcher = REVISION_REF_PATTERN.matcher(text);
        while (matcher.find()) {
            sources.add(matcher.group().toLowerCase());
        }
    }

    private Map<String, List<CommitEntry>> buildProjectCommitMap(String markdownContent) {
        final Map<String, List<CommitEntry>> grouped = createProjectCommitMap();
        if (markdownContent == null || markdownContent.trim().isEmpty()) {
            return grouped;
        }

        final Matcher fileMatcher = FILE_SECTION_PATTERN.matcher(markdownContent);
        while (fileMatcher.find()) {
            final String filename = fileMatcher.group(1);
            final String section = fileMatcher.group(2);
            final String project = normalizeProject(filename);
            if (project == null) {
                continue;
            }
            final List<CommitEntry> commits = grouped.get(project);
            if (commits == null) {
                continue;
            }
            final Matcher commitMatcher = COMMIT_ENTRY_PATTERN.matcher(section == null ? "" : section);
            while (commitMatcher.find()) {
                final String revision = "r" + commitMatcher.group(1);
                final String message = normalizeCommitMessage(commitMatcher.group(2));
                if (message.isEmpty()) {
                    continue;
                }
                commits.add(new CommitEntry(revision, message));
            }
        }
        return grouped;
    }

    private Map<String, Integer> buildProjectLogCountsFromCommits(Map<String, List<CommitEntry>> projectCommits) {
        final Map<String, Integer> counts = new LinkedHashMap<String, Integer>();
        for (String project : FIXED_PROJECTS) {
            final List<CommitEntry> commits = projectCommits == null ? null : projectCommits.get(project);
            counts.put(project, Integer.valueOf(commits == null ? 0 : commits.size()));
        }
        return counts;
    }

    private Map<String, List<CommitEntry>> createProjectCommitMap() {
        final Map<String, List<CommitEntry>> map = new LinkedHashMap<String, List<CommitEntry>>();
        for (String project : FIXED_PROJECTS) {
            map.put(project, new ArrayList<CommitEntry>());
        }
        return map;
    }

    private String normalizeCommitMessage(String raw) {
        if (raw == null) {
            return "";
        }
        String cleaned = raw.replace("\r", "\n").trim();
        cleaned = cleaned.replaceAll("(?m)^\\s*[-*]\\s*", "");
        cleaned = cleaned.replaceAll("\\s+", " ");
        return cleanWorkItem(cleaned);
    }

    private String joinValues(Iterable<String> values, String delimiter) {
        final StringBuilder builder = new StringBuilder();
        if (values == null) {
            return "";
        }
        for (String value : values) {
            if (value == null || value.trim().isEmpty()) {
                continue;
            }
            if (builder.length() > 0) {
                builder.append(delimiter);
            }
            builder.append(value.trim());
        }
        return builder.toString();
    }

    private JsonObject buildBasePayload(String period) {
        final JsonObject payload = new JsonObject();
        payload.addProperty("team", DEFAULT_TEAM);
        payload.addProperty("contact", DEFAULT_CONTACT);
        payload.addProperty("developer", DEFAULT_DEVELOPER);
        payload.addProperty("period", period);

        final JsonArray records = new JsonArray();
        final JsonObject record = new JsonObject();
        record.addProperty("sequence", 1);
        record.addProperty("project", FIXED_PROJECT_VALUE);
        record.addProperty("content", "");
        records.add(record);
        payload.add("records", records);
        return payload;
    }

    private Map<String, Integer> buildProjectLogCounts(List<Path> markdownFiles) throws IOException {
        final Map<String, Integer> counts = new LinkedHashMap<String, Integer>();
        for (String project : FIXED_PROJECTS) {
            counts.put(project, Integer.valueOf(0));
        }
        for (Path path : markdownFiles) {
            final String content = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
            final String project = normalizeProject(path.getFileName().toString());
            if (project == null) {
                continue;
            }
            int count = extractTotalRecordsCount(content);
            if (count <= 0) {
                count = estimateRevisionCount(content);
            }
            counts.put(project, Integer.valueOf(Math.max(count, 0)));
        }
        return counts;
    }

    private Map<String, Integer> buildProjectMinItems(Map<String, Integer> projectLogCounts) {
        final Map<String, Integer> minimums = new LinkedHashMap<String, Integer>();
        for (String project : FIXED_PROJECTS) {
            final int logCount = projectLogCounts.containsKey(project)
                    ? projectLogCounts.get(project).intValue()
                    : 0;
            minimums.put(project, Integer.valueOf(computeRequiredSummaryItems(
                    logCount,
                    SUMMARY_RECORDS_PER_ITEM,
                    SUMMARY_MIN_ITEMS,
                    SUMMARY_MAX_ITEMS
            )));
        }
        return minimums;
    }

    private int computeRequiredSummaryItems(int totalRecords,
                                            int recordsPerItem,
                                            int minItems,
                                            int maxItems) {
        final int safePerItem = Math.max(1, recordsPerItem);
        final int safeMin = Math.max(0, minItems);
        final int safeMax = Math.max(safeMin, maxItems);
        final int raw = (Math.max(0, totalRecords) + safePerItem - 1) / safePerItem;
        return Math.max(safeMin, Math.min(raw, safeMax));
    }

    private int extractTotalRecordsCount(String markdown) {
        if (markdown == null || markdown.trim().isEmpty()) {
            return 0;
        }
        final Matcher matcher = TOTAL_RECORDS_PATTERN.matcher(markdown);
        if (matcher.find()) {
            try {
                return Integer.parseInt(matcher.group(1));
            } catch (Exception ignored) {
                return 0;
            }
        }
        return 0;
    }

    private int estimateRevisionCount(String markdown) {
        if (markdown == null || markdown.trim().isEmpty()) {
            return 0;
        }
        int count = 0;
        final String[] lines = markdown.split("\\r?\\n");
        for (String line : lines) {
            if (line == null) {
                continue;
            }
            if (REVISION_HEADING_PATTERN.matcher(line.trim()).matches()) {
                count++;
            }
        }
        return count;
    }

    private String callDeepSeek(String apiKey, String prompt, TaskContext context, String model) throws IOException {
        final String modelName = model == null || model.trim().isEmpty() ? DEEPSEEK_MODEL_CHAT : model.trim();
        final int primaryMaxTokens = resolvePrimaryMaxTokens(modelName);
        final int retryMaxTokens = resolveRetryMaxTokens(modelName);
        try {
            final DeepSeekStreamResult primary = retrySupport.execute(
                    () -> callDeepSeekOnce(apiKey, prompt, context, modelName, primaryMaxTokens),
                    3,
                    1000L
            );
            if (!"length".equalsIgnoreCase(primary.finishReason)) {
                return primary.answer;
            }

            // 输出达到 token 上限但 JSON 已完整时直接使用，避免误报失败。
            if (isValidJsonObjectText(primary.answer)) {
                LOGGER.warn("DeepSeek finish_reason=length, but JSON is complete; using primary response");
                return primary.answer;
            }

            context.emitEvent("phase", buildEventPayload(
                    "DeepSeek(" + modelName + ") 输出长度触顶，自动重试（max_tokens=" + retryMaxTokens + "）"
            ));
            final DeepSeekStreamResult retried = retrySupport.execute(
                    () -> callDeepSeekOnce(apiKey, prompt, context, modelName, retryMaxTokens),
                    2,
                    1200L
            );
            if ("length".equalsIgnoreCase(retried.finishReason) && !isValidJsonObjectText(retried.answer)) {
                throw new IllegalStateException(
                        "DeepSeek 输出被截断（finish_reason=length），请缩短输入日志范围后重试"
                );
            }
            return retried.answer;
        } catch (IOException e) {
            context.setAiStreamStatus("FALLBACK");
            throw e;
        } catch (Exception e) {
            context.setAiStreamStatus("FALLBACK");
            throw new IOException(e.getMessage(), e);
        }
    }

    private int resolvePrimaryMaxTokens(String modelName) {
        if (DEEPSEEK_MODEL_THINK.equalsIgnoreCase(modelName)) {
            return DEEPSEEK_REASONER_MAX_TOKENS_PRIMARY;
        }
        return DEEPSEEK_CHAT_MAX_TOKENS_PRIMARY;
    }

    private int resolveRetryMaxTokens(String modelName) {
        if (DEEPSEEK_MODEL_THINK.equalsIgnoreCase(modelName)) {
            return DEEPSEEK_REASONER_MAX_TOKENS_RETRY;
        }
        return DEEPSEEK_CHAT_MAX_TOKENS_RETRY;
    }

    private DeepSeekStreamResult callDeepSeekOnce(String apiKey,
                                                  String prompt,
                                                  TaskContext context,
                                                  String model,
                                                  int maxTokens) throws Exception {
        final JsonObject message = new JsonObject();
        message.addProperty("role", "user");
        message.addProperty("content", prompt);

        final JsonArray messages = new JsonArray();
        messages.add(message);

        final JsonObject body = new JsonObject();
        body.addProperty("model", model);
        body.add("messages", messages);
        body.addProperty("max_tokens", maxTokens);
        body.addProperty("stream", true);
        final JsonObject responseFormat = new JsonObject();
        responseFormat.addProperty("type", "json_object");
        body.add("response_format", responseFormat);
        final JsonObject streamOptions = new JsonObject();
        streamOptions.addProperty("include_usage", true);
        body.add("stream_options", streamOptions);

        final Request request = new Request.Builder()
                .url(DEEPSEEK_API_URL)
                .addHeader("Authorization", "Bearer " + apiKey)
                .addHeader("Content-Type", "application/json")
                .post(RequestBody.create(body.toString(), MediaType.parse("application/json")))
                .build();

        try (Response response = httpClient.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                String errorBody = "";
                if (response.body() != null) {
                    errorBody = response.body().string();
                }
                String detail = "DeepSeek API 调用失败: " + response.code() + " " + errorBody;
                if (response.code() == 429 || response.code() >= 500) {
                    throw new RetrySupport.RetryableException(detail);
                }
                throw new IllegalStateException(detail);
            }
            if (response.body() == null) {
                throw new RetrySupport.RetryableException("DeepSeek API 返回空响应体");
            }

            final StringBuilder answerBuilder = new StringBuilder();
            final StringBuilder reasoningBuilder = new StringBuilder();
            final okhttp3.ResponseBody responseBody = response.body();
            final okio.BufferedSource source = responseBody.source();
            String finishReason = "";
            int reasoningDeltaCount = 0;
            int answerDeltaCount = 0;
            Long usagePromptTokens = null;
            Long usageCompletionTokens = null;
            Long usageTotalTokens = null;
            String finalMessageContent = "";

            context.emitEvent("phase", buildEventPayload("正在流式接收 DeepSeek 输出"));
            while (!source.exhausted()) {
                final String line = source.readUtf8Line();
                if (line == null || line.trim().isEmpty() || !line.startsWith("data:")) {
                    continue;
                }

                final String dataLine = line.substring(5).trim();
                if ("[DONE]".equals(dataLine)) {
                    break;
                }

                final JsonObject data = JsonParser.parseString(dataLine).getAsJsonObject();
                if (data.has("usage") && data.get("usage").isJsonObject()) {
                    final JsonObject usage = data.getAsJsonObject("usage");
                    usagePromptTokens = optLong(usage, "prompt_tokens");
                    usageCompletionTokens = optLong(usage, "completion_tokens");
                    usageTotalTokens = optLong(usage, "total_tokens");
                    final Map<String, Object> usagePayload = new LinkedHashMap<String, Object>();
                    usagePayload.put("promptTokens", usagePromptTokens);
                    usagePayload.put("completionTokens", usageCompletionTokens);
                    usagePayload.put("totalTokens", usageTotalTokens);
                    usagePayload.put("cacheHitTokens", optLong(usage, "prompt_cache_hit_tokens"));
                    usagePayload.put("cacheMissTokens", optLong(usage, "prompt_cache_miss_tokens"));
                    context.emitEvent("usage", usagePayload);
                }

                final JsonArray choices = data.getAsJsonArray("choices");
                if (choices == null || choices.size() == 0) {
                    continue;
                }

                final JsonObject first = choices.get(0).getAsJsonObject();
                if (first.has("message") && first.get("message").isJsonObject()) {
                    final String content = optString(first.getAsJsonObject("message"), "content");
                    if (content != null && !content.trim().isEmpty()) {
                        finalMessageContent = content.trim();
                    }
                }
                if (first.has("delta") && first.get("delta").isJsonObject()) {
                    final JsonObject delta = first.getAsJsonObject("delta");

                    final String reasoning = optString(delta, "reasoning_content");
                    if (reasoning != null && !reasoning.isEmpty()) {
                        reasoningDeltaCount++;
                        reasoningBuilder.append(reasoning);
                        context.emitEvent("reasoning_delta", buildTextPayload(reasoning));
                        if (reasoningDeltaCount % STREAM_PERSIST_INTERVAL == 0) {
                            context.updateAiOutput(reasoningBuilder.toString(), answerBuilder.toString());
                        }
                    }

                    final String answer = optString(delta, "content");
                    if (answer != null && !answer.isEmpty()) {
                        answerDeltaCount++;
                        answerBuilder.append(answer);
                        context.emitEvent("answer_delta", buildTextPayload(answer));
                        if (answerDeltaCount % STREAM_PERSIST_INTERVAL == 0) {
                            context.updateAiOutput(reasoningBuilder.toString(), answerBuilder.toString());
                        }
                    }
                }

                if (first.has("finish_reason") && !first.get("finish_reason").isJsonNull()) {
                    finishReason = first.get("finish_reason").getAsString();
                }
            }

            if ("insufficient_system_resource".equalsIgnoreCase(finishReason)) {
                throw new RetrySupport.RetryableException("DeepSeek 资源不足，请稍后重试");
            }

            String answer = answerBuilder.toString().trim();
            if (answer.isEmpty() && finalMessageContent != null && !finalMessageContent.isEmpty()) {
                answer = finalMessageContent;
            }
            if (answer.isEmpty()) {
                throw new IllegalStateException(
                        "DeepSeek 未返回有效 content 内容"
                                + " | stage_model=" + model
                                + " | api_model=" + model
                                + " | finish_reason=" + finishReason
                                + " | prompt_tokens=" + usagePromptTokens
                                + " | completion_tokens=" + usageCompletionTokens
                                + " | total_tokens=" + usageTotalTokens
                );
            }
            context.updateAiOutput(reasoningBuilder.toString(), answer);
            context.setAiStreamStatus("DONE");
            LOGGER.info(
                    "DeepSeek stream deltas: model={}, reasoning={}, answer={}, finishReason={}, maxTokens={}",
                    model,
                    reasoningDeltaCount,
                    answerDeltaCount,
                    finishReason,
                    maxTokens
            );
            return new DeepSeekStreamResult(answer, finishReason);
        }
    }

    private boolean isValidJsonObjectText(String text) {
        if (text == null || text.trim().isEmpty()) {
            return false;
        }
        try {
            extractJson(text);
            return true;
        } catch (Exception ignored) {
            return false;
        }
    }

    private static final class CommitEntry {
        private final String revision;
        private final String message;

        private CommitEntry(String revision, String message) {
            this.revision = revision == null ? "" : revision.trim().toLowerCase();
            this.message = message == null ? "" : message.trim();
        }
    }

    private static final class ProjectSummaryItem {
        private final String summary;
        private final LinkedHashSet<String> sources;

        private ProjectSummaryItem(String summary, LinkedHashSet<String> sources) {
            this.summary = summary == null ? "" : summary.trim();
            this.sources = sources == null ? new LinkedHashSet<String>() : sources;
        }
    }

    private static final class DeepSeekStreamResult {
        private final String answer;
        private final String finishReason;

        private DeepSeekStreamResult(String answer, String finishReason) {
            this.answer = answer == null ? "" : answer;
            this.finishReason = finishReason == null ? "" : finishReason;
        }
    }

    private Map<String, Object> buildTextPayload(String text) {
        final Map<String, Object> payload = new LinkedHashMap<String, Object>();
        payload.put("text", text);
        return payload;
    }

    private Map<String, Object> buildEventPayload(String message) {
        final Map<String, Object> payload = new LinkedHashMap<String, Object>();
        payload.put("message", message);
        return payload;
    }

    private Long optLong(JsonObject object, String key) {
        if (object == null || key == null || !object.has(key) || object.get(key).isJsonNull()) {
            return null;
        }
        try {
            return Long.valueOf(object.get(key).getAsLong());
        } catch (Exception ignored) {
            return null;
        }
    }

    private JsonObject extractJson(String rawResponse) {
        String trimmed = rawResponse == null ? "" : rawResponse.trim();
        if (trimmed.startsWith("```json")) {
            trimmed = trimmed.substring(7).trim();
        } else if (trimmed.startsWith("```")) {
            trimmed = trimmed.substring(3).trim();
        }
        if (trimmed.endsWith("```")) {
            trimmed = trimmed.substring(0, trimmed.length() - 3).trim();
        }
        return JsonParser.parseString(trimmed).getAsJsonObject();
    }

    private String buildOutputFilename(String outputFileName) {
        if (outputFileName != null && !outputFileName.trim().isEmpty()) {
            String name = outputFileName.trim();
            if (!name.toLowerCase().endsWith(".xlsx")) {
                name = name + ".xlsx";
            }
            return sanitize(name);
        }
        return new SimpleDateFormat("yyyyMM").format(new Date()) + "工作量统计.xlsx";
    }

    private void writeExcel(Path outputFile, JsonObject payload, String defaultPeriod) throws IOException {
        final String period = payload.has("period")
                ? firstNonBlank(optString(payload, "period"), defaultPeriod)
                : defaultPeriod;
        final String team = DEFAULT_TEAM;
        final String contact = DEFAULT_CONTACT;
        final String developer = DEFAULT_DEVELOPER;
        final String project = FIXED_PROJECT_VALUE;
        final String content = buildContentFromPayload(payload);
        validateExcelCellLength(content, "具体工作内容");

        try (Workbook workbook = new XSSFWorkbook()) {
            final Sheet sheet = workbook.createSheet("工作量统计");

            final CellStyle headerStyle = createHeaderStyle(workbook);
            final CellStyle textStyle = createTextStyle(workbook);
            final CellStyle developerPeriodStyle = createDeveloperPeriodStyle(workbook);
            final CellStyle projectNameStyle = createProjectNameStyle(workbook);
            final CellStyle contentStyle = createContentStyle(workbook);

            final String[] headers = {"序号", "所属班组", "技术对接", "开发人员", "工作周期", "开发项目名称", "具体工作内容"};
            final Row header = sheet.createRow(0);
            for (int i = 0; i < headers.length; i++) {
                final Cell cell = header.createCell(i);
                cell.setCellValue(headers[i]);
                cell.setCellStyle(headerStyle);
            }

            final Row row = sheet.createRow(1);
            row.setHeightInPoints(calculateRowHeight(content));
            createCell(row, 0, 1, textStyle);
            createCell(row, 1, team, textStyle);
            createCell(row, 2, contact, textStyle);
            createCell(row, 3, developer, developerPeriodStyle);
            createCell(row, 4, period, developerPeriodStyle);
            createCell(row, 5, project, projectNameStyle);
            createCell(row, 6, content, contentStyle);

            sheet.setColumnWidth(0, 2200);
            sheet.setColumnWidth(1, 4200);
            sheet.setColumnWidth(2, 5200);
            sheet.setColumnWidth(3, 4200);
            sheet.setColumnWidth(4, 4600);
            sheet.setColumnWidth(5, 12000);
            sheet.setColumnWidth(6, 26000);

            Files.createDirectories(outputFile.getParent());
            try (OutputStream out = Files.newOutputStream(outputFile)) {
                workbook.write(out);
            }
        }
    }

    private CellStyle createHeaderStyle(Workbook workbook) {
        final CellStyle style = workbook.createCellStyle();
        final Font font = workbook.createFont();
        font.setBold(true);
        font.setFontName("SimSun");
        font.setColor(IndexedColors.BLACK.getIndex());
        style.setFont(font);
        style.setAlignment(HorizontalAlignment.CENTER);
        style.setVerticalAlignment(VerticalAlignment.CENTER);
        style.setBorderTop(BorderStyle.THIN);
        style.setBorderBottom(BorderStyle.THIN);
        style.setBorderLeft(BorderStyle.THIN);
        style.setBorderRight(BorderStyle.THIN);
        style.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
        style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        return style;
    }

    private CellStyle createTextStyle(Workbook workbook) {
        final CellStyle style = workbook.createCellStyle();
        final Font font = workbook.createFont();
        font.setFontName("SimSun");
        style.setFont(font);
        style.setAlignment(HorizontalAlignment.LEFT);
        style.setVerticalAlignment(VerticalAlignment.CENTER);
        style.setBorderBottom(BorderStyle.THIN);
        style.setWrapText(false);
        return style;
    }

    private CellStyle createDeveloperPeriodStyle(Workbook workbook) {
        final CellStyle style = workbook.createCellStyle();
        final Font font = workbook.createFont();
        font.setFontName("SimSun");
        font.setBold(false);
        style.setFont(font);
        style.setAlignment(HorizontalAlignment.CENTER);
        style.setVerticalAlignment(VerticalAlignment.CENTER);
        style.setWrapText(false);
        style.setBorderBottom(BorderStyle.THIN);
        setSolidFillColor(style, "FEE4FF");
        return style;
    }

    private CellStyle createProjectNameStyle(Workbook workbook) {
        final CellStyle style = workbook.createCellStyle();
        final Font font = workbook.createFont();
        font.setFontName("宋体");
        font.setBold(true);
        style.setFont(font);
        style.setAlignment(HorizontalAlignment.GENERAL);
        style.setVerticalAlignment(VerticalAlignment.CENTER);
        style.setWrapText(true);
        style.setBorderBottom(BorderStyle.THIN);
        setSolidFillColor(style, "FFFF00");
        return style;
    }

    private CellStyle createContentStyle(Workbook workbook) {
        final CellStyle style = workbook.createCellStyle();
        final Font font = workbook.createFont();
        font.setFontName("NSimSun");
        font.setBold(true);
        style.setFont(font);
        style.setAlignment(HorizontalAlignment.LEFT);
        style.setVerticalAlignment(VerticalAlignment.TOP);
        style.setWrapText(true);
        style.setBorderBottom(BorderStyle.THIN);
        setSolidFillColor(style, "FFFF00");
        return style;
    }

    private void setSolidFillColor(CellStyle style, String rgbHex) {
        if (!(style instanceof XSSFCellStyle) || rgbHex == null || rgbHex.trim().isEmpty()) {
            return;
        }
        final String normalized = rgbHex.trim();
        if (normalized.length() != 6) {
            return;
        }
        final byte[] rgb = new byte[3];
        try {
            rgb[0] = (byte) Integer.parseInt(normalized.substring(0, 2), 16);
            rgb[1] = (byte) Integer.parseInt(normalized.substring(2, 4), 16);
            rgb[2] = (byte) Integer.parseInt(normalized.substring(4, 6), 16);
        } catch (Exception ignored) {
            return;
        }
        final XSSFCellStyle xssfStyle = (XSSFCellStyle) style;
        xssfStyle.setFillForegroundColor(new XSSFColor(rgb, new DefaultIndexedColorMap()));
        xssfStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
    }

    private void createCell(Row row, int idx, String value, CellStyle style) {
        final Cell cell = row.createCell(idx);
        cell.setCellValue(value == null ? "" : value);
        cell.setCellStyle(style);
    }

    private void validateExcelCellLength(String value, String fieldName) {
        final String safe = value == null ? "" : value;
        if (safe.length() > EXCEL_CELL_MAX_LENGTH) {
            throw new IllegalArgumentException(
                    "Excel 单元格内容超长: "
                            + (fieldName == null ? "未知字段" : fieldName)
                            + " 长度=" + safe.length()
                            + "，最大允许=" + EXCEL_CELL_MAX_LENGTH
                            + "。请减少本次汇总范围后重试。"
            );
        }
    }

    private void createCell(Row row, int idx, int value, CellStyle style) {
        final Cell cell = row.createCell(idx);
        cell.setCellValue(value);
        cell.setCellStyle(style);
    }

    private int getAsInt(JsonElement element, int defaultValue) {
        if (element == null) {
            return defaultValue;
        }
        try {
            return element.getAsInt();
        } catch (Exception e) {
            return defaultValue;
        }
    }

    private String optString(JsonObject object, String key) {
        if (object == null || !object.has(key) || object.get(key).isJsonNull()) {
            return "";
        }
        return object.get(key).getAsString();
    }

    private String buildContentFromPayload(JsonObject payload) {
        final Map<String, LinkedHashSet<String>> groupedItems = createGroupedItems();
        final JsonArray records = payload.has("records") ? payload.getAsJsonArray("records") : new JsonArray();
        for (JsonElement element : records) {
            if (element == null || !element.isJsonObject()) {
                continue;
            }
            final JsonObject record = element.getAsJsonObject();
            final String recordProject = optString(record, "project");
            final String recordContent = optString(record, "content");
            collectItems(groupedItems, recordProject, recordContent);
        }

        final StringBuilder builder = new StringBuilder();
        for (String project : FIXED_PROJECTS) {
            final LinkedHashSet<String> items = groupedItems.get(project);
            if (items == null || items.isEmpty()) {
                continue;
            }
            if (builder.length() > 0) {
                builder.append("\n\n");
            }
            builder.append(project).append('\n');
            int index = 1;
            for (String item : items) {
                builder.append(index++).append(". ").append(item).append('\n');
            }
        }
        return builder.toString().trim();
    }

    private void enforceMinimumSummaryItems(JsonObject payload,
                                            String markdownContent,
                                            Map<String, Integer> projectMinItems) {
        final Map<String, LinkedHashSet<String>> groupedFromPayload = createGroupedItems();
        final JsonArray records = payload.has("records") ? payload.getAsJsonArray("records") : new JsonArray();
        for (JsonElement element : records) {
            if (element == null || !element.isJsonObject()) {
                continue;
            }
            final JsonObject record = element.getAsJsonObject();
            collectItems(
                    groupedFromPayload,
                    optString(record, "project"),
                    optString(record, "content")
            );
        }

        final Map<String, LinkedHashSet<String>> groupedFromMarkdown = parseItemsFromMarkdown(markdownContent);
        for (String project : FIXED_PROJECTS) {
            final int targetItems = projectMinItems.containsKey(project)
                    ? projectMinItems.get(project).intValue()
                    : 2;
            final LinkedHashSet<String> current = groupedFromPayload.get(project);
            final LinkedHashSet<String> source = groupedFromMarkdown.get(project);
            if (current == null) {
                continue;
            }
            if (current.isEmpty() && source != null) {
                for (String item : source) {
                    current.add(item);
                }
            }
            final LinkedHashSet<String> normalized = normalizeToTargetItemCount(project, current, targetItems);
            current.clear();
            current.addAll(normalized);
        }

        applyGroupedItemsToPayload(payload, groupedFromPayload);
    }

    private Map<String, LinkedHashSet<String>> parseItemsFromMarkdown(String markdownContent) {
        final Map<String, LinkedHashSet<String>> groupedItems = createGroupedItems();
        String currentProject = null;
        final String[] lines = markdownContent == null ? new String[0] : markdownContent.split("\\r?\\n");
        for (String rawLine : lines) {
            final String line = rawLine == null ? "" : rawLine.trim();
            if (line.isEmpty()) {
                continue;
            }

            if (line.startsWith("=== 文件:")) {
                currentProject = normalizeProject(line);
                continue;
            }

            final String headingProject = parseHeadingProject(line);
            if (headingProject != null) {
                currentProject = headingProject;
                continue;
            }

            final String extracted = parseWorkItem(line);
            if (extracted == null || extracted.isEmpty()) {
                continue;
            }
            final String targetProject = currentProject == null ? FIXED_PROJECTS[0] : currentProject;
            groupedItems.get(targetProject).add(extracted);
        }
        return groupedItems;
    }

    private void applyGroupedItemsToPayload(JsonObject payload, Map<String, LinkedHashSet<String>> groupedItems) {
        final StringBuilder mergedContent = new StringBuilder();
        for (String project : FIXED_PROJECTS) {
            final LinkedHashSet<String> items = groupedItems.get(project);
            if (items == null || items.isEmpty()) {
                continue;
            }
            if (mergedContent.length() > 0) {
                mergedContent.append("\n\n");
            }
            mergedContent.append(project).append('\n');
            int index = 1;
            for (String item : items) {
                mergedContent.append(index++).append(". ").append(item).append('\n');
            }
        }
        final String merged = mergedContent.toString().trim();

        JsonArray records = payload.has("records") ? payload.getAsJsonArray("records") : null;
        if (records == null) {
            records = new JsonArray();
            payload.add("records", records);
        }
        JsonObject record;
        if (records.size() > 0 && records.get(0).isJsonObject()) {
            record = records.get(0).getAsJsonObject();
        } else {
            record = new JsonObject();
            record.addProperty("sequence", 1);
            records.add(record);
        }
        record.addProperty("project", FIXED_PROJECT_VALUE);
        record.addProperty("content", merged);
    }

    private String buildFallbackItem(String project, int index) {
        return "补充总结" + index + "：基于" + project + "本周期提交记录提炼的功能优化与问题修复工作";
    }

    private Map<String, LinkedHashSet<String>> createGroupedItems() {
        final Map<String, LinkedHashSet<String>> groupedItems =
                new LinkedHashMap<String, LinkedHashSet<String>>();
        for (String project : FIXED_PROJECTS) {
            groupedItems.put(project, new LinkedHashSet<String>());
        }
        return groupedItems;
    }

    private void collectItems(Map<String, LinkedHashSet<String>> groupedItems, String projectText, String content) {
        final String fallbackProject = normalizeProject(projectText);
        String currentProject = fallbackProject;
        final String[] lines = content == null ? new String[0] : content.split("\\r?\\n");
        for (String rawLine : lines) {
            final String line = rawLine == null ? "" : rawLine.trim();
            if (line.isEmpty()) {
                continue;
            }

            final String headingProject = parseHeadingProject(line);
            if (headingProject != null) {
                currentProject = headingProject;
                continue;
            }

            final String extracted = parseWorkItem(line);
            if (extracted == null || extracted.isEmpty()) {
                continue;
            }
            final String targetProject = currentProject == null ? FIXED_PROJECTS[0] : currentProject;
            groupedItems.get(targetProject).add(extracted);
        }
    }

    private String parseHeadingProject(String line) {
        if (line.startsWith("#")) {
            final String stripped = line.replaceFirst("^#+\\s*", "");
            return normalizeProject(stripped);
        }
        return normalizeProject(line);
    }

    private String parseWorkItem(String line) {
        if (isMetaLine(line)) {
            return null;
        }

        Matcher matcher = NUMBERED_ITEM_PATTERN.matcher(line);
        if (matcher.matches()) {
            return cleanWorkItem(matcher.group(2));
        }

        matcher = BULLET_ITEM_PATTERN.matcher(line);
        if (matcher.matches()) {
            return cleanWorkItem(matcher.group(1));
        }

        matcher = REVISION_ITEM_PATTERN.matcher(line);
        if (matcher.matches()) {
            return cleanWorkItem(matcher.group(1));
        }

        if (line.length() > 6 && !line.startsWith("=") && !line.startsWith("```")) {
            return cleanWorkItem(line);
        }
        return null;
    }

    private boolean isMetaLine(String line) {
        return line.startsWith("SVN")
                || line.startsWith("仓库")
                || line.startsWith("分支")
                || line.startsWith("版本")
                || line.startsWith("提交总数")
                || line.startsWith("日志详情")
                || line.startsWith("作者")
                || line.startsWith("时间")
                || line.startsWith("消息")
                || line.startsWith("文件")
                || line.startsWith("=== 文件:");
    }

    private String cleanWorkItem(String item) {
        String cleaned = item == null ? "" : item.trim();
        cleaned = cleaned.replaceAll("^\\[[^\\]]+\\]", "");
        cleaned = cleaned.replaceAll("^\\[[^\\]]+\\]", "");
        cleaned = cleaned.replaceAll("^\\[[^\\]]+\\]", "");
        cleaned = cleaned.replaceAll("\\s+", " ");
        return cleaned.trim();
    }

    private String normalizeProject(String value) {
        if (value == null) {
            return null;
        }
        final String input = value.trim();
        if (input.isEmpty()) {
            return null;
        }
        if (input.contains("7050")) {
            return "PRS-7050场站智慧管控";
        }
        if (input.contains("电科院")) {
            return "PRS-7950在线巡视电科院测试版";
        }
        if (input.contains("7950")) {
            return "PRS-7950在线巡视";
        }
        return null;
    }

    private float calculateRowHeight(String content) {
        final String safeContent = content == null ? "" : content;
        final String[] lines = safeContent.split("\\r?\\n");
        final int visibleLines = Math.max(lines.length, 1);
        final float lineHeight = 19.0f;
        final float minHeight = 220.0f;
        return Math.max(minHeight, visibleLines * lineHeight);
    }

    private String firstNonBlank(String preferred, String fallback) {
        if (preferred != null && !preferred.trim().isEmpty()) {
            return preferred.trim();
        }
        return fallback == null ? "" : fallback;
    }

    private String sanitize(String value) {
        return value.replaceAll("[^a-zA-Z0-9\\u4e00-\\u9fa5_.-]", "_");
    }
}