using System.Text.RegularExpressions;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class BookmarkService(IRepository<Bookmark> repository, IMapper mapper) : IBookmarkService
{
    [Cache(ExpirationSeconds = 30 * ExpirationTime.Day)]
    public async Task<List<VmBookmark>> GetBookmarksAsync(string? title, string[]? categories)
    {
        var empty = Builders<Bookmark>.Filter.Empty;
        var titleFilter = string.IsNullOrEmpty(title)
            ? empty
            : Builders<Bookmark>.Filter.Regex(x => x.Title, new BsonRegularExpression(title, "i"));
        var categoryFilter =
            categories?.Any() == true
                ? Builders<Bookmark>.Filter.All(x => x.Categories, categories)
                : empty;
        var source = await repository
            .SearchFor(Builders<Bookmark>.Filter.And(titleFilter, categoryFilter))
            .ToListAsync();
        return mapper.Map<List<VmBookmark>>(source);
    }

    [Cache(ExpirationSeconds = 30 * ExpirationTime.Day)]
    public async Task<List<string>> SearchAsync(
        string? title = null,
        IReadOnlyCollection<string>? categories = null
    )
    {
        if (string.IsNullOrEmpty(title))
        {
            return [];
        }

        var empty = Builders<Bookmark>.Filter.Empty;
        var regexTitle = Regex.Escape(title);
        var titleFilter = Builders<Bookmark>.Filter.Regex(
            x => x.Title,
            new BsonRegularExpression(regexTitle, "i")
        );
        var categoryFilter = categories is { Count: > 0 }
            ? Builders<Bookmark>.Filter.All(x => x.Categories, categories)
            : empty;

        return await repository
            .SearchFor(Builders<Bookmark>.Filter.And(titleFilter, categoryFilter))
            .Limit(10)
            .Project(x => x.Title)
            .ToListAsync();
    }

    [Cache(ExpirationSeconds = 30 * ExpirationTime.Day)]
    public async Task<VmBookmark?> GetBookmarkAsync(string id)
    {
        var entity = await repository.TryGetAsync(id);
        return entity == null ? null : mapper.Map<VmBookmark>(entity);
    }

    [Cache(ExpirationSeconds = 30 * ExpirationTime.Day)]
    public async Task<List<string>> GetCategoriesAsync()
    {
        return await repository
            .MongodbQueryable.SelectMany(x => x.Categories)
            .GroupBy(x => x)
            .Select(x => x.Key)
            .OrderByDescending(x => x)
            .ToListAsync();
    }

    [InvalidateCache(
        Methods = [
            nameof(GetBookmarksAsync),
            nameof(SearchAsync),
            nameof(GetBookmarkAsync),
            nameof(GetCategoriesAsync),
        ]
    )]
    public async Task CreateBookmarkAsync(VmCreateBookmark bookmark)
    {
        var entity = mapper.Map<Bookmark>(bookmark);
        if (bookmark.UploadIcon != null && !string.IsNullOrEmpty(entity.Icon))
        {
            var iconUrl = await bookmark.UploadIcon(entity.Icon);
            if (!string.IsNullOrEmpty(iconUrl))
            {
                entity.Icon = iconUrl;
            }
        }
        if (bookmark.UploadImage != null && !string.IsNullOrEmpty(entity.Image))
        {
            var imageUrl = await bookmark.UploadImage(entity.Image);
            if (!string.IsNullOrEmpty(imageUrl))
            {
                entity.Image = imageUrl;
            }
        }
        await repository.InsertAsync(entity);
    }

    [InvalidateCache(
        Methods = [
            nameof(GetBookmarksAsync),
            nameof(SearchAsync),
            nameof(GetBookmarkAsync),
            nameof(GetCategoriesAsync),
        ]
    )]
    public async Task UpdateAsync(VmUpdateBookmark bookmark)
    {
        var entity = await repository.TryGetAsync(bookmark.Id);
        if (entity == null)
        {
            return;
        }

        if (bookmark.Icon != entity.Icon)
        {
            if (!string.IsNullOrEmpty(entity.Icon) && bookmark.DeleteIcon != null)
            {
                await bookmark.DeleteIcon(entity.Icon);
                entity.Icon = null;
            }

            if (!string.IsNullOrEmpty(bookmark.Icon) && bookmark.UploadIcon != null)
            {
                var icon = await bookmark.UploadIcon(bookmark.Icon);
                entity.Icon = icon;
            }
        }

        if (bookmark.Image != entity.Image)
        {
            if (!string.IsNullOrEmpty(entity.Image) && bookmark.DeleteImage != null)
            {
                await bookmark.DeleteImage(entity.Image);
                entity.Image = null;
            }
            if (!string.IsNullOrEmpty(bookmark.Image) && bookmark.UploadImage != null)
            {
                var image = await bookmark.UploadImage(bookmark.Image);
                entity.Image = image;
            }
        }

        entity.Title = bookmark.Title ?? entity.Title;
        entity.Url = bookmark.Url ?? entity.Url;
        entity.Categories = bookmark.Categories;

        await repository.UpdateAsync(entity);
    }

    [InvalidateCache(
        Methods = [
            nameof(GetBookmarksAsync),
            nameof(SearchAsync),
            nameof(GetBookmarkAsync),
            nameof(GetCategoriesAsync),
        ]
    )]
    public async Task DeleteAsync(string id, Func<VmBookmark, Task> deleteSource)
    {
        var entity = await repository.TryGetAsync(id);
        if (entity == null)
        {
            return;
        }
        await deleteSource(mapper.Map<VmBookmark>(entity));
        await repository.DeleteAsync(entity.Id);
    }
}