@Service(Service.Level.PROJECT)
public final class ChangelogService {

    /**
     * 从选中的提交记录生成 Changelog
     *
     * @param commitHashes 提交记录的 hash 列表
     * @return 生成的 Changelog 内容（Markdown 格式）
     */
    @NotNull
    public String generateChangelog(@NotNull List<String> commitHashes) {
        // 1. 读取提交记录
        List<CommitInfo> commits = readCommits(commitHashes);

        // 2. 组装 prompt
        String prompt = buildPrompt(commits);

        // 3. 调用 AI 服务生成 Changelog
        return callAIService(prompt);
    }

    /**
     * 从选中的提交记录生成工作日报
     */
    @NotNull
    public String generateDailyReport(@NotNull List<String> commitHashes) {
        // 类似逻辑，使用日报模板
    }

    /**
     * 从选中的提交记录生成工作周报
     */
    @NotNull
    public String generateWeeklyReport(@NotNull List<String> commitHashes) {
        // 类似逻辑，使用周报模板
    }
}

/**
 * 读取提交记录
 */
@NotNull
private List<CommitInfo> readCommits(@NotNull List<String> commitHashes) {
    List<CommitInfo> commits = new ArrayList<>();

    Repository repository = getRepository();

    try (Git git = new Git(repository)) {
        for (String hash : commitHashes) {
            ObjectId commitId = repository.resolve(hash);
            if (commitId != null) {
                RevCommit commit = git.log()
                    .add(commitId)
                    .setMaxCount(1)
                    .call()
                    .iterator()
                    .next();

                commits.add(new CommitInfo(
                    commit.getName(),
                    commit.getShortMessage(),
                    commit.getFullMessage(),
                    new Date(commit.getCommitTime() * 1000L),
                    commit.getAuthorIdent().getName()
                ));
            }
        }
    }

    return commits;
}

/**
 * 基于代码变更（diff）生成提交记录
 */
@NotNull
public String generateCommitMessageFromDiff(@NotNull Collection<Change> changes) {
    // 1. 提取代码变更信息
    List<CodeDiff> codeDiffs = CodeDiffUtil.extractCodeDiffs(changes);

    if (codeDiffs.isEmpty()) {
        throw new Exception("没有检测到代码变更");
    }

    // 2. 构建 prompt
    String prompt = buildPromptFromCodeDiff(codeDiffs);

    // 3. 调用 AI 服务生成提交记录
    return callAIServiceForCommitMessage(prompt);
}

/**
 * 组装 prompt
 */
@NotNull
private String buildPrompt(@NotNull List<CommitInfo> commits) {
    SettingsState settings = SettingsState.getInstance();
    String template = settings.changelogTemplate;
    String commitsText = buildCommitsText(commits);

    return template
        .replace("{version}", "v1.0.0")
        .replace("{commits}", commitsText);
}

/**
 * 组装日报 prompt
 */
@NotNull
private String buildDailyReportPrompt(@NotNull List<CommitInfo> commits) {
    String template = settings.dailyReportTemplate;
    String commitsText = buildCommitsText(commits);
    String date = formatCurrentDate();

    return template
        .replace("{date}", date)
        .replace("{commits}", commitsText);
}

+ public class PasswordValidator {
+
+     /**
+      * 验证用户密码强度
+      * @param password 用户密码
+      * @return 验证结果
+      */
+     public ValidationResult validate(String password) {
+         // 密码强度验证逻辑
+     }
+ }

/**
 * 构建提交记录文本
 * 按照提交日期对提交记录进行分组，每个日期一个分组
 */
@NotNull
private String buildCommitsText(@NotNull List<CommitInfo> commits) {
    if (commits.isEmpty()) {
        return "";
    }

    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

    // 按日期分组提交记录
    Map<String, List<CommitInfo>> commitsByDate = new LinkedHashMap<>();
    for (CommitInfo commit : commits) {
        String dateStr = dateFormat.format(commit.date);
        commitsByDate.computeIfAbsent(dateStr, k -> new ArrayList<>()).add(commit);
    }

    // 构建分组后的文本
    StringBuilder commitsText = new StringBuilder();
    for (Map.Entry<String, List<CommitInfo>> entry : commitsByDate.entrySet()) {
        String dateStr = entry.getKey();
        List<CommitInfo> dateCommits = entry.getValue();

        // 添加日期分组标题
        commitsText.append("### ").append(dateStr).append("\n\n");

        // 添加该日期下的所有提交记录
        for (CommitInfo commit : dateCommits) {
            commitsText.append("- ").append(commit.shortMessage).append("\n");
        }

        commitsText.append("\n");
    }

    return commitsText.toString().trim();
}

/**
 * 提取代码变更信息
 */
public static List<CodeDiff> extractCodeDiffs(@NotNull Collection<Change> changes) {
    List<CodeDiff> codeDiffs = new ArrayList<>();

    for (Change change : changes) {
        CodeDiff diff = new CodeDiff();

        // 文件路径
        diff.filePath = getRelativePath(change);

        // 变更类型
        diff.changeType = change.getType();

        // 统计新增和删除的行数
        try {
            diff.addedLines = countAddedLines(change);
            diff.deletedLines = countDeletedLines(change);

            // 提取有意义的变更内容
            diff.diffContent = extractMeaningfulDiff(change);
        } catch (Exception e) {
            // 忽略解析异常，继续处理其他变更
            continue;
        }

        // 过滤掉无意义的变更
        if (isMeaningfulChange(diff)) {
            codeDiffs.add(diff);
        }
    }

    return codeDiffs;
}

/**
 * 判断是否为有意义的变更
 */
private static boolean isMeaningfulChange(CodeDiff diff) {
    // 忽略纯格式化变更
    if (diff.addedLines == 0 && diff.deletedLines == 0) {
        return false;
    }

    // 忽略空白字符变更
    if (diff.diffContent != null &&
        diff.diffContent.matches("(?s).*^\\s*[+-]\\s*$.*")) {
        return false;
    }

    return true;
}

/**
 * 专为 Changelog 生成优化的系统提示词
 */
private static final String CHANGELOG_SYSTEM_PROMPT = """
    你是一位专业的技术文档撰写专家，在软件公司负责发布说明和技术文档编写。

    你的任务是根据 Git 提交记录生成专业、准确、有价值的版本更新日志。

    生成原则：
    1. 用户导向：重点说明对用户的价值和影响，而不是技术细节
    2. 分类清晰：按功能类型、重要程度合理分类
    3. 语言简洁：使用易于理解的语言，避免过于技术化
    4. 格式规范：使用 Markdown 格式，添加适当的图标和结构
    5. 价值突出：每个改动都要说明解决了什么问题，带来什么好处

    分类标准：
    - 🎉 重大更新：重要功能发布、架构升级等
    - 🚀 新增功能：新功能模块、新特性等
    - 🐛 问题修复：Bug 修复、异常处理等
    - 🔧 技术改进：性能优化、重构、技术升级等
    - 📚 文档更新：API 文档、使用说明等

    输出格式：
    # 版本号 (发布日期)

    ## 🎉 重大更新

    ### 功能名称
    - 功能描述和价值
    - 技术亮点（可选）

    ## 🚀 新增功能

    ### 功能名称
    - 功能描述
    - 用户价值

    ## 🐛 问题修复

    ### 问题描述
    - 修复内容
    - 带来的改善

    ## 🔧 技术改进

    ### 改进内容
    - 技术细节
    - 性能提升

    注意：
    - 输出内容不要使用 markdown 代码块包裹
    - 直接输出内容，不要添加任何代码块标记
    - 根据提交记录的实际情况灵活调整分类
    """;

/**
 * 调用 AI 服务生成 Changelog
 */
@NotNull
private String callAIService(@NotNull String userPrompt) throws Exception {
    SettingsState settings = SettingsState.getInstance();

    // 获取当前配置的供应商
    AIProviderConfig config = settings.providerConfig;
    if (config == null) {
        throw new Exception("请先配置 AI 提供商");
    }

    // 获取系统提示词
    String systemPrompt = settings.systemPrompt;
    if (systemPrompt == null || systemPrompt.trim().isEmpty()) {
        // 使用默认系统提示词
        systemPrompt = getDefaultSystemPrompt();
    }

    // 创建 AI 聊天请求
    AIChatRequest request = new AIChatRequest(systemPrompt, userPrompt);

    // 获取 AIService 实例
    AIService aiService = AIServiceImpl.getInstance();

    try {
        // 使用 AIService API 生成内容
        String result = aiService.generateContent(project, request, config, null);

        // 检查结果是否为空
        if (result.trim().isEmpty()) {
            throw new Exception("AI 服务返回空结果");
        }

        return result;
    } catch (AIServiceException e) {
        // 捕获 AIServiceException 并转换为友好的错误消息
        String errorMessage = e.getMessage();
        if (errorMessage != null && !errorMessage.isEmpty()) {
            throw new Exception("AI 服务调用失败: " + errorMessage);
        } else {
            throw new Exception("AI 服务调用失败，请检查网络连接和配置");
        }
    }
}

public class GenerateChangelogForGitLogAction extends AbstractGitLogAction {

    @Override
    protected void actionPerformed(@NotNull AnActionEvent e, @NotNull List<String> commitHashes) {
        Project project = e.getProject();
        if (project == null) return;

        // 显示进度提示
        ProgressManager.getInstance().run(new Task.Backgroundable(project, "生成 Changelog") {

            @Override
            public void run(@NotNull ProgressIndicator indicator) {
                try {
                    indicator.setText("正在读取提交记录...");
                    indicator.setIndeterminate(false);

                    ChangelogService service = ChangelogService.getInstance(project);

                    // 异步生成 Changelog
                    String changelog = service.generateChangelog(commitHashes);

                    // 在 UI 线程显示结果
                    ApplicationManager.getApplication().invokeLater(() -> {
                        showResultDialog(project, changelog);
                    });

                } catch (Exception ex) {
                    // 错误处理
                    ApplicationManager.getApplication().invokeLater(() -> {
                        showErrorDialog(project, ex.getMessage());
                    });
                }
            }
        });
    }
}

public class ChangelogService {

    private final Map<String, String> commitCache = new ConcurrentHashMap<>();

    @NotNull
    private List<CommitInfo> readCommits(@NotNull List<String> commitHashes) {
        List<CommitInfo> commits = new ArrayList<>();

        Repository repository = getRepository();

        try (Git git = new Git(repository)) {
            for (String hash : commitHashes) {
                // 检查缓存
                String cached = commitCache.get(hash);
                if (cached != null) {
                    // 从缓存反序列化
                    commits.add(deserializeCommitInfo(cached));
                    continue;
                }

                // 读取提交记录
                CommitInfo commit = readSingleCommit(git, repository, hash);
                if (commit != null) {
                    commits.add(commit);
                    // 写入缓存
                    commitCache.put(hash, serializeCommitInfo(commit));
                }
            }
        }

        return commits;
    }
}

public class BatchProcessor {

    /**
     * 批量处理多个提交记录集合
     */
    public void processBatch(@NotNull Project project,
                           @NotNull List<List<String>> commitGroups) {

        // 使用线程池并行处理
        ExecutorService executor = Executors.newFixedThreadPool(
            Math.min(commitGroups.size(), 4)
        );

        List<Future<String>> futures = new ArrayList<>();

        for (List<String> group : commitGroups) {
            futures.add(executor.submit(() -> {
                ChangelogService service = ChangelogService.getInstance(project);
                return service.generateChangelog(group);
            }));
        }

        // 收集结果
        List<String> results = new ArrayList<>();
        for (Future<String> future : futures) {
            try {
                results.add(future.get());
            } catch (Exception e) {
                results.add("生成失败: " + e.getMessage());
            }
        }

        executor.shutdown();
    }
}