using System.Collections.Concurrent;
using BotFramework;
using BotFramework.Attributes;
using BotFramework.Enums;
using Kruzya.TelegramBot.Core.AutoDelete;
using Kruzya.TelegramBot.Core.Extensions;
using Telegram.Bot;
using Telegram.Bot.Types;
using Telegram.Bot.Types.Enums;
using West.TelegramBot.CodeWatcher.Options;
using West.TelegramBot.CodeWatcher.Service;

namespace West.TelegramBot.CodeWatcher;

public class Handler : BotEventHandler
{
    private readonly ConcurrentBag<DeleteRequest> _requests;
    private readonly CodeWatcherMode _mode;
    private readonly IHasteService _haste;

    public Handler(ConcurrentBag<DeleteRequest> requests, CodeWatcherMode mode, IHasteService haste)
    {
        _requests = requests;
        _mode = mode;
        _haste = haste;
    }

    [InChat(InChat.Public)]
    [Update(UpdateFlag.Message | UpdateFlag.EditedMessage)]
    public async Task HandleMessage()
    {
        var message = RawUpdate.Message ?? RawUpdate.EditedMessage;

        if (message?.Entities == null && message?.CaptionEntities == null)
        {
            return;
        }
        
        var text = message.Caption ?? message.Text;
        if (text == null)
        {
            return;
        }

        if (!await Bot.CanDeleteMessagesAsync(Chat))
        {
            return;
        }

        var entities = new List<MessageEntity>();
        
        if (message.Entities != null)
        {
            entities.AddRange(message.Entities);
        }

        if (message.CaptionEntities != null)
        {
            entities.AddRange(message.CaptionEntities);
        }
        
        foreach (var entity in entities)
        {
            if (entity.Type is MessageEntityType.Code or MessageEntityType.Pre)
            {
                var entityLines = text!
                    .Substring(entity.Offset, entity.Length)
                    .SplitToLines()
                    .ToList();

                if (entityLines.Count < 2)
                {
                    continue;
                }

                if (entityLines.Count >= 20 || entityLines.Any(line => line.Length > 160))
                {
                    await ProcessDetectedCode(message);
                    return;
                }
            }
        }
    }

    public async Task ProcessDetectedCode(Message message)
    {
        switch (await _mode.GetValueAsync(Chat.Id))
        {
            case "disabled":
                return;
            
            case "remove":
                await RemoveDetectedCode(message);
                break;
            
            case "upload":
                await UploadDetectedCode(message);
                break;

        }
    }

    public async Task UploadDetectedCode(Message message)
    {
        var resp = await _haste.PostDocumentAsync(message.Text!);
        await Bot.DeleteMessageAsync(Chat.Id, message.MessageId);
       
        await Bot.SendTextMessageAsync(Chat.Id, 
            $"{message.From?.ToHtml()}, you posted something long and pre-escaped, so I decided to upload it to our paste service for you.\n" +
            $"Here is the link: {_haste.GetHasteUri() + resp.Key}",
            parseMode: ParseMode.Html);
    }

    public async Task RemoveDetectedCode(Message message)
    {
        await Bot.DeleteMessageAsync(Chat.Id, message.MessageId);
        var notifyMsg = await Bot.SendTextMessageAsync(Chat.Id,
            (message.From?.ToHtml() ?? "") + ", не стоит публиковать столь большой код прямо в чат. " +
            "Вместо этого загрузите его на https://pastebin.com и отправьте в виде ссылки.", 
            parseMode: ParseMode.Html);

        // TODO: maybe write a wrapper-service around collection to avoid direct interactions with the collection, West, 07.07.2022, 16:53
        _requests.Add(new DeleteRequest
        {
            ChatId = notifyMsg.Chat.Id,
            MessageId = notifyMsg.MessageId,
            DeleteAt = DateTime.Now.AddSeconds(30)
        });
    }
}