using Dpz.Core.Public.Entity.Option;
using Dpz.Core.Public.ViewModel.Option;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class AppOptionService(IRepository<AppOption> repository, IMapper mapper) : IAppOptionService
{
    /// <summary>
    /// 友情链接 Option name
    /// </summary>
    private const string FriendOptionName = "friends";

    /// <summary>
    /// 页脚内容 Option name
    /// </summary>
    private const string FooterContentOptionName = "footer";

    /// <summary>
    /// robots.txt Option name
    /// </summary>
    private const string RobotsOptionName = "robots.txt";

    [Cache(ExpirationSeconds = 30 * ExpirationTime.Day)]
    public async Task<IList<VmFriends>> GetFriendsAsync()
    {
        var friends = await repository
            .SearchFor(x => x.OptionName == FriendOptionName)
            .ToListAsync();
        if (friends == null || friends.Count == 0)
        {
            return [];
        }

        var list = friends.Cast<Friends>().ToList();
        return mapper.Map<List<VmFriends>>(list);
    }

    [InvalidateCache(Methods = [nameof(GetFriendsAsync)])]
    public async Task AddFriendAsync(VmFriends friend)
    {
        var entity = mapper.Map<Friends>(friend);
        entity.CreateTime = DateTime.Now;
        entity.LastUpdateTime = DateTime.Now;
        entity.OptionName = FriendOptionName;
        await repository.InsertAsync(entity);
    }

    [InvalidateCache(Methods = [nameof(GetFriendsAsync)])]
    public async Task EditFriendAsync(VmFriends? friend)
    {
        if (string.IsNullOrEmpty(friend?.Id) || !ObjectId.TryParse(friend.Id, out var oid))
        {
            return;
        }

        var entity = await repository.FindAsync(oid);
        if (entity == null || entity is not Friends entityFriend)
        {
            return;
        }

        entityFriend.Avatar = friend.Avatar;
        entityFriend.Description = friend.Description;
        entityFriend.Link = friend.Link;
        entityFriend.Name = friend.Name;
        entityFriend.LastUpdateTime = DateTime.Now;
        await repository.UpdateAsync(entityFriend);
    }

    public async Task<VmAppOption?> FindAsync(string id)
    {
        var entity = await repository.TryGetAsync(id);
        if (entity == null)
        {
            return null;
        }

        return mapper.Map<VmAppOption>(entity);
    }

    [InvalidateCache(Methods = [nameof(GetFooterContentAsync)])]
    public async Task SaveFooterContentAsync(string content)
    {
        var footer = await repository
            .SearchFor(x => x.OptionName == FooterContentOptionName)
            .FirstOrDefaultAsync();
        if (footer != null)
        {
            var set = new BsonDocument
            {
                {
                    "$set",
                    new BsonDocument
                    {
                        { nameof(FooterContent.Content), new BsonString(content) },
                        { nameof(FooterContent.LastUpdateTime), new BsonDateTime(DateTime.Now) },
                    }
                },
            };
            UpdateDefinition<AppOption> update = new BsonDocumentUpdateDefinition<AppOption>(set);
            await repository.UpdateAsync(x => x.Id == footer.Id, update);
            return;
        }

        var entity = new FooterContent
        {
            Content = content,
            CreateTime = DateTime.Now,
            LastUpdateTime = DateTime.Now,
            OptionName = FooterContentOptionName,
        };
        await repository.InsertAsync(entity);
    }

    [Cache(ExpirationSeconds = 30 * ExpirationTime.Day)]
    public async Task<string> GetFooterContentAsync()
    {
        var footer = await repository
            .SearchFor(x => x.OptionName == FooterContentOptionName)
            .FirstOrDefaultAsync();
        return footer is FooterContent entity ? entity.Content ?? "" : "";
    }

    [Cache(ExpirationSeconds = 30 * ExpirationTime.Day)]
    public async Task<string> GetRobotsAsync()
    {
        var robots = await repository
            .SearchFor(x => x.OptionName == RobotsOptionName)
            .SingleOrDefaultAsync();
        return robots is RobotsOption entity ? entity.Content : "";
    }

    [InvalidateCache(Methods = [nameof(GetRobotsAsync)])]
    public async Task SaveRobotsAsync(string content)
    {
        var robots = await repository
            .SearchFor(x => x.OptionName == RobotsOptionName)
            .FirstOrDefaultAsync();
        if (robots != null)
        {
            var set = new BsonDocument
            {
                {
                    "$set",
                    new BsonDocument
                    {
                        { nameof(RobotsOption.Content), new BsonString(content) },
                        { nameof(RobotsOption.LastUpdateTime), new BsonDateTime(DateTime.Now) },
                    }
                },
            };
            UpdateDefinition<AppOption> update = new BsonDocumentUpdateDefinition<AppOption>(set);
            await repository.UpdateAsync(x => x.Id == robots.Id, update);
            return;
        }

        var entity = new RobotsOption
        {
            Content = content,
            CreateTime = DateTime.Now,
            LastUpdateTime = DateTime.Now,
            OptionName = RobotsOptionName,
        };
        await repository.InsertAsync(entity);
    }

    [InvalidateCache(Methods = [nameof(GetFriendsAsync)])]
    public async Task DeleteFriendAsync(string id)
    {
        if (ObjectId.TryParse(id, out var oid))
        {
            await repository.DeleteAsync(x => x.OptionName == FriendOptionName && x.Id == oid);
        }
    }
}