using Dpz.Core.Public.ViewModel.Response;

namespace Dpz.Core.Service.Mediator.Features.Article.Contracts;

/// <summary>
/// 文章搜索出参
/// </summary>
public class ArticleResponseSearchResultResponse : ArticleResponse
{
    /// <summary>
    /// 标题搜索结果
    /// </summary>
    public List<SearchResult> TitleSearchResult { get; set; } = [];

    /// <summary>
    /// 内容搜索结果 --> Markdown
    /// </summary>
    public List<SearchResult> ContentSearchResult { get; set; } = [];

    /// <summary>
    /// 生成高亮后的标题。
    /// </summary>
    public string HighlightTitle()
    {
        if (TitleSearchResult.Count == 0)
        {
            return Title;
        }
        return HighlightText(TitleSearchResult, Title);
    }

    /// <summary>
    /// 生成高亮后的正文内容。
    /// </summary>
    public string HighlightContent(bool readAll = false)
    {
        if (ContentSearchResult.Count == 0)
        {
            return "";
        }
        return HighlightText(ContentSearchResult, Markdown, readAll);
    }

    private static string HighlightText(
        List<SearchResult> searchResults,
        string text,
        bool readAll = false
    )
    {
        var highlightedText = new StringBuilder();
        using var reader = new StringReader(text);
        var lineNumber = 1;
        // 维护 fenced code block (``` / ~~~) 的跨行状态。
        var codeFenceState = new CodeFenceState();

        var groupedResults = searchResults
            .GroupBy(x => x.LineNumber)
            .ToDictionary(x => x.Key, x => x.ToList());

        while (reader.ReadLine() is { } line)
        {
            // 先更新当前行是否触发代码围栏开闭，再决定本行是否属于代码块。
            var isCodeFenceDelimiter = TryUpdateCodeFenceState(line, codeFenceState);
            var isInsideCodeFence = codeFenceState.IsInsideFence || isCodeFenceDelimiter;

            if (groupedResults.TryGetValue(lineNumber, out var matchesInLine))
            {
                // 记录不允许插入 <mark> 的区间，避免破坏 Markdown 结构。
                var unsafeRanges = new List<(int Start, int End)>();

                if (isInsideCodeFence)
                {
                    // 代码块整行禁用高亮。
                    unsafeRanges.Add((0, line.Length));
                }

                var linkMatches = System.Text.RegularExpressions.Regex.Matches(
                    line,
                    @"!?\[.*?\]\((.*?)\)"
                );
                foreach (System.Text.RegularExpressions.Match m in linkMatches)
                {
                    if (m.Groups.Count > 1)
                    {
                        // 仅保护链接目标 URL 区域，避免将链接语法打断。
                        var g = m.Groups[1];
                        unsafeRanges.Add((g.Index, g.Index + g.Length));
                    }
                }

                // 行内代码 (`...`) 区域同样不执行高亮。
                unsafeRanges.AddRange(GetInlineCodeRanges(line));

                var sortedMatches = matchesInLine.OrderBy(x => x.StartIndex).ToList();
                var highlightedLine = line;
                var offset = 0;

                foreach (var result in sortedMatches)
                {
                    if (
                        unsafeRanges.Any(r =>
                            result.StartIndex >= r.Start && result.EndIndex < r.End
                        )
                    )
                    {
                        continue;
                    }

                    var adjustedStartIndex = result.StartIndex + offset;
                    var adjustedEndIndex = result.EndIndex + offset;

                    var beforeMatch = highlightedLine[..adjustedStartIndex];
                    var match = highlightedLine.Substring(
                        adjustedStartIndex,
                        adjustedEndIndex - adjustedStartIndex + 1
                    );
                    var afterMatch = highlightedLine[(adjustedEndIndex + 1)..];

                    highlightedLine = $"{beforeMatch}{HighlightTag(match)}{afterMatch}";
                    // 每插入一对 <mark></mark> 都会改变后续索引，需累计偏移。
                    offset += HighlightTag(null).Length;
                }

                highlightedText.AppendLine(highlightedLine);
            }
            else if (readAll)
            {
                highlightedText.AppendLine(line);
            }
            lineNumber++;
        }

        return highlightedText.ToString();

        string HighlightTag(string? match)
        {
            return $"<mark>{match}</mark>";
        }
    }

    private sealed class CodeFenceState
    {
        /// <summary>
        /// 是否已进入 fenced code block。
        /// </summary>
        public bool IsInsideFence { get; set; }

        /// <summary>
        /// 围栏字符：` 或 ~。
        /// </summary>
        public char FenceChar { get; set; }

        /// <summary>
        /// 围栏长度，结束时要求同字符且数量不少于起始长度。
        /// </summary>
        public int FenceLength { get; set; }
    }

    private static bool TryUpdateCodeFenceState(string line, CodeFenceState state)
    {
        // 仅识别行首（忽略缩进）围栏，避免误判正文中的反引号。
        var trimmed = line.TrimStart();
        if (trimmed.Length < 3)
        {
            return false;
        }

        var firstChar = trimmed[0];
        if (firstChar != '`' && firstChar != '~')
        {
            return false;
        }

        var length = 0;
        while (length < trimmed.Length && trimmed[length] == firstChar)
        {
            length++;
        }

        if (length < 3)
        {
            return false;
        }

        if (!state.IsInsideFence)
        {
            // 命中起始围栏，进入代码块模式。
            state.IsInsideFence = true;
            state.FenceChar = firstChar;
            state.FenceLength = length;
            return true;
        }

        if (state.FenceChar == firstChar && length >= state.FenceLength)
        {
            // 命中匹配的结束围栏，退出代码块模式。
            state.IsInsideFence = false;
            state.FenceChar = default;
            state.FenceLength = 0;
            return true;
        }

        return false;
    }

    private static IEnumerable<(int Start, int End)> GetInlineCodeRanges(string line)
    {
        // 支持多个连续反引号包裹的行内代码（如 ``code `x` ``）。
        var i = 0;
        while (i < line.Length)
        {
            if (line[i] != '`')
            {
                i++;
                continue;
            }

            var start = i;
            var tickCount = 0;
            while (i < line.Length && line[i] == '`')
            {
                tickCount++;
                i++;
            }

            var contentStart = i;
            var matched = false;
            while (i < line.Length)
            {
                if (line[i] != '`')
                {
                    i++;
                    continue;
                }

                var closeTickCount = 0;
                var closeStart = i;
                while (i < line.Length && line[i] == '`')
                {
                    closeTickCount++;
                    i++;
                }

                if (closeTickCount == tickCount)
                {
                    var endExclusive = closeStart + closeTickCount;
                    // 与现有逻辑保持一致：使用 [start, endExclusive) 语义。
                    yield return (start, endExclusive);
                    matched = true;
                    break;
                }
            }

            if (!matched)
            {
                i = contentStart;
            }
        }
    }
}