// JavaDoc 功能中的 AI 调用
public class JavaDocAIService {
    public String generateJavaDoc(String code) {
        // 配置管理
        String apiKey = getApiKey("openai");
        String model = getModel("gpt-4");
        String baseUrl = getBaseUrl("https://api.openai.com");

        // HTTP 调用
        // 错误处理
        // 响应解析
    }
}

// Changelog 功能中的 AI 调用
public class ChangelogAIService {
    public String generateChangelog(String commits) {
        // 几乎相同的代码
        String apiKey = getApiKey("openai"); // 重复！
        String model = getModel("gpt-4");     // 重复！
        String baseUrl = getBaseUrl("https://api.openai.com"); // 重复！

        // HTTP 调用（几乎相同）
        // 错误处理（几乎相同）
        // 响应解析（几乎相同）
    }
}

// 每个功能都需要管理相同的配置
public class JavaDocSettings {
    public String openaiApiKey;
    public String openaiModel;
    public String openaiBaseUrl;
    public String anthropicApiKey;
    public String anthropicModel;
    // ... 更多服务商配置
}

public class ChangelogSettings {
    public String openaiApiKey;    // 重复！
    public String openaiModel;     // 重复！
    public String openaiBaseUrl;   // 重复！
    public String anthropicApiKey; // 重复！
    // ... 更多重复配置
}

/**
 * AI 服务统一入口
 * 为业务插件提供简洁的 AI 能力调用接口
 */
public interface AIService {

    /**
     * 生成 AI 内容
     *
     * @param project  项目上下文
     * @param request  AI 请求（系统提示词 + 用户提示词）
     * @param config   AI 提供商配置
     * @param listener 响应监听器（支持流式响应）
     * @return 生成的文本内容
     */
    @NotNull
    String generateContent(@NotNull Project project,
                           @NotNull AIChatRequest request,
                           @NotNull AIProviderConfig config,
                           @Nullable AIResponseListener listener) throws AIServiceException;

    /**
     * 获取全局配置
     * 包含所有可用的 AI 服务商配置
     */
    @NotNull
    AIProviderSettings getGlobalSettings();
}

/**
 * AI 服务提供商工厂
 * 根据配置动态创建对应的服务商实例
 */
public final class AIServiceFactory {

    @Nullable
    public static AIServiceProvider createProvider(@NotNull AIProviderConfig config,
                                                   @Nullable AIConsoleLogger consoleLogger) {

        AIProviderType providerType = config.providerType != null ?
            config.providerType : AIProviderType.QIANWEN;

        AIModelParameters modelParameters = config.modelParameters != null ?
            config.modelParameters : new AIModelParameters();

        AIRuntimeSettings runtimeSettings = config.runtimeSettings != null ?
            config.runtimeSettings : new AIRuntimeSettings();

        // 根据类型创建对应的服务商实现
        return switch (providerType) {
            case CUSTOM -> new CustomProvider(config, modelParameters, runtimeSettings, consoleLogger);
            case QIANWEN -> new QianWenProvider(config, modelParameters, runtimeSettings, consoleLogger);
            case SILICONFLOW -> new SiliconFlowProvider(config, modelParameters, runtimeSettings, consoleLogger);
            case OLLAMA -> new OllamaProvider(config, modelParameters, runtimeSettings, consoleLogger);
            case LM_STUDIO -> new LMStudioProvider(config, modelParameters, runtimeSettings, consoleLogger);
            case MODELSCOPE -> new ModelScopeProvider(config, modelParameters, runtimeSettings, consoleLogger);
        };
    }
}

/**
 * AI 服务提供商接口
 * 定义所有服务商必须实现的行为
 */
public interface AIServiceProvider {

    /** 获取服务商类型 */
    @NotNull
    AIProviderType getProviderType();

    /** 获取模型名称 */
    @NotNull
    String getModelName();

    /** 获取基础 URL */
    @NotNull
    String getBaseUrl();

    /** 验证配置 */
    @NotNull
    ValidationResult validateConfiguration(@NotNull String apiKey);

    /** 生成内容（核心方法） */
    @NotNull
    String generateContent(@NotNull AIChatRequest request,
                              @NotNull String apiKey,
                              @Nullable AIResponseListener listener) throws AIServiceException;

    /** 是否支持流式响应 */
    boolean supportsStreaming();

    /** 获取默认模型 */
    @NotNull
    String getDefaultModel();

    /** 获取默认基础 URL */
    @NotNull
    String getDefaultBaseUrl();
}

/**
 * AI 提供商配置类
 * 封装所有与 AI 服务相关的配置信息
 */
public class AIProviderConfig {
    /** 服务商类型 */
    public AIProviderType providerType = AIProviderType.CUSTOM;

    /** 模型名称 */
    public String modelName = AIProviderType.CUSTOM.getDefaultModel();

    /** 基础 URL */
    public String baseUrl = AIProviderType.CUSTOM.getDefaultBaseUrl();

    /** 配置验证状态 */
    public boolean configurationVerified;

    /** 最后验证时间 */
    public long lastVerifiedTime;

    /** 备注信息 */
    public String remark;

    /** 凭证 ID */
    public String credentialId;

    /** 模型参数 */
    public AIModelParameters modelParameters = new AIModelParameters();

    /** 运行时配置 */
    public AIRuntimeSettings runtimeSettings = new AIRuntimeSettings();

    /**
     * 创建配置副本
     */
    public AIProviderConfig copy() {
        AIProviderConfig copy = new AIProviderConfig();
        copy.providerType = this.providerType;
        copy.modelName = this.modelName;
        copy.baseUrl = this.baseUrl;
        copy.configurationVerified = this.configurationVerified;
        copy.lastVerifiedTime = this.lastVerifiedTime;
        copy.remark = this.remark;
        copy.credentialId = this.credentialId;
        copy.modelParameters = this.modelParameters.copy();
        copy.runtimeSettings = this.runtimeSettings.copy();
        return copy;
    }
}

/**
 * AI 凭证管理器
 * 基于 IntelliJ Password Safe 实现安全的 API Key 存储
 */
public class AICredentialManager {

    private final String serviceName;
    private final String keyPrefix;

    public AICredentialManager(@NotNull String serviceName, @NotNull String keyPrefix) {
        this.serviceName = serviceName;
        this.keyPrefix = keyPrefix;
    }

    /**
     * 存储 API Key
     */
    public void storeApiKey(@NotNull String credentialId, @NotNull String apiKey) {
        String key = buildKey(credentialId);
        PasswordSafe.getInstance().storePassword(serviceName, key, apiKey);
    }

    /**
     * 获取 API Key
     */
    @Nullable
    public String getApiKey(@NotNull String credentialId) {
        String key = buildKey(credentialId);
        try {
            return PasswordSafe.getInstance().getPassword(serviceName, key);
        } catch (Exception e) {
            // 处理异常
            return null;
        }
    }

    /**
     * 删除 API Key
     */
    public void removeApiKey(@NotNull String credentialId) {
        String key = buildKey(credentialId);
        PasswordSafe.getInstance().removePassword(serviceName, key);
    }

    /**
     * 构建唯一的存储键
     */
    @NotNull
    private String buildKey(@NotNull String credentialId) {
        return keyPrefix + credentialId;
    }
}

<!-- 在 plugin.xml 中定义扩展点 -->
<extensionPoints>
    <!-- AI 控制台日志提供者扩展点 -->
    <extensionPoint name="aiConsoleLoggerProvider"
                    interface="dev.dong4j.zeka.stack.idea.plugin.common.ai.AIConsoleLoggerProvider"/>
</extensionPoints>

<!-- 在业务插件中扩展 -->
<extensions defaultExtensionNs="dev.dong4j.zeka.stack.idea.plugin.common.ai">
    <!-- AI 控制台日志提供者 -->
    <aiConsoleLoggerProvider implementation="dev.dong4j.zeka.stack.idea.plugin.ai.JavaDocAIConsoleLoggerProvider"/>
</extensions>

/**
 * AI 控制台日志提供者接口
 * 允许业务插件提供自定义的日志实现
 */
public interface AIConsoleLoggerProvider {
    /**
     * 获取控制台日志记录器
     *
     * @param project 项目上下文
     * @return 日志记录器实例，如果没有则返回 null
     */
    @Nullable
    AIConsoleLogger getConsoleLogger(@NotNull Project project);
}

// 新增 ModelScope 服务商
public class ModelScopeProvider implements AIServiceProvider {

    @Override
    @NotNull
    public AIProviderType getProviderType() {
        return AIProviderType.MODELSCOPE;
    }

    @Override
    @NotNull
    public String generateContent(@NotNull AIChatRequest request,
                              @NotNull String apiKey,
                              @Nullable AIResponseListener listener) throws AIServiceException {

        // ModelScope 特定的实现
        return callModelScopeAPI(request, apiKey, listener);
    }

    // 其他接口实现...
}

// 在 JavaDoc 插件中调用 AI
public class JavaDocGenerator {

    public String generateJavaDoc(@NotNull Project project, @NotNull String code) {
        // 获取 AI 服务
        AIService aiService = AIServiceImpl.getInstance();

        // 获取插件配置
        AIProviderConfig config = getPluginConfig();

        // 构建请求
        AIChatRequest request = new AIChatRequest(
            "你是一个专业的 Java 开发者，请为以下代码生成 JavaDoc",
            "请为这段代码生成详细的 JavaDoc 注释：\n" + code
        );

        // 调用 AI 服务
        return aiService.generateContent(project, request, config, null);
    }
}

/**
 * 配置数据迁移工具
 */
public class ConfigMigrationUtil {

    /**
     * 迁移 JavaDoc 插件的配置
     */
    public static void migrateJavaDocConfig() {
        // 1. 读取旧配置
        OldJavaDocSettings oldSettings = OldJavaDocSettings.getInstance();

        // 2. 创建新的引擎配置
        AIProviderSettings engineSettings = AIProviderSettings.getInstance();

        // 3. 迁移配置项
        if (oldSettings.apiKey != null) {
            AIProviderConfig config = new AIProviderConfig();
            config.providerType = oldSettings.providerType;
            config.modelName = oldSettings.modelName;
            config.baseUrl = oldSettings.baseUrl;

            // 迁移 API Key 到凭证管理器
            AICredentialManager credentialManager = new AICredentialManager(
                "IntelliAI Engine", "AI_COMMON_"
            );
            credentialManager.storeApiKey("javadoc_default", oldSettings.apiKey);
            config.credentialId = "javadoc_default";

            // 添加到引擎配置
            engineSettings.addProviderConfig(config);
        }

        // 4. 清理旧配置（可选）
        // oldSettings.clear();
    }
}

/**
 * 服务类加载器工具
 * 用于处理插件间的类加载问题
 */
public class ServiceLoaderUtils {

    /**
     * 安全加载服务实现
     */
    @Nullable
    public static <T> T loadService(@NotNull Class<T> serviceInterface,
                                   @NotNull String implementationClass) {
        try {
            // 使用正确的类加载器
            ClassLoader loader = ServiceLoaderUtils.class.getClassLoader();
            Class<?> implClass = loader.loadClass(implementationClass);

            // 创建实例
            Object instance = implClass.getDeclaredConstructor().newInstance();

            return serviceInterface.cast(instance);

        } catch (Exception e) {
            // 记录错误，但不中断流程
            Logger.getInstance(ServiceLoaderUtils.class)
                .warn("Failed to load service: " + implementationClass, e);
            return null;
        }
    }
}

/**
 * 扩展点管理器
 * 安全管理扩展点的生命周期
 */
public class ExtensionPointManager {

    private final Project project;
    private final Map<String, Object> cache = new ConcurrentHashMap<>();

    /**
     * 安全获取扩展点实现
     */
    @Nullable
    public <T> T getExtension(@NotNull ExtensionPointName<T> extensionPointName) {
        String key = extensionPointName.getName();

        // 使用项目级别的缓存
        return (T) cache.computeIfAbsent(key, k -> {
            for (T extension : extensionPointName.getExtensionList()) {
                // 验证扩展点的有效性
                if (isValidExtension(extension)) {
                    return extension;
                }
            }
            return null;
        });
    }

    /**
     * 清理项目级别的缓存
     */
    public void dispose() {
        cache.clear();
    }
}

/**
 * 线程安全执行工具
 * 确保 AI 调用在正确的线程中执行
 */
public class ThreadSafeExecutor {

    /**
     * 在后台线程执行 AI 调用
     */
    public static <T> CompletableFuture<T> executeInBackground(@NotNull Callable<T> task) {
        CompletableFuture<T> future = new CompletableFuture<>();

        // 使用 ProgressManager 进行后台执行
        ProgressManager.getInstance().run(new Task.Backgroundable(null, "AI Processing") {
            @Override
            public void run(@NotNull ProgressIndicator indicator) {
                try {
                    T result = task.call();
                    // 在 UI 线程中完成 Future
                    ApplicationManager.getApplication().invokeLater(() -> {
                        future.complete(result);
                    });
                } catch (Exception e) {
                    // 在 UI 线程中处理异常
                    ApplicationManager.getApplication().invokeLater(() -> {
                        future.completeExceptionally(e);
                    });
                }
            }
        });

        return future;
    }
}

/**
 * 配置版本管理器
 * 处理不同版本的配置格式
 */
public class ConfigVersionManager {

    private static final int CURRENT_VERSION = 2;

    /**
     * 迁移配置到最新版本
     */
    public static void migrateToLatestVersion(@NotNull AIProviderSettings settings) {
        int version = settings.version != null ? settings.version : 1;

        switch (version) {
            case 1:
                migrateFromV1ToV2(settings);
                // fall through
            case 2:
                // 当前版本，无需迁移
                break;
            default:
                // 未知版本，记录警告
                Logger.getInstance(ConfigVersionManager.class)
                    .warn("Unknown config version: " + version);
        }

        settings.version = CURRENT_VERSION;
    }

    private static void migrateFromV1ToV2(@NotNull AIProviderSettings settings) {
        // V1 到 V2 的具体迁移逻辑
        // 例如：字段重命名、结构调整等
        if (settings.providers != null) {
            for (AIProviderConfig provider : settings.providers) {
                if (provider.temperature == null) {
                    // 新增默认值
                    provider.temperature = 0.7;
                }
            }
        }
    }
}

/**
 * 性能监控工具
 * 监控 AI 调用的性能指标
 */
public class PerformanceMonitor {

    private static final Map<String, PerformanceMetrics> metricsMap = new ConcurrentHashMap<>();

    /**
     * 记录性能指标
     */
    public static void recordMetrics(@NotNull String providerType,
                                   @NotNull String operation,
                                   long startTime,
                                   long endTime,
                                   int tokenCount) {
        String key = providerType + ":" + operation;
        PerformanceMetrics metrics = metricsMap.computeIfAbsent(key, k -> new PerformanceMetrics());

        long duration = endTime - startTime;

        metrics.record(duration, tokenCount);
    }

    /**
     * 获取性能报告
     */
    @NotNull
    public static String getPerformanceReport() {
        StringBuilder report = new StringBuilder();
        report.append("AI 服务性能报告\n");
        report.append("==================\n\n");

        for (Map.Entry<String, PerformanceMetrics> entry : metricsMap.entrySet()) {
            PerformanceMetrics metrics = entry.getValue();
            report.append(entry.getKey()).append(":\n");
            report.append(String.format("  平均响应时间: %.2f ms\n", metrics.getAverageDuration()));
            report.append(String.format("  总调用次数: %d\n", metrics.getCallCount()));
            report.append(String.format("  平均 Token 数: %.2f\n", metrics.getAverageTokens()));
            report.append(String.format("  成功率: %.2f%%\n", metrics.getSuccessRate() * 100));
            report.append("\n");
        }

        return report.toString();
    }
}

/**
 * AI 响应缓存管理器
 * 使用 LRU 策略缓存 AI 响应结果
 */
public class AIResponseCache {

    private static final int MAX_CACHE_SIZE = 1000;
    private static final long CACHE_EXPIRE_TIME = TimeUnit.HOURS.toMillis(1);

    private final Map<String, CacheEntry> cache = new LinkedHashMap<String, CacheEntry>(16, 0.75f, true) {
        @Override
        protected boolean removeEldestEntry(Map.Entry<String, CacheEntry> eldest) {
            return size() > MAX_CACHE_SIZE;
        }
    };

    /**
     * 获取缓存的响应
     */
    @Nullable
    public String getCachedResponse(@NotNull AIChatRequest request, @NotNull AIProviderConfig config) {
        String key = buildCacheKey(request, config);
        CacheEntry entry = cache.get(key);

        if (entry != null && !entry.isExpired()) {
            return entry.response;
        }

        if (entry != null && entry.isExpired()) {
            cache.remove(key);
        }

        return null;
    }

    /**
     * 缓存响应结果
     */
    public void cacheResponse(@NotNull AIChatRequest request,
                           @NotNull AIProviderConfig config,
                           @NotNull String response) {
        String key = buildCacheKey(request, config);
        CacheEntry entry = new CacheEntry(response, System.currentTimeMillis());
        cache.put(key, entry);
    }

    /**
     * 构建缓存键
     */
    @NotNull
    private String buildCacheKey(@NotNull AIChatRequest request, @NotNull AIProviderConfig config) {
        return request.getUserMessage() + "|" + config.providerType + "|" + config.modelName;
    }

    /**
     * 缓存条目
     */
    private static class CacheEntry {
        final String response;
        final long timestamp;

        CacheEntry(@NotNull String response, long timestamp) {
            this.response = response;
            this.timestamp = timestamp;
        }

        boolean isExpired() {
            return System.currentTimeMillis() - timestamp > CACHE_EXPIRE_TIME;
        }
    }
}

/**
 * AI 服务连接池管理器
 * 复用 HTTP 连接，提高并发性能
 */
public class ConnectionPoolManager {

    private static final int MAX_CONNECTIONS = 20;
    private static final int MAX_CONNECTIONS_PER_ROUTE = 5;
    private static final int CONNECTION_TIMEOUT_MS = 30000;
    private static final int READ_TIMEOUT_MS = 60000;

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

    /**
     * 获取 HTTP 客户端
     */
    @NotNull
    public CloseableHttpClient getClient(@NotNull String baseUrl) {
        return clientMap.computeIfAbsent(baseUrl, k -> createHttpClient());
    }

    /**
     * 创建 HTTP 客户端
     */
    @NotNull
    private CloseableHttpClient createHttpClient() {
        ConnectionConfig connectionConfig = ConnectionConfig.custom()
            .setCharset(Charset.forName("UTF-8"))
            .build();

        SocketConfig socketConfig = SocketConfig.custom()
            .setSoTimeout(READ_TIMEOUT_MS)
            .build();

        RequestConfig requestConfig = RequestConfig.custom()
            .setConnectTimeout(CONNECTION_TIMEOUT_MS)
            .setConnectionRequestTimeout(CONNECTION_TIMEOUT_MS)
            .setSocketTimeout(READ_TIMEOUT_MS)
            .build();

        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
        connectionManager.setMaxTotal(MAX_CONNECTIONS);
        connectionManager.setDefaultMaxPerRoute(MAX_CONNECTIONS_PER_ROUTE);
        connectionManager.setConnectionConfig(connectionConfig);
        connectionManager.setSocketConfig(socketConfig);

        return HttpClients.custom()
            .setConnectionManager(connectionManager)
            .setDefaultRequestConfig(requestConfig)
            .setConnectionTimeToLive(CONNECTION_TIMEOUT_MS, TimeUnit.MILLISECONDS)
            .evictIdleConnections(30000, TimeUnit.MILLISECONDS)
            .build();
    }

    /**
     * 关闭所有连接
     */
    public void shutdown() {
        for (CloseableHttpClient client : clientMap.values()) {
            try {
                client.close();
            } catch (IOException e) {
                Logger.getInstance(ConnectionPoolManager.class)
                    .warn("Failed to close HTTP client", e);
            }
        }
        clientMap.clear();
    }
}