namespace Dpz.Core.Service.RepositoryServiceImpl;

public class CodeNoteService(
    IRepository<CodeNote> repository,
    IMapper mapper,
    ILogger<CodeNoteService> logger,
    IConfiguration configuration,
    IFusionCache fusionCache
) : ICodeNoteService
{
    public async Task<string> SaveNoteAsync(string[]? path, string name, string? note)
    {
        var codeNote = await BuildFluent(path, name, out var pathStr).FirstOrDefaultAsync();
        if (codeNote == null)
        {
            var entity = new CodeNote
            {
                CreateTime = DateTime.Now,
                LastUpdateTime = DateTime.Now,
                Name = name,
                Note = note,
                Path = pathStr,
            };
            await repository.InsertAsync(entity);
            return entity.Id.ToString();
        }

        codeNote.Note = note;
        codeNote.LastUpdateTime = DateTime.Now;
        await repository.UpdateAsync(codeNote);
        return codeNote.Id.ToString();
    }

    public async Task<VmCodeNote?> FindAsync(string[]? path, string? name)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            return null;
        }
        var codeNote = await BuildFluent(path, name, out _).FirstOrDefaultAsync();

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

        return mapper.Map<VmCodeNote>(codeNote);
    }

    private static string GetPathStr(string[]? path)
    {
        return path is not null && path.Length > 0 ? string.Join("/", path) : "";
    }

    private static FilterDefinition<CodeNote> BuildFilter(
        string[]? path,
        string? name,
        out string pathStr
    )
    {
        pathStr = GetPathStr(path);
        return Builders<CodeNote>.Filter.And(
            Builders<CodeNote>.Filter.Eq(x => x.Path, pathStr),
            Builders<CodeNote>.Filter.Eq(x => x.Name, name)
        );
    }

    private IFindFluent<CodeNote, CodeNote> BuildFluent(
        string[]? path,
        string name,
        out string pathStr
    )
    {
        var filter = BuildFilter(path, name, out pathStr);
        return repository.SearchFor(
            filter,
            new FindOptions
            {
                Collation = new Collation(
                    locale: "en",
                    strength: new Optional<CollationStrength?>(CollationStrength.Secondary)
                ),
            }
        );
    }

    public async Task SaveAiAnalyzeResultAsync(string[]? path, string name, string analyzeResult)
    {
        var codeNote = await BuildFluent(path, name, out var pathStr).FirstOrDefaultAsync();
        if (codeNote == null)
        {
            var entity = new CodeNote
            {
                CreateTime = DateTime.Now,
                LastUpdateTime = DateTime.Now,
                Name = name,
                AiAnalyzeResult = analyzeResult,
                Path = pathStr,
            };
            await repository.InsertAsync(entity);

            await ClearCacheAsync();
            return;
        }

        codeNote.AiAnalyzeResult = analyzeResult;
        codeNote.LastUpdateTime = DateTime.Now;
        await repository.UpdateAsync(codeNote);

        await ClearCacheAsync();
        return;

        async Task ClearCacheAsync()
        {
            var codeView =
                configuration.GetSection("CodeView").Get<CodeViewOption>()
                ?? throw new InvalidConfigurationException("CodeView");
            var cachePath = new List<string>();
            cachePath.AddRange(path ?? []);
            cachePath.Add(name);
            var removeCacheKey = CacheKey.CodeViewKey(cachePath.ToArray(), codeView.ToString());
            await fusionCache.RemoveAsync(removeCacheKey);
        }
    }

    public async Task<List<VmCodeNote>> GetNoteAsync(string[]? path)
    {
#if DEBUG
        var stopwatch = new Stopwatch();
        stopwatch.Start();
#endif
        var pathStr = GetPathStr(path);
        var filter = Builders<CodeNote>.Filter.Eq(x => x.Path, pathStr);
        var list = await repository
            .SearchFor(
                filter,
                new FindOptions
                {
                    Collation = new Collation(
                        locale: "en",
                        strength: new Optional<CollationStrength?>(CollationStrength.Secondary)
                    ),
                }
            )
            .ToListAsync();
#if DEBUG
        stopwatch.Stop();
        var queryTime = stopwatch.Elapsed;
        logger.LogInformation("查询耗时：{QueryTime} ms", queryTime.TotalMilliseconds);
#endif
        return mapper.Map<List<VmCodeNote>>(list);
    }

    public async Task<List<VmCodeNote>> GetAllNoteAsync()
    {
        var list = await repository.SearchFor(x => true).ToListAsync();
        return mapper.Map<List<VmCodeNote>>(list);
    }

    public async Task DeleteAsync(string[]? path, string name)
    {
        var filter = BuildFilter(path, name, out _);
        await repository.DeleteAsync(filter);
    }
}