using System.Text.RegularExpressions;
using Dpz.Core.Entity.Base.ExpressTreeQuery;
using Dpz.Core.Public.ViewModel.Request;
using Dpz.Core.Public.ViewModel.Response;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class CodeFileSystemEntryService(
    IRepository<CodeFileSystemEntry> repository,
    IConfiguration configuration,
    ILogger<CodeFileSystemEntryService> logger,
    IFusionCache fusionCache
) : ICodeFileSystemEntryService
{
    private static readonly TimeSpan CacheDefaultExpiration = TimeSpan.FromDays(7);

    private readonly Lazy<CodeViewOption> _codeViewCfg = new(() =>
    {
        var codeView = configuration.GetSection("CodeView").Get<CodeViewOption>();
        return codeView ?? throw new InvalidConfigurationException("CodeView 配置无效");
    });

    public async Task<CodeFileSystemEntryResponse?> FindByPathAsync(
        IReadOnlyCollection<string>? pathSegments,
        CancellationToken cancellationToken = default
    )
    {
        var segments = NormalizeSegments(pathSegments);
        var cacheKey = BuildPathKey(segments);
        return await GetOrSetCacheAsync<CodeFileSystemEntryResponse?>(
            nameof(FindByPathAsync),
            "Path=" + cacheKey,
            ct => FindByPathCoreAsync(segments, ct),
            cancellationToken: cancellationToken
        );
    }

    public async Task<CodeFileSystemEntryResponse?> FindByPathWithoutCacheAsync(
        IReadOnlyCollection<string>? pathSegments,
        CancellationToken cancellationToken = default
    )
    {
        var segments = NormalizeSegments(pathSegments);
        return await FindByPathCoreAsync(segments, cancellationToken);
    }

    public async Task<List<CodeFileSystemEntryResponse>> GetChildrenAsync(
        IReadOnlyCollection<string>? parentPathSegments,
        CancellationToken cancellationToken = default
    )
    {
        var segments = NormalizeSegments(parentPathSegments);
        var cacheKey = BuildPathKey(segments);
        return await GetOrSetCacheAsync<List<CodeFileSystemEntryResponse>>(
            nameof(GetChildrenAsync),
            "Parent=" + cacheKey,
            async ct =>
            {
                var filter = Builders<CodeFileSystemEntry>.Filter.Eq(
                    x => x.ParentPathSegments,
                    segments
                );
                var entries = await repository.SearchFor(filter).ToListAsync(ct);
                return await MapToResponseListAsync(entries, ct);
            },
            cancellationToken: cancellationToken
        );
    }

    public async Task<List<CodeFileSystemEntryResponse>> SearchAsync(
        string keyword,
        CancellationToken cancellationToken = default
    )
    {
        if (string.IsNullOrWhiteSpace(keyword))
        {
            return [];
        }

        return await GetOrSetCacheAsync<List<CodeFileSystemEntryResponse>>(
            nameof(SearchAsync),
            "Keyword=" + keyword,
            async ct =>
            {
                var filter = Builders<CodeFileSystemEntry>.Filter.Regex(
                    x => x.Name,
                    new BsonRegularExpression(BuildSearchPattern(keyword), "i")
                );
                var entries = await repository.SearchFor(filter).ToListAsync(ct);
                return await MapToResponseListAsync(entries, ct);
            },
            cancellationToken: cancellationToken
        );
    }

    /// <inheritdoc />
    public async Task<List<CodeContentSearchHitResponse>> SearchContentAsync(
        string query,
        int? maxResults = null,
        CancellationToken cancellationToken = default
    )
    {
        var pattern = CodeContentSearch.BuildEscapedPattern(query);
        if (pattern == null)
        {
            return [];
        }

        // 字面量转义后再做不区分大小写的正则,避免用户输入变成 Mongo 正则炸弹
        var limit = CodeContentSearch.ClampMaxResults(maxResults);
        var filter = Builders<CodeFileSystemEntry>.Filter.And(
            Builders<CodeFileSystemEntry>.Filter.Eq(x => x.IsDirectory, false),
            Builders<CodeFileSystemEntry>.Filter.Eq(
                x => x.CodeFileContentType,
                CodeFileContentType.Text
            ),
            Builders<CodeFileSystemEntry>.Filter.Regex(
                x => x.FileContent,
                new BsonRegularExpression(pattern, "i")
            )
        );

        var entries = await repository
            .SearchFor(filter)
            .Limit(limit)
            .ToListAsync(cancellationToken);

        return entries
            .Select(entry => new CodeContentSearchHitResponse
            {
                PathSegments = entry.PathSegments.ToList(),
                Name = entry.Name,
                Path = string.Join('/', entry.PathSegments),
                Snippet = CodeContentSearch.BuildSnippet(entry.FileContent, query),
            })
            .ToList();
    }

    /// <summary>
    /// 将用户输入转换为安全的 MongoDB 正则：
    /// `*` 视为任意字符、`?` 视为单个字符通配符，其余正则元字符按字面量匹配；
    /// 含通配符时整体锚定首尾（glob 语义），否则保持子串匹配。
    /// </summary>
    private static string BuildSearchPattern(string keyword)
    {
        var hasWildcard = keyword.Contains('*') || keyword.Contains('?');
        var pattern = ApplicationTools.WildcardToRegexPattern(keyword);
        return hasWildcard ? $"^{pattern}$" : pattern;
    }

    public async Task<IPagedList<CodeFileSystemEntryListResponse>> GetPagedListAsync(
        CodeFlatRequest request,
        CancellationToken cancellationToken = default
    )
    {
        // 生成查询条件
        var filter = GenerateConditionFilter.GenerateConditionExpressionTree<
            CodeFileSystemEntry,
            CodeFlatRequest
        >(request);

        var query = repository.SearchFor(filter);

        // 应用排序
        if (request.SortField.HasValue)
        {
            query = request.SortField.Value switch
            {
                CodeFileSortField.Size => request.IsDescending
                    ? query.OrderByDescending(x => x.Size)
                    : query.OrderBy(x => x.Size),
                CodeFileSortField.CreatedTime => request.IsDescending
                    ? query.OrderByDescending(x => x.CreatedTime)
                    : query.OrderBy(x => x.CreatedTime),
                CodeFileSortField.LastWriteTime => request.IsDescending
                    ? query.OrderByDescending(x => x.LastWriteTime)
                    : query.OrderBy(x => x.LastWriteTime),
                CodeFileSortField.LastUpdateTime => request.IsDescending
                    ? query.OrderByDescending(x => x.LastUpdateTime)
                    : query.OrderBy(x => x.LastUpdateTime),
                CodeFileSortField.AiAnalyzeTime => request.IsDescending
                    ? query.OrderByDescending(x => x.AiAnalyzeTime)
                    : query.OrderBy(x => x.AiAnalyzeTime),
                _ => query,
            };
        }

        // 执行分页查询
        var entityPagedList = await query
            .Select(x => new CodeFileSystemEntryListResponse
            {
                Id = x.Id.ToString(),
                PathSegments = x.PathSegments,
                Name = x.Name,
                ParentPathSegments = x.ParentPathSegments,
                IsDirectory = x.IsDirectory,
                Extension = x.Extension,
                Size = x.Size,
                Hash = x.Hash,
                CodeFileContentType = x.CodeFileContentType,
                CodeLanguage = x.CodeLanguage,
                Tags = x.Tags,
                CreatedTime = x.CreatedTime,
                LastWriteTime = x.LastWriteTime,
                LastUpdateTime = x.LastUpdateTime,
                Description = x.Description,
                AiAnalyzeTime = x.AiAnalyzeTime,
                AiAnalyzeHash = x.AiAnalyzeHash,
            })
            .ToPagedListAsync(request.PageIndex, request.PageSize, cancellationToken);

        entityPagedList.ForEach(x =>
            x.CodeLanguage = ResolveCodeLanguage(x.IsDirectory, x.Extension, x.Name)
        );

        return entityPagedList;
    }

    public async Task<List<string[]>> GetAllDirectoriesAsync(
        string[]? pathSegments = null,
        CancellationToken cancellationToken = default
    )
    {
        var normalizedPath = NormalizeSegments(pathSegments);
        var pathKey = BuildPathKey(normalizedPath);

        return await GetOrSetCacheAsync<List<string[]>>(
            nameof(GetAllDirectoriesAsync),
            "Path=" + pathKey,
            async ct =>
            {
                var filterBuilder = Builders<CodeFileSystemEntry>.Filter;
                var filter = filterBuilder.Eq(x => x.IsDirectory, true);

                // 如果指定了路径，则只查询该路径及其所有子目录
                if (normalizedPath.Count > 0)
                {
                    // 查询所有 PathSegments 以 normalizedPath 开头的目录
                    // 先查询所有目录，然后在内存中过滤
                    var allDirectories = await repository
                        .SearchFor(filter)
                        .ToListAsync(cancellationToken: ct);

                    var filteredDirectories = allDirectories
                        .Where(x =>
                            x.PathSegments.Count >= normalizedPath.Count
                            && x.PathSegments.Take(normalizedPath.Count)
                                .SequenceEqual(normalizedPath)
                        )
                        .ToList();

                    return filteredDirectories
                        .Select(x => x.PathSegments.ToArray())
                        .OrderBy(x => x.Length)
                        .ThenBy(x => string.Join("/", x))
                        .ToList();
                }

                // 没有指定路径，返回所有目录
                var directories = await repository
                    .SearchFor(filter)
                    .ToListAsync(cancellationToken: ct);

                return directories
                    .Select(x => x.PathSegments.ToArray())
                    .OrderBy(x => x.Length)
                    .ThenBy(x => string.Join("/", x))
                    .ToList();
            },
            cancellationToken: cancellationToken
        );
    }

    public async Task<bool> SaveDescriptionAsync(
        string[]? path,
        string name,
        string? description,
        CancellationToken cancellationToken = default
    )
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            return false;
        }

        var segments = NormalizeSegments(path).ToList();
        segments.Add(name);
        var filter = Builders<CodeFileSystemEntry>.Filter.Eq(x => x.PathSegments, segments);
        var entry = await repository.SearchFor(filter).FirstOrDefaultAsync(cancellationToken);
        if (entry == null)
        {
            return false;
        }

        entry.Description = description;
        entry.LastUpdateTime = DateTime.Now;
        await repository.UpdateAsync(entry, cancellationToken);
        await InvalidateEntryCachesAsync(entry);
        await InvalidateSearchCacheAsync(name);
        return true;
    }

    public async Task SaveAiAnalyzeResultAsync(
        string[]? path,
        string name,
        string analyzeResult,
        string? analyzedHash = null,
        CancellationToken cancellationToken = default
    )
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            return;
        }

        var segments = NormalizeSegments(path).ToList();
        segments.Add(name);
        var filter = Builders<CodeFileSystemEntry>.Filter.Eq(x => x.PathSegments, segments);
        var entry = await repository.SearchFor(filter).FirstOrDefaultAsync(cancellationToken);
        if (entry == null)
        {
            return;
        }

        entry.AiAnalyzeResult = analyzeResult;
        entry.AiAnalyzeHash = analyzedHash ?? entry.Hash;
        entry.AiAnalyzeTime = DateTime.Now;
        entry.LastUpdateTime = DateTime.Now;
        await repository.UpdateAsync(entry, cancellationToken);
        await InvalidateEntryCachesAsync(entry);
        await InvalidateSearchCacheAsync(name);
    }

    public async Task<bool> ShouldAnalyzeAsync(
        string[]? path,
        string? name,
        CodeContainer? codeContainer,
        CancellationToken cancellationToken = default
    )
    {
        var useAiAnalyze = configuration.GetValue("CodeUseAIAnalyze", false);
        if (!useAiAnalyze)
        {
            return false;
        }

        if (
            string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(codeContainer?.CodeContent)
        )
        {
            return false;
        }

        // 检查代码行数，少于50行不分析
        var lineCount = codeContainer
            .CodeContent.Split(["\r\n", "\r", "\n"], StringSplitOptions.None)
            .Length;
        if (lineCount < 50)
        {
            return false;
        }

        if (name.Contains(".min"))
        {
            return false;
        }

        var language = codeContainer.Language?.ToLowerInvariant();
        var isSupportedLanguage = language is "csharp" or "javascript" or "typescript";
        if (!isSupportedLanguage)
        {
            return false;
        }

        var segments = NormalizeSegments(path).ToList();
        var filter = Builders<CodeFileSystemEntry>.Filter.Eq(x => x.PathSegments, segments);
        var entry = await repository.SearchFor(filter).FirstOrDefaultAsync(cancellationToken);
        if (entry == null)
        {
            return false;
        }

        if (string.IsNullOrWhiteSpace(entry.AiAnalyzeResult))
        {
            return true;
        }

        if (!string.Equals(entry.AiAnalyzeHash, entry.Hash, StringComparison.OrdinalIgnoreCase))
        {
            return true;
        }

        return false;
    }

    private async Task InvalidateEntryCachesAsync(CodeFileSystemEntry entry)
    {
        var entryKey = BuildPathKey(entry.PathSegments);
        await fusionCache.RemoveAsync(BuildCacheKey(nameof(FindByPathAsync), "Path=" + entryKey));

        var parentKey = BuildPathKey(entry.ParentPathSegments);
        await fusionCache.RemoveAsync(
            BuildCacheKey(nameof(GetChildrenAsync), "Parent=" + parentKey)
        );
    }

    private async Task<CodeFileSystemEntryResponse?> FindByPathCoreAsync(
        List<string> segments,
        CancellationToken cancellationToken
    )
    {
        // 先尝试精确匹配（区分大小写）
        var filter = Builders<CodeFileSystemEntry>.Filter.Eq(x => x.PathSegments, segments);
        var entry = await repository.SearchFor(filter).FirstOrDefaultAsync(cancellationToken);

        if (entry == null && segments.Count > 0)
        {
            // 如果精确匹配失败，则构建不区分大小写的正则过滤器
            var regexes = segments
                .Select(x => new BsonRegularExpression($"^{Regex.Escape(x)}$", "i"))
                .ToArray();
            var caseInsensitiveFilter = new BsonDocumentFilterDefinition<CodeFileSystemEntry>(
                new BsonDocument
                {
                    {
                        nameof(CodeFileSystemEntry.PathSegments),
                        new BsonDocument
                        {
                            { "$size", segments.Count },
                            { "$all", new BsonArray(regexes) },
                        }
                    },
                }
            );

#if DEBUG
            var serializerRegistry = BsonSerializer.SerializerRegistry;
            var documentSerializer = serializerRegistry.GetSerializer<CodeFileSystemEntry>();
            var serializerArgs = new RenderArgs<CodeFileSystemEntry>(
                documentSerializer,
                serializerRegistry
            );
            var bsonDocumentQuery = caseInsensitiveFilter.Render(serializerArgs);
            logger.LogInformation(
                "构建查询条件: {BsonDocumentQuery}",
                bsonDocumentQuery.ToString()
            );
#endif
            entry = await repository
                .SearchFor(caseInsensitiveFilter)
                .FirstOrDefaultAsync(cancellationToken);
        }

        if (entry == null)
        {
            return null;
        }

        if (!entry.IsDirectory)
        {
            entry = await FixPreviewContentAsync(entry, cancellationToken);
        }

        var readmeContent = entry.IsDirectory
            ? await ResolveReadmeContentAsync(entry.PathSegments, cancellationToken)
            : null;
        return MapToResponse(entry, readmeContent);
    }

    private async Task InvalidateSearchCacheAsync(string name)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            return;
        }

        await fusionCache.RemoveAsync(BuildCacheKey(nameof(SearchAsync), "Keyword=" + name));
    }

    private async Task<T> GetOrSetCacheAsync<T>(
        string methodName,
        string parameters,
        Func<CancellationToken, Task<T>> factory,
        CancellationToken cancellationToken = default
    )
    {
        return await fusionCache.GetOrSetAsync<T>(
            BuildCacheKey(methodName, parameters),
            async (context, factoryCancellationToken) =>
            {
                context.Tags =
                [
                    GeneratedCodeFileSystemEntryServiceCacheMetadata.DefaultPrefix,
                    GeneratedCodeFileSystemEntryServiceCacheMetadata.GetMethodTag(methodName),
                ];
                return await factory(factoryCancellationToken);
            },
            options =>
                options
                    .SetDuration(CacheDefaultExpiration)
                    .SetFailSafe(true, CacheDefaultExpiration),
            token: cancellationToken
        );
    }

    private static string BuildCacheKey(string methodName, string parameters)
    {
        return string.Concat(
            GeneratedCodeFileSystemEntryServiceCacheMetadata.DefaultPrefix,
            ":",
            methodName,
            ":",
            parameters
        );
    }

    private static List<string> NormalizeSegments(IReadOnlyCollection<string>? segments)
    {
        return segments?.Where(x => !string.IsNullOrWhiteSpace(x)).ToList() ?? [];
    }

    private CodeFileSystemEntryResponse MapToResponse(
        CodeFileSystemEntry entry,
        string? readmeContent
    )
    {
        return new CodeFileSystemEntryResponse
        {
            Id = entry.Id.ToString(),
            PathSegments = entry.PathSegments.ToList(),
            Name = entry.Name,
            ParentPathSegments = entry.ParentPathSegments.ToList(),
            IsDirectory = entry.IsDirectory,
            Extension = entry.Extension,
            Size = entry.Size,
            Hash = entry.Hash,
            CodeFileContentType = entry.CodeFileContentType,
            FileContent = entry.FileContent,
            CodeLanguage = ResolveCodeLanguage(entry.IsDirectory, entry.Extension, entry.Name),
            Tags = entry.Tags.ToList(),
            CreatedTime = entry.CreatedTime,
            LastWriteTime = entry.LastWriteTime,
            LastUpdateTime = entry.LastUpdateTime,
            Description = entry.Description,
            AiAnalyzeResult = entry.AiAnalyzeResult,
            AiAnalyzeTime = entry.AiAnalyzeTime,
            AiAnalyzeHash = entry.AiAnalyzeHash,
            ReadmeContent = readmeContent,
        };
    }

    private async Task<List<CodeFileSystemEntryResponse>> MapToResponseListAsync(
        List<CodeFileSystemEntry> entries,
        CancellationToken cancellationToken
    )
    {
        if (entries.Count == 0)
        {
            return [];
        }

        var directories = entries.Where(x => x.IsDirectory).ToList();
        var readmeMap = await ResolveReadmeContentMapAsync(directories, cancellationToken);

        return entries
            .Select(entry =>
            {
                string? readmeContent = null;
                if (
                    entry.IsDirectory
                    && readmeMap.TryGetValue(BuildPathKey(entry.PathSegments), out var content)
                )
                {
                    readmeContent = content;
                }

                return MapToResponse(entry, readmeContent);
            })
            .ToList();
    }

    /// <summary>
    /// 解析文件语言，目录不参与语言识别。
    /// </summary>
    /// <param name="isDirectory">是否为目录。</param>
    /// <param name="extension">文件扩展名。</param>
    /// <param name="name">文件名。</param>
    /// <returns>配置中的语言标识，目录或未配置时返回 null。</returns>
    private string? ResolveCodeLanguage(bool isDirectory, string? extension, string? name)
    {
        if (isDirectory)
        {
            return null;
        }

        return ResolveCodeLanguage(_codeViewCfg.Value, extension, name);
    }

    /// <summary>
    /// 按配置解析文件语言；未配置的扩展名或文件名不支持预览。
    /// </summary>
    /// <param name="codeView">代码查看配置。</param>
    /// <param name="extension">文件扩展名。</param>
    /// <param name="name">文件名。</param>
    /// <returns>配置中的语言标识，未匹配则返回 null。</returns>
    private static string? ResolveCodeLanguage(
        CodeViewOption codeView,
        string? extension,
        string? name
    )
    {
        foreach (var key in GetLanguageLookupKeys(extension, name))
        {
            if (
                TryGetConfiguredLanguage(
                    codeView.ExtensionToLanguage,
                    key,
                    out var configuredLanguage
                )
            )
            {
                return configuredLanguage;
            }
        }

        return null;
    }

    /// <summary>
    /// 从配置中查找语言映射，扩展名和文件名匹配忽略大小写。
    /// </summary>
    /// <param name="extensionToLanguage">扩展名和语言映射配置。</param>
    /// <param name="key">待匹配的扩展名或文件名。</param>
    /// <param name="language">匹配到的语言标识。</param>
    /// <returns>是否匹配到配置。</returns>
    private static bool TryGetConfiguredLanguage(
        Dictionary<string, string>? extensionToLanguage,
        string key,
        out string? language
    )
    {
        language = null;
        if (extensionToLanguage == null)
        {
            return false;
        }

        if (extensionToLanguage.TryGetValue(key, out var exactLanguage))
        {
            language = exactLanguage;
            return true;
        }

        var matched = extensionToLanguage.FirstOrDefault(x =>
            string.Equals(x.Key, key, StringComparison.OrdinalIgnoreCase)
        );
        if (matched.Key == null)
        {
            return false;
        }

        language = matched.Value;
        return true;
    }

    /// <summary>
    /// 生成配置查找键，兼容扩展名和无扩展名的特殊文件名配置。
    /// </summary>
    /// <param name="extension">文件扩展名。</param>
    /// <param name="name">文件名。</param>
    /// <returns>用于匹配 ExtensionToLanguage 的候选键。</returns>
    private static IEnumerable<string> GetLanguageLookupKeys(string? extension, string? name)
    {
        var primary = string.IsNullOrWhiteSpace(extension) ? name : extension;
        foreach (var key in ExpandLanguageLookupKey(primary))
        {
            yield return key;
        }

        if (
            !string.IsNullOrWhiteSpace(name)
            && !string.Equals(name, primary, StringComparison.OrdinalIgnoreCase)
        )
        {
            foreach (var key in ExpandLanguageLookupKey(name))
            {
                yield return key;
            }
        }
    }

    /// <summary>
    /// 生成带点和不带点两种形式的配置键。
    /// </summary>
    /// <param name="value">扩展名或文件名。</param>
    /// <returns>规范化后的候选键。</returns>
    private static IEnumerable<string> ExpandLanguageLookupKey(string? value)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            yield break;
        }

        var normalized = value.Trim().ToLowerInvariant();
        yield return normalized;

        if (normalized.StartsWith('.'))
        {
            yield return normalized.TrimStart('.');
        }
        else
        {
            yield return "." + normalized;
        }
    }

    /// <summary>
    /// 自愈可预览文件的历史记录内容。
    /// </summary>
    /// <param name="entry">数据库中的文件系统项。</param>
    /// <param name="cancellationToken">取消令牌。</param>
    /// <returns>补齐内容后的文件系统项。</returns>
    private async Task<CodeFileSystemEntry> FixPreviewContentAsync(
        CodeFileSystemEntry entry,
        CancellationToken cancellationToken
    )
    {
        var codeView = _codeViewCfg.Value;
        var shouldPreview = ResolveCodeLanguage(codeView, entry.Extension, entry.Name) != null;
        if (!shouldPreview)
        {
            return entry;
        }

        if (entry.CodeFileContentType == CodeFileContentType.Text && entry.FileContent != null)
        {
            return entry;
        }

        var fileInfo = ResolveSourceFileInfo(codeView, entry.PathSegments);
        if (fileInfo is not { Exists: true })
        {
            return entry;
        }

        entry.CodeFileContentType = CodeFileContentType.Text;
        entry.FileContent = await ReadTextContentAsync(fileInfo, cancellationToken) ?? "";
        entry.LastUpdateTime = DateTime.Now;
        await repository.UpdateAsync(entry, cancellationToken);
        return entry;
    }

    /// <summary>
    /// 根据路径分段解析源代码目录下的物理文件。
    /// </summary>
    /// <param name="codeView">代码查看配置。</param>
    /// <param name="pathSegments">相对源码根目录的路径分段。</param>
    /// <returns>位于源码根目录下的文件信息；路径越界时返回 null。</returns>
    private static FileInfo? ResolveSourceFileInfo(
        CodeViewOption codeView,
        IReadOnlyCollection<string> pathSegments
    )
    {
        if (
            string.IsNullOrWhiteSpace(codeView.SourceCodeRoot)
            || !Directory.Exists(codeView.SourceCodeRoot)
        )
        {
            throw new InvalidConfigurationException("CodeView.SourceCodeRoot 配置无效");
        }

        var sourceRoot = Path.GetFullPath(codeView.SourceCodeRoot);
        var fullPath = pathSegments.Aggregate(sourceRoot, Path.Combine);
        var normalizedFullPath = Path.GetFullPath(fullPath);
        var rootWithSeparator =
            sourceRoot.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
            + Path.DirectorySeparatorChar;

        if (
            !string.Equals(normalizedFullPath, sourceRoot, StringComparison.OrdinalIgnoreCase)
            && !normalizedFullPath.StartsWith(rootWithSeparator, StringComparison.OrdinalIgnoreCase)
        )
        {
            return null;
        }

        return new FileInfo(normalizedFullPath);
    }

    private async Task<Dictionary<string, string?>> ResolveReadmeContentMapAsync(
        List<CodeFileSystemEntry> directories,
        CancellationToken cancellationToken
    )
    {
        if (directories.Count == 0)
        {
            return new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);
        }

        var parentSegmentsList = directories.Select(x => x.PathSegments).ToList();
        var filter = Builders<CodeFileSystemEntry>.Filter.And(
            Builders<CodeFileSystemEntry>.Filter.In(x => x.ParentPathSegments, parentSegmentsList),
            Builders<CodeFileSystemEntry>.Filter.Regex(
                x => x.Name,
                new BsonRegularExpression("^readme\\.md$", "i")
            )
        );

        var readmes = await repository.SearchFor(filter).ToListAsync(cancellationToken);
        return readmes.ToDictionary(
            x => BuildPathKey(x.ParentPathSegments),
            x => x.FileContent,
            StringComparer.OrdinalIgnoreCase
        );
    }

    private async Task<string?> ResolveReadmeContentAsync(
        List<string> parentPathSegments,
        CancellationToken cancellationToken
    )
    {
        var filter = Builders<CodeFileSystemEntry>.Filter.And(
            Builders<CodeFileSystemEntry>.Filter.Eq(x => x.ParentPathSegments, parentPathSegments),
            Builders<CodeFileSystemEntry>.Filter.Regex(
                x => x.Name,
                new BsonRegularExpression("^readme\\.md$", "i")
            )
        );

        var readme = await repository.SearchFor(filter).FirstOrDefaultAsync(cancellationToken);
        return readme?.FileContent;
    }

    private static string BuildPathKey(IEnumerable<string> segments)
    {
        return string.Join("/", segments);
    }

    /// <summary>
    /// 读取文本文件内容
    /// </summary>
    private async Task<string?> ReadTextContentAsync(
        FileInfo fileInfo,
        CancellationToken cancellationToken
    )
    {
        try
        {
            using var reader = fileInfo.OpenText();
            return await reader.ReadToEndAsync(cancellationToken);
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "读取文件内容失败: {FilePath}", fileInfo.FullName);
            return null;
        }
    }
}