using ChatBot.Services;
using ChatBot.Services.Telegram.Commands;
using ChatBot.Services.Telegram.Interfaces;
using ChatBot.Services.Telegram.Services;
using ChatBot.Tests.TestUtilities;
using FluentAssertions;
using Microsoft.Extensions.Logging;
using Moq;
using Telegram.Bot.Types;

namespace ChatBot.Tests.Telegram.Commands;

public class TelegramCommandProcessorTests : UnitTestBase
{
    private readonly CommandRegistry _commandRegistry;
    private readonly ChatService _chatService;
    private readonly Mock<ILogger<TelegramCommandProcessor>> _loggerMock;
    private readonly BotInfoService _botInfoService;
    private readonly TelegramCommandProcessor _processor;

    public TelegramCommandProcessorTests()
    {
        _commandRegistry = new CommandRegistry(
            TestDataBuilder.Mocks.CreateLoggerMock<CommandRegistry>().Object,
            Enumerable.Empty<ITelegramCommand>()
        );
        _chatService = new ChatService(
            TestDataBuilder.Mocks.CreateLoggerMock<ChatService>().Object,
            TestDataBuilder.Mocks.CreateAIServiceMock().Object,
            TestDataBuilder.Mocks.CreateSessionStorageMock().Object,
            TestDataBuilder
                .Mocks.CreateOptionsMock(TestDataBuilder.Configurations.CreateAISettings())
                .Object,
            TestDataBuilder.Mocks.CreateCompressionServiceMock().Object
        );
        _loggerMock = TestDataBuilder.Mocks.CreateLoggerMock<TelegramCommandProcessor>();
        _botInfoService = new BotInfoService(
            TestDataBuilder.Mocks.CreateTelegramBotClient().Object,
            TestDataBuilder.Mocks.CreateLoggerMock<BotInfoService>().Object
        );

        _processor = new TelegramCommandProcessor(
            _commandRegistry,
            _chatService,
            _loggerMock.Object,
            _botInfoService
        );
    }

    [Fact]
    public void Constructor_ShouldInitializeServices()
    {
        // Arrange & Act
        var processor = new TelegramCommandProcessor(
            _commandRegistry,
            _chatService,
            _loggerMock.Object,
            _botInfoService
        );

        // Assert
        processor.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldProcessAsRegularMessage_WhenNoCommandFound()
    {
        // Arrange
        var messageText = "Hello bot";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
        result.Should().NotBeEmpty();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleEmptyMessage()
    {
        // Arrange
        var messageText = "";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleVeryLongMessage()
    {
        // Arrange
        var messageText = new string('A', 10000);
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleEmptyUsername()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = 12345L;
        var username = "";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleEmptyChatType()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleEmptyChatTitle()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleNegativeChatId()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = -12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleZeroChatId()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = 0L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleVeryLongUsername()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = 12345L;
        var username = new string('A', 1000);
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleSpecialCharactersInMessage()
    {
        // Arrange
        var messageText = "Hello! @#$%^&*()_+-=[]{}|;':\",./<>?";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleUnicodeCharacters()
    {
        // Arrange
        var messageText = "Привет! 🌍 Hello!";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleNullMessage()
    {
        // Arrange
        string messageText = null!;
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleNullUsername()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = 12345L;
        string username = null!;
        var chatType = "private";
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleNullChatType()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = 12345L;
        var username = "testuser";
        string chatType = null!;
        var chatTitle = "Test Chat";

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleNullChatTitle()
    {
        // Arrange
        var messageText = "Hello";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        string chatTitle = null!;

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleCancellationToken()
    {
        // Arrange
        var messageText = "Hello bot";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";
        var cts = new CancellationTokenSource();
        cts.Cancel();

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle,
            cancellationToken: cts.Token
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleReplyInfo()
    {
        // Arrange
        var messageText = "Hello bot";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";
        var replyInfo = new ReplyInfo
        {
            MessageId = 1,
            UserId = 123,
            Username = "testuser",
        };

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle,
            replyInfo
        );

        // Assert
        result.Should().NotBeNull();
    }

    [Fact]
    public async Task ProcessMessageAsync_ShouldHandleNullReplyInfo()
    {
        // Arrange
        var messageText = "Hello bot";
        var chatId = 12345L;
        var username = "testuser";
        var chatType = "private";
        var chatTitle = "Test Chat";
        ReplyInfo? replyInfo = null;

        // Act
        var result = await _processor.ProcessMessageAsync(
            messageText,
            chatId,
            username,
            chatType,
            chatTitle,
            replyInfo
        );

        // Assert
        result.Should().NotBeNull();
    }
}