telegram-bot/modules/Entertainment/Handler/Fun/AbstractAnimationReply.cs

#nullable enable

using System;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BotFramework;
using Kruzya.TelegramBot.Core;
using Kruzya.TelegramBot.Core.Data;
using Kruzya.TelegramBot.Core.Extensions;
using Microsoft.Extensions.Logging;
using Telegram.Bot;
using Telegram.Bot.Types;

namespace West.Entertainment.Handler.Fun;

public abstract class AbstractAnimationReply : BotEventHandler
{
    private readonly CoreContext _db;

    private readonly ILogger _logger;
    private readonly ThreadSafeRandom _rng;

    protected virtual TimeSpan Cooldown => TimeSpan.FromMinutes(_rng.Next(10, 1337));

    protected Message? Message => RawUpdate.Message;

    private User? RepliedUser => Message?.ReplyToMessage?.From;
        
    protected abstract Regex AnimationMatch
    {
        get;
    }
        
    protected AbstractAnimationReply(CoreContext db, ILogger logger, ThreadSafeRandom rng)
    {
        _db = db;
        _logger = logger;
        _rng = rng;
    }
        
    protected abstract string GetAnimationName();
        
    protected virtual bool CanHandle() => true;
        
    protected async Task HandleSetAnimation()
    {
        var animation = Message?.ReplyToMessage?.Animation;
        var isAdmin = await Bot.IsUserAdminAsync(Chat, From);
           
        _logger.LogDebug("IsAdmin: {IsAdmin}. FileId: {FileId}", isAdmin, animation?.FileId);
        if (!isAdmin || animation == null) return;

        var animationFileOption = await GetAnimationFileOption();
        animationFileOption.SetValue(animation.FileId);
        _db.AddOrUpdate(animationFileOption);

        await Bot.SendTextMessageAsync(Chat.Id, "Animation has been set.", replyToMessageId: Message!.ReplyToMessage!.MessageId);
    }

    protected virtual async Task<bool> HandleAnimation()
    {
        var text = Message!.Text!.ToLower();
        if (!AnimationMatch.IsMatch(text.ToLower()) || text.StartsWith("/set") || !CanHandle()) return false;

        var animationFileId = (await GetAnimationFileOption()).GetValue(string.Empty);
        var nextUseOption = await GetNextUseOption();

        _logger.LogDebug("Animation: {Text}, ToLower: {ToLowerText}", 
            Message!.Text, Message!.Text!.ToLower());
        _logger.LogDebug("AnimationFileId: {FileId}", animationFileId);

        if (string.IsNullOrEmpty(animationFileId))
        {
            _logger.LogDebug("AnimationFileId is empty. Ignoring.");
            return false;
        }
            
        var nextUseDt = nextUseOption.GetValue<DateTime>();
        if (nextUseDt > DateTime.Now)
        {
            _logger.LogInformation("{Name} is on cooldown for chat \"{ChatTitle}\". Will be available at {Time}",
                GetAnimationName(), Chat.Title, nextUseDt);

            return false;
        }
            
        await Bot.SendAnimationAsync(Chat.Id, new InputFileId(animationFileId), 
            replyToMessageId: GetMessageIdToReply() ?? Message?.MessageId);

        nextUseOption.SetValue(DateTime.Now + Cooldown);
        _db.AddOrUpdate(nextUseOption);
            
        return true;
    }
        
    private async Task<BotUserValue> GetAnimationFileOption()
    {
        return await _db.UserValues.FindOrCreateOption(Chat.Id, $"{GetAnimationName()}File");
    }

    private async Task<BotUserValue> GetNextUseOption()
    {
        return await _db.UserValues.FindOrCreateOption(Chat.Id, $"{GetAnimationName()}NextUse");
    }
        
    protected virtual int? GetMessageIdToReply() => Message?.MessageId;
}