using Dpz.Core.Public.ViewModel;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class CodeNoteService(
    IRepository<CodeNote> repository,
    IMapper mapper,
    ILogger<CodeNoteService> logger,
    IConfiguration configuration
) : 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);
            return;
        }

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

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

        if (
            codeContainer is not { Language: "csharp" }
            || string.IsNullOrWhiteSpace(codeContainer.CodeContent)
            || string.IsNullOrWhiteSpace(name)
        )
        {
            return false;
        }

        var codeNote = await FindAsync(path, name);
        if (string.IsNullOrWhiteSpace(codeContainer.AiAnalyzeResult))
        {
            return true;
        }

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

        return DateTime.Now - codeNote.LastUpdateTime > TimeSpan.FromDays(30);
    }

    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);
    }
}