using System.Text.RegularExpressions;

namespace Dpz.Core.Service.Mediator.Features.Search;

/// <summary>
/// 统一分析搜索关键字，兼容中英文输入并生成查询词与高亮词。
/// </summary>
public static partial class SearchKeywordAnalyzer
{
    private const int MaxQueryTerms = 8;
    private const int MaxHighlightTerms = 24;

    /// <summary>
    /// 分析用户输入，生成规范化关键字、查询词和高亮词。
    /// </summary>
    public static SearchKeywordAnalysis Analyze(string? keyword)
    {
        var normalizedKeyword = Normalize(keyword);
        if (string.IsNullOrWhiteSpace(normalizedKeyword))
        {
            return SearchKeywordAnalysis.Empty;
        }

        var queryTerms = new List<string>();
        var highlightTerms = new List<string>();

        var rawTokens = TokenRegex()
            .Matches(normalizedKeyword)
            .Select(x => x.Value)
            .Where(x => !string.IsNullOrWhiteSpace(x))
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .ToList();

        foreach (var token in rawTokens)
        {
            if (ContainsCjk(token))
            {
                AddTerm(queryTerms, token);
                AddTerm(highlightTerms, token);

                foreach (var gram in BuildNGrams(token, 2))
                {
                    AddTerm(queryTerms, gram);
                    AddTerm(highlightTerms, gram);
                }
                continue;
            }

            AddTerm(queryTerms, token.ToLowerInvariant());
            AddTerm(highlightTerms, token);
        }

        if (queryTerms.Count == 0)
        {
            AddTerm(queryTerms, normalizedKeyword);
            AddTerm(highlightTerms, normalizedKeyword);
        }

        var sortedQueryTerms = queryTerms
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .OrderByDescending(x => x.Length)
            .ThenBy(x => x, StringComparer.OrdinalIgnoreCase)
            .Take(MaxQueryTerms)
            .ToList();

        var sortedHighlightTerms = highlightTerms
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .OrderByDescending(x => x.Length)
            .ThenBy(x => x, StringComparer.OrdinalIgnoreCase)
            .Take(MaxHighlightTerms)
            .ToList();

        return new SearchKeywordAnalysis(normalizedKeyword, sortedQueryTerms, sortedHighlightTerms);
    }

    /// <summary>
    /// 将关键词转成正则并按长度降序，避免短词吞噬长词。
    /// </summary>
    public static string BuildRegexPattern(IEnumerable<string> terms)
    {
        var escapedTerms = terms
            .Where(x => !string.IsNullOrWhiteSpace(x))
            .Select(Regex.Escape)
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .OrderByDescending(x => x.Length)
            .ToList();
        return escapedTerms.Count == 0 ? string.Empty : string.Join('|', escapedTerms);
    }

    private static string Normalize(string? keyword)
    {
        if (string.IsNullOrWhiteSpace(keyword))
        {
            return string.Empty;
        }

        return string.Join(
            ' ',
            keyword.Split([' ', '\t', '\r', '\n'], StringSplitOptions.RemoveEmptyEntries)
        );
    }

    private static bool ContainsCjk(string token)
    {
        return CjkRegex().IsMatch(token);
    }

    private static IEnumerable<string> BuildNGrams(string token, int n)
    {
        if (token.Length < n)
        {
            yield break;
        }

        for (var i = 0; i <= token.Length - n; i++)
        {
            yield return token.Substring(i, n);
        }
    }

    private static void AddTerm(List<string> terms, string candidate)
    {
        if (string.IsNullOrWhiteSpace(candidate) || candidate.Length < 2)
        {
            return;
        }

        terms.Add(candidate);
    }

    [GeneratedRegex(@"[\p{L}\p{N}]+", RegexOptions.Compiled | RegexOptions.CultureInvariant)]
    private static partial Regex TokenRegex();
    [GeneratedRegex(@"[\u4E00-\u9FFF]", RegexOptions.Compiled | RegexOptions.CultureInvariant)]
    private static partial Regex CjkRegex();
}

/// <summary>
/// 搜索关键词分析结果。
/// </summary>
public sealed record SearchKeywordAnalysis(
    string NormalizedKeyword,
    IReadOnlyList<string> QueryTerms,
    IReadOnlyList<string> HighlightTerms
)
{
    public static readonly SearchKeywordAnalysis Empty = new(string.Empty, [], []);
}