using ChatBot.Models.Dto;
using FluentAssertions;
using OllamaSharp.Models.Chat;

namespace ChatBot.Tests.Models;

public class ChatMessageTests
{
    [Fact]
    public void Constructor_WithRequiredProperties_ShouldInitializeCorrectly()
    {
        // Arrange
        var content = "Hello, world!";
        var role = ChatRole.User;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }

    [Fact]
    public void Content_ShouldBeSettable()
    {
        // Arrange
        var message = new ChatMessage { Content = "Initial content", Role = ChatRole.User };
        var newContent = "Updated content";

        // Act
        message.Content = newContent;

        // Assert
        message.Content.Should().Be(newContent);
    }

    [Fact]
    public void Role_ShouldBeSettable()
    {
        // Arrange
        var message = new ChatMessage { Content = "Test content", Role = ChatRole.User };
        var newRole = ChatRole.Assistant;

        // Act
        message.Role = newRole;

        // Assert
        message.Role.Should().Be(newRole);
    }

    [Theory]
    [InlineData("")]
    [InlineData("Short message")]
    [InlineData(
        "A very long message that contains a lot of text and should still be valid for the content field"
    )]
    [InlineData("Message with special characters: !@#$%^&*()_+-=[]{}|;':\",./<>?")]
    [InlineData("Message with unicode: Привет мир! 🌍")]
    [InlineData("Message with newlines:\nLine 1\nLine 2")]
    [InlineData("Message with tabs:\tTab content")]
    public void Content_ShouldAcceptVariousValues(string content)
    {
        // Arrange
        var message = new ChatMessage { Content = "Initial", Role = ChatRole.User };

        // Act
        message.Content = content;

        // Assert
        message.Content.Should().Be(content);
    }

    [Fact]
    public void Role_ShouldAcceptSystemRole()
    {
        // Arrange
        var message = new ChatMessage { Content = "Test content", Role = ChatRole.User };

        // Act
        message.Role = ChatRole.System;

        // Assert
        message.Role.Should().Be(ChatRole.System);
    }

    [Fact]
    public void Role_ShouldAcceptUserRole()
    {
        // Arrange
        var message = new ChatMessage { Content = "Test content", Role = ChatRole.System };

        // Act
        message.Role = ChatRole.User;

        // Assert
        message.Role.Should().Be(ChatRole.User);
    }

    [Fact]
    public void Role_ShouldAcceptAssistantRole()
    {
        // Arrange
        var message = new ChatMessage { Content = "Test content", Role = ChatRole.User };

        // Act
        message.Role = ChatRole.Assistant;

        // Assert
        message.Role.Should().Be(ChatRole.Assistant);
    }

    [Fact]
    public void AllProperties_ShouldBeMutable()
    {
        // Arrange
        var message = new ChatMessage { Content = "Initial content", Role = ChatRole.User };

        // Act
        message.Content = "Updated content";
        message.Role = ChatRole.Assistant;

        // Assert
        message.Content.Should().Be("Updated content");
        message.Role.Should().Be(ChatRole.Assistant);
    }

    [Fact]
    public void Message_ShouldSupportSystemRole()
    {
        // Arrange
        var content = "You are a helpful assistant.";
        var role = ChatRole.System;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(ChatRole.System);
    }

    [Fact]
    public void Message_ShouldSupportUserRole()
    {
        // Arrange
        var content = "Hello, how are you?";
        var role = ChatRole.User;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(ChatRole.User);
    }

    [Fact]
    public void Message_ShouldSupportAssistantRole()
    {
        // Arrange
        var content = "I'm doing well, thank you!";
        var role = ChatRole.Assistant;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(ChatRole.Assistant);
    }

    [Fact]
    public void Message_WithEmptyContent_ShouldBeValid()
    {
        // Arrange
        var content = "";
        var role = ChatRole.User;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }

    [Fact]
    public void Message_WithWhitespaceContent_ShouldBeValid()
    {
        // Arrange
        var content = "   \t\n   ";
        var role = ChatRole.User;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }

    [Fact]
    public void Message_WithVeryLongContent_ShouldBeValid()
    {
        // Arrange
        var content = new string('A', 10000); // 10,000 characters
        var role = ChatRole.Assistant;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
        message.Content.Length.Should().Be(10000);
    }

    [Fact]
    public void Message_WithJsonContent_ShouldBeValid()
    {
        // Arrange
        var content = """{"key": "value", "number": 123, "array": [1, 2, 3]}""";
        var role = ChatRole.Assistant;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }

    [Fact]
    public void Message_WithXmlContent_ShouldBeValid()
    {
        // Arrange
        var content = "<root><item>value</item></root>";
        var role = ChatRole.Assistant;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }

    [Fact]
    public void Message_WithMarkdownContent_ShouldBeValid()
    {
        // Arrange
        var content = "# Header\n\n**Bold text** and *italic text*\n\n- List item 1\n- List item 2";
        var role = ChatRole.Assistant;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }

    [Fact]
    public void Message_WithCodeContent_ShouldBeValid()
    {
        // Arrange
        var content = "```csharp\npublic class Test { }\n```";
        var role = ChatRole.Assistant;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }

    [Fact]
    public void Message_WithDefaultRole_ShouldBeValid()
    {
        // Arrange
        var content = "Test message";

        // Act
        var message = new ChatMessage { Content = content, Role = default(ChatRole) };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(default(ChatRole));
    }

    [Fact]
    public void Message_ShouldBeComparableByContent()
    {
        // Arrange
        var message1 = new ChatMessage { Content = "Same content", Role = ChatRole.User };
        var message2 = new ChatMessage { Content = "Same content", Role = ChatRole.Assistant };

        // Act & Assert
        message1.Content.Should().Be(message2.Content);
        message1.Role.Should().NotBe(message2.Role);
    }

    [Fact]
    public void Message_ShouldBeComparableByRole()
    {
        // Arrange
        var message1 = new ChatMessage { Content = "Different content 1", Role = ChatRole.User };
        var message2 = new ChatMessage { Content = "Different content 2", Role = ChatRole.User };

        // Act & Assert
        message1.Role.Should().Be(message2.Role);
        message1.Content.Should().NotBe(message2.Content);
    }

    [Fact]
    public void Message_ShouldSupportAllRoleTypes()
    {
        // Arrange & Act
        var systemMessage = new ChatMessage { Content = "System message", Role = ChatRole.System };
        var userMessage = new ChatMessage { Content = "User message", Role = ChatRole.User };
        var assistantMessage = new ChatMessage
        {
            Content = "Assistant message",
            Role = ChatRole.Assistant,
        };
        // Assert
        systemMessage.Role.Should().Be(ChatRole.System);
        userMessage.Role.Should().Be(ChatRole.User);
        assistantMessage.Role.Should().Be(ChatRole.Assistant);
    }

    [Fact]
    public void Message_ShouldHandleSpecialCharacters()
    {
        // Arrange
        var content = "Special chars: !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
        var role = ChatRole.User;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }

    [Fact]
    public void Message_ShouldHandleUnicodeCharacters()
    {
        // Arrange
        var content = "Unicode: 中文 العربية русский 日本語 한국어";
        var role = ChatRole.Assistant;

        // Act
        var message = new ChatMessage { Content = content, Role = role };

        // Assert
        message.Content.Should().Be(content);
        message.Role.Should().Be(role);
    }
}