using System.Text;
using System.Text.Json;
using Dpz.Core.Infrastructure;
using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.MessageQueue.Models;
using Dpz.Core.Public.ViewModel.Messages;
using Dpz.Core.Service.Mcp;
using Dpz.Core.Service.Network;
using Dpz.Core.Service.RepositoryService;
using Dpz.Core.Web.Jobs.Services;
using JetBrains.Annotations;
using Medallion.Threading;
using OpenAI.Chat;
using ZiggyCreatures.Caching.Fusion;

namespace Dpz.Core.Web.Jobs.MessageHandlers;

/// <summary>
/// 代码分析消息处理器
/// </summary>
[UsedImplicitly]
public class AnalyzeCodeHandler(
    IOpenAiService openAiService,
    ICodeFileSystemEntryService codeFileSystemEntryService,
    IInProcessMcpSessionFactory mcpSessionFactory,
    IDistributedLockProvider distributedLockProvider,
    IFusionCache fusionCache,
    IPushMessage pushMessage,
    ILogger<AnalyzeCodeHandler> logger
) : IMessageHandler<AnalyzeCodeMessage>
{
    /// <summary>
    /// 流式文本增量推送间隔（毫秒）
    /// </summary>
    private const int DeltaFlushIntervalMilliseconds = 100;

    /// <summary>
    /// 待推送的流式文本增量缓冲
    /// </summary>
    private readonly List<string> _pendingDeltaBuffer = [];

    private DateTime _lastDeltaFlushTime = DateTime.UtcNow;

    /// <summary>
    /// 当前分析文件的进度标识（与代码浏览页面路由一致）
    /// </summary>
    private string _progressFileKey = "";

    public async Task<MessageHandlerResult> HandleAsync(
        AnalyzeCodeMessage message,
        CancellationToken cancellationToken
    )
    {
        var dedupeKey = string.Empty;
        try
        {
            // 1. 基本校验：代码行数必须 >= 50
            if (GetContentLineCount(message.CodeContent) < 50)
            {
                logger.LogInformation(
                    "代码行数不足50行，跳过分析。Path:{@Path} File:{FileName} Lines:{Lines}",
                    message.Path,
                    message.FileName,
                    GetContentLineCount(message.CodeContent)
                );
                return MessageHandlerResult.Ok();
            }

            // 2. 生成去重键
            var keyParts = new List<string>(message.Path) { message.FileName, message.FileHash };
            var subKey = Convert.ToBase64String(
                Encoding.UTF8.GetBytes(string.Join("\0", keyParts))
            );
            dedupeKey = $"AI_Analyze.InProgress:{subKey}";

            // 3. 检查是否已有进行中的分析任务
            var wasSet = await fusionCache.TryGetAsync<bool>(dedupeKey, token: cancellationToken);
            if (wasSet.HasValue && wasSet.Value)
            {
                logger.LogInformation(
                    "已有分析任务进行中，跳过重复处理。Path:{@Path} File:{FileName} Hash:{Hash}",
                    message.Path,
                    message.FileName,
                    message.FileHash
                );
                return MessageHandlerResult.Ok();
            }

            // 4. 设置进行中标记
            var cacheOptions = new FusionCacheEntryOptions
            {
                Duration = TimeSpan.FromMinutes(30),
                AllowBackgroundDistributedCacheOperations = false,
            };
            await fusionCache.SetAsync(dedupeKey, true, cacheOptions, cancellationToken);

            // 5. 分布式锁
            var pathParts = new List<string>(message.Path) { message.FileName };
            var lockSubKey = Convert.ToBase64String(
                Encoding.UTF8.GetBytes(string.Join("\0", pathParts))
            );
            var lockKey = $"AI_Analyze.Code.Lock:{lockSubKey}";

            await using (
                await distributedLockProvider.AcquireLockAsync(
                    lockKey,
                    cancellationToken: cancellationToken
                )
            )
            {
                // 6. 再次检查文件是否存在及是否需要分析
                var entryPath = pathParts.ToArray();
                var entry = await codeFileSystemEntryService.FindByPathWithoutCacheAsync(
                    entryPath,
                    cancellationToken
                );

                if (entry == null)
                {
                    logger.LogWarning(
                        "文件不存在，跳过分析。Path:{@Path} File:{FileName}",
                        message.Path,
                        message.FileName
                    );
                    return MessageHandlerResult.Ok();
                }

                // 7. 检查是否已有最新分析结果（哈希值匹配）
                var hasFreshAnalyzeResult =
                    !string.IsNullOrWhiteSpace(entry.AiAnalyzeResult)
                    && string.Equals(
                        entry.AiAnalyzeHash,
                        message.FileHash,
                        StringComparison.OrdinalIgnoreCase
                    );

                if (hasFreshAnalyzeResult)
                {
                    logger.LogInformation(
                        "已有最新分析结果，跳过。Path:{@Path} File:{FileName} Hash:{Hash}",
                        message.Path,
                        message.FileName,
                        message.FileHash
                    );
                    return MessageHandlerResult.Ok();
                }

                // 8. 通知前端分析开始，并调用 AI 分析（允许模型通过 MCP 查询相关文件）
                var filePath = string.Join('/', pathParts);
                _progressFileKey = filePath;
                await PushProgressStageAsync(
                    CodeAnalyzeStage.Started,
                    $"开始分析代码文件：{message.FileName}"
                );

                var prompt = BuildAnalysisPrompt(filePath);
                await using var mcpSession = await mcpSessionFactory.CreateAsync(cancellationToken);
                var result = await openAiService.SendMessageWithMcpAsync(
                    messages:
                    [
                        new SystemChatMessage(prompt),
                        new UserChatMessage(
                            $"当前文件路径：{filePath}\n\n```\n{message.CodeContent}\n```"
                        ),
                    ],
                    mcpClient: mcpSession.Client,
                    onDeltaContentAsync: PushContentDeltaAsync,
                    onToolCallAsync: PushToolCallAsync,
                    options: x =>
                    {
                        x.Model = "deepseek-v4-flash";
                    },
                    maxToolRounds: 16,
                    cancellationToken: cancellationToken
                );

                // 推送剩余未刷出的流式增量
                await FlushContentAsync(cancellationToken);

                // 9. 保存分析结果
                if (result is { Success: true, Data: not null })
                {
                    var content = result.Data.Content;
                    if (string.IsNullOrWhiteSpace(content))
                    {
                        logger.LogWarning(
                            "AI分析未产出文本,跳过保存. Path:{@Path} File:{FileName}",
                            message.Path,
                            message.FileName
                        );
                        await PushProgressStageAsync(
                            CodeAnalyzeStage.Failed,
                            "AI 分析未产出文本，已跳过保存。"
                        );
                        return MessageHandlerResult.Fail("AI分析未产出文本结果");
                    }

                    // 10. 再次验证文件未变更（关键！防止在 AI 调用期间文件被修改）
                    var latestEntry = await codeFileSystemEntryService.FindByPathWithoutCacheAsync(
                        entryPath,
                        cancellationToken
                    );

                    if (
                        latestEntry == null
                        || !string.Equals(
                            latestEntry.Hash,
                            message.FileHash,
                            StringComparison.OrdinalIgnoreCase
                        )
                    )
                    {
                        logger.LogInformation(
                            "文件已变更，跳过保存过期分析结果。Path:{@Path} File:{FileName} MessageHash:{MessageHash} CurrentHash:{CurrentHash}",
                            message.Path,
                            message.FileName,
                            message.FileHash,
                            latestEntry?.Hash
                        );
                        await PushProgressStageAsync(
                            CodeAnalyzeStage.Completed,
                            "分析期间文件内容已变更，正在重新加载最新内容。"
                        );
                        return MessageHandlerResult.Ok();
                    }

                    // 11. 保存 AI 分析结果到数据库
                    await codeFileSystemEntryService.SaveAiAnalyzeResultAsync(
                        message.Path,
                        message.FileName,
                        content,
                        message.FileHash,
                        cancellationToken
                    );

                    await PushProgressStageAsync(CodeAnalyzeStage.Completed, "代码分析完成");

                    logger.LogInformation(
                        "AI分析成功。Path:{@Path} File:{FileName} Hash:{Hash}",
                        message.Path,
                        message.FileName,
                        message.FileHash
                    );
                }
                else
                {
                    logger.LogWarning(
                        "AI分析失败:{Message} | Path:{@Path} File:{FileName} Args:{@Arguments}",
                        result.Message,
                        message.Path,
                        message.FileName,
                        result.Arguments
                    );
                    await PushProgressStageAsync(
                        CodeAnalyzeStage.Failed,
                        $"AI 分析失败：{result.Message ?? "未知错误"}"
                    );
                    return MessageHandlerResult.Fail($"AI分析失败: {result.Message ?? "未知错误"}");
                }
            }

            return MessageHandlerResult.Ok();
        }
        catch (Exception ex)
        {
            logger.LogError(
                ex,
                "代码分析异常。Path:{@Path} File:{FileName} Hash:{Hash}",
                message.Path,
                message.FileName,
                message.FileHash
            );
            // 把流式中断前已产生的增量补推，便于前端展示部分内容
            await FlushContentAsync(cancellationToken);
            await PushProgressStageAsync(CodeAnalyzeStage.Failed, $"代码分析异常：{ex.Message}");
            return MessageHandlerResult.Fail($"代码分析异常: {ex.Message}");
        }
        finally
        {
            // 12. 清除进行中标记
            if (!string.IsNullOrEmpty(dedupeKey))
            {
                await fusionCache.RemoveAsync(dedupeKey, token: cancellationToken);
            }
        }
    }

    /// <summary>
    /// 推送分析进度阶段消息（推送失败不影响分析主流程）
    /// </summary>
    private async Task PushProgressStageAsync(int stage, string message)
    {
        if (string.IsNullOrEmpty(_progressFileKey))
        {
            return;
        }

        try
        {
            await pushMessage.PushCodeAnalyzeProgressAsync(
                new CodeAnalyzeProgressMessage
                {
                    FileKey = _progressFileKey,
                    Stage = stage,
                    Message = message,
                }
            );
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "推送代码分析进度失败 Stage:{Stage}", stage);
        }
    }

    /// <summary>
    /// 将 MCP 工具调用转换为中文进度说明并推送
    /// </summary>
    private Task PushToolCallAsync(
        string toolName,
        string argumentsJson,
        CancellationToken cancellationToken
    )
    {
        var target = ExtractToolTarget(argumentsJson);
        var message = (toolName, target) switch
        {
            ("list_directory", not null) => $"正在查看目录：{target}",
            ("list_directory", null) => "正在查看目录内容…",
            ("read_file", not null) => $"正在读取文件：{target}",
            ("read_file", null) => "正在读取相关文件…",
            ("search_files", not null) => $"正在查找文件：{target}",
            ("search_files", null) => "正在查找相关文件…",
            ("search_content", not null) => $"正在搜索代码：{target}",
            ("search_content", null) => "正在搜索相关代码…",
            ("get_file_info", not null) => $"正在获取文件信息：{target}",
            ("get_file_info", null) => "正在获取文件信息…",
            _ => $"正在调用工具：{toolName}",
        };
        return PushProgressStageAsync(CodeAnalyzeStage.Tool, message);
    }

    /// <summary>
    /// 从工具参数 JSON 中提取目标路径或关键字用于进度展示
    /// </summary>
    private static string? ExtractToolTarget(string argumentsJson)
    {
        try
        {
            using var document = JsonDocument.Parse(argumentsJson);
            var root = document.RootElement;
            foreach (var propertyName in new[] { "path", "directory", "pattern", "keyword" })
            {
                if (
                    root.TryGetProperty(propertyName, out var property)
                    && property.ValueKind == JsonValueKind.String
                )
                {
                    return property.GetString();
                }
            }
        }
        catch (JsonException)
        {
            // 参数不是合法 JSON 时忽略
        }

        return null;
    }

    /// <summary>
    /// 缓冲流式文本增量，按间隔批量推送
    /// </summary>
    private async Task PushContentDeltaAsync(string delta, CancellationToken cancellationToken)
    {
        _pendingDeltaBuffer.Add(delta);
        if (
            (DateTime.UtcNow - _lastDeltaFlushTime).TotalMilliseconds
            < DeltaFlushIntervalMilliseconds
        )
        {
            return;
        }

        await FlushContentAsync(cancellationToken);
    }

    /// <summary>
    /// 将缓冲的流式文本一次性推送
    /// </summary>
    private async Task FlushContentAsync(CancellationToken cancellationToken)
    {
        if (_pendingDeltaBuffer.Count == 0 || string.IsNullOrEmpty(_progressFileKey))
        {
            return;
        }

        var content = string.Concat(_pendingDeltaBuffer);
        _pendingDeltaBuffer.Clear();
        _lastDeltaFlushTime = DateTime.UtcNow;

        try
        {
            await pushMessage.PushCodeAnalyzeProgressAsync(
                new CodeAnalyzeProgressMessage
                {
                    FileKey = _progressFileKey,
                    Stage = CodeAnalyzeStage.Content,
                    Content = content,
                }
            );
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "推送代码分析流式内容失败");
        }
    }

    /// <summary>
    /// 构建 AI 分析提示词
    /// </summary>
    /// <param name="filePath">当前正在分析的文件相对路径</param>
    private static string BuildAnalysisPrompt(string filePath)
    {
        return new StringBuilder()
            .AppendLine("你是一个经验丰富且专业的开发人员。")
            .AppendLine()
            .AppendLine($"当前需要解释的文件路径是：{filePath}")
            .AppendLine("用户消息中包含该文件的完整内容。")
            .AppendLine()
            .AppendLine("代码如果足够简单，直接分析即可。")
            .AppendLine(
                "代码如果复杂，不要猜测含义。请主动使用提供的 MCP 工具，MCP工具调用限制在16轮以内："
            )
            .AppendLine("- list_directory：查看同目录其它文件")
            .AppendLine("- read_file：阅读 import/using 或引用指向的相关文件")
            .AppendLine("- search_files：按文件名查找类型或模块")
            .AppendLine("- search_content：在源码内容中搜索符号或字符串")
            .AppendLine("- get_file_info：查看元数据和已有 AI 分析结果")
            .AppendLine()
            .AppendLine("在掌握足够上下文后，解释上述代码的用途、职责以及它如何与相关文件协作。")
            .AppendLine("回复要求：")
            .AppendLine("- 使用简体中文")
            .AppendLine("- 引用相关文件时使用Markdown链接格式，形如： [Y.cs](X/Y.cs)")
            .AppendLine("- 未通过工具确认的符号或调用关系不要臆断，直接说明")
            .AppendLine(
                "- 对于超长、足够复杂、存在明显执行/调用流程时的代码，使用mermaid画出流程图，流程图必须放在 mermaid 代码块中"
            )
            .AppendLine()
            .AppendLine("最终回复必须是对该文件描述的自然语言的报告，不要再发起工具调用。")
            .AppendLine()
            .ToString();
    }

    /// <summary>
    /// 获取代码内容行数
    /// </summary>
    private static int GetContentLineCount(string codeContent)
    {
        return codeContent.Split(["\r\n", "\r", "\n"], StringSplitOptions.None).Length;
    }
}