"""Tests for AstrBotMessage and MessageMember classes."""

import time
from unittest.mock import patch

from astrbot.core.message.components import Image, Plain
from astrbot.core.platform.astrbot_message import AstrBotMessage, Group, MessageMember
from astrbot.core.platform.message_type import MessageType


class TestMessageMember:
    """Tests for MessageMember dataclass."""

    def test_message_member_creation_basic(self):
        """Test creating a MessageMember with required fields."""
        member = MessageMember(user_id="user123")

        assert member.user_id == "user123"
        assert member.nickname is None

    def test_message_member_creation_with_nickname(self):
        """Test creating a MessageMember with nickname."""
        member = MessageMember(user_id="user123", nickname="TestUser")

        assert member.user_id == "user123"
        assert member.nickname == "TestUser"

    def test_message_member_str_with_nickname(self):
        """Test __str__ method with nickname."""
        member = MessageMember(user_id="user123", nickname="TestUser")
        result = str(member)

        assert "User ID: user123" in result
        assert "Nickname: TestUser" in result

    def test_message_member_str_without_nickname(self):
        """Test __str__ method without nickname."""
        member = MessageMember(user_id="user123")
        result = str(member)

        assert "User ID: user123" in result
        assert "Nickname: N/A" in result


class TestGroup:
    """Tests for Group dataclass."""

    def test_group_creation_basic(self):
        """Test creating a Group with required fields."""
        group = Group(group_id="group123")

        assert group.group_id == "group123"
        assert group.group_name is None
        assert group.group_avatar is None
        assert group.group_owner is None
        assert group.group_admins is None
        assert group.members is None

    def test_group_creation_with_all_fields(self):
        """Test creating a Group with all fields."""
        members = [MessageMember(user_id="user1"), MessageMember(user_id="user2")]
        group = Group(
            group_id="group123",
            group_name="Test Group",
            group_avatar="http://example.com/avatar.jpg",
            group_owner="owner123",
            group_admins=["admin1", "admin2"],
            members=members,
        )

        assert group.group_id == "group123"
        assert group.group_name == "Test Group"
        assert group.group_avatar == "http://example.com/avatar.jpg"
        assert group.group_owner == "owner123"
        assert group.group_admins == ["admin1", "admin2"]
        assert group.members == members

    def test_group_str_with_all_fields(self):
        """Test __str__ method with all fields."""
        members = [MessageMember(user_id="user1", nickname="User One")]
        group = Group(
            group_id="group123",
            group_name="Test Group",
            group_avatar="http://example.com/avatar.jpg",
            group_owner="owner123",
            group_admins=["admin1"],
            members=members,
        )
        result = str(group)

        assert "Group ID: group123" in result
        assert "Name: Test Group" in result
        assert "Avatar: http://example.com/avatar.jpg" in result
        assert "Owner ID: owner123" in result
        assert "Admin IDs: ['admin1']" in result
        assert "Members Len: 1" in result

    def test_group_str_with_minimal_fields(self):
        """Test __str__ method with minimal fields."""
        group = Group(group_id="group123")
        result = str(group)

        assert "Group ID: group123" in result
        assert "Name: N/A" in result
        assert "Avatar: N/A" in result
        assert "Owner ID: N/A" in result
        assert "Admin IDs: N/A" in result
        assert "Members Len: 0" in result
        assert "First Member: N/A" in result


class TestAstrBotMessage:
    """Tests for AstrBotMessage class."""

    def test_astrbot_message_creation(self):
        """Test creating an AstrBotMessage."""
        message = AstrBotMessage()

        assert message.group is None
        assert message.timestamp is not None
        assert isinstance(message.timestamp, int)

    def test_astrbot_message_timestamp(self):
        """Test timestamp is set on creation."""
        with patch.object(time, "time", return_value=1234567890):
            message = AstrBotMessage()
            assert message.timestamp == 1234567890

    def test_astrbot_message_all_attributes(self):
        """Test setting all attributes on AstrBotMessage."""
        message = AstrBotMessage()
        message.type = MessageType.FRIEND_MESSAGE
        message.self_id = "bot123"
        message.session_id = "session123"
        message.message_id = "msg123"
        message.sender = MessageMember(user_id="user123", nickname="TestUser")
        message.message = [Plain(text="Hello")]
        message.message_str = "Hello"
        message.raw_message = {"raw": "data"}

        assert message.type == MessageType.FRIEND_MESSAGE
        assert message.self_id == "bot123"
        assert message.session_id == "session123"
        assert message.message_id == "msg123"
        assert message.sender.user_id == "user123"
        assert len(message.message) == 1
        assert message.message_str == "Hello"
        assert message.raw_message == {"raw": "data"}

    def test_astrbot_message_str(self):
        """Test __str__ method."""
        message = AstrBotMessage()
        message.type = MessageType.FRIEND_MESSAGE
        message.self_id = "bot123"

        result = str(message)
        assert "'type'" in result
        assert "'self_id'" in result


class TestAstrBotMessageGroupId:
    """Tests for AstrBotMessage group_id property."""

    def test_group_id_returns_empty_when_no_group(self):
        """Test group_id returns empty string when group is None."""
        message = AstrBotMessage()
        assert message.group_id == ""

    def test_group_id_returns_group_id_when_group_exists(self):
        """Test group_id returns the group's id when group exists."""
        message = AstrBotMessage()
        message.group = Group(group_id="group123")

        assert message.group_id == "group123"

    def test_group_id_setter_creates_new_group(self):
        """Test group_id setter creates a new group if none exists."""
        message = AstrBotMessage()
        message.group_id = "new_group123"

        assert message.group is not None
        assert message.group.group_id == "new_group123"

    def test_group_id_setter_updates_existing_group(self):
        """Test group_id setter updates existing group's id."""
        message = AstrBotMessage()
        message.group = Group(group_id="old_group")
        message.group_id = "new_group"

        assert message.group.group_id == "new_group"

    def test_group_id_setter_with_none_removes_group(self):
        """Test group_id setter with None removes the group."""
        message = AstrBotMessage()
        message.group = Group(group_id="group123")
        message.group_id = None

        assert message.group is None

    def test_group_id_setter_with_empty_string_removes_group(self):
        """Test group_id setter with empty string removes the group."""
        message = AstrBotMessage()
        message.group = Group(group_id="group123")
        message.group_id = ""

        assert message.group is None


class TestAstrBotMessageTypes:
    """Tests for AstrBotMessage with different message types."""

    def test_friend_message_type(self):
        """Test AstrBotMessage with FRIEND_MESSAGE type."""
        message = AstrBotMessage()
        message.type = MessageType.FRIEND_MESSAGE

        assert message.type == MessageType.FRIEND_MESSAGE
        assert message.type.value == "FriendMessage"

    def test_group_message_type(self):
        """Test AstrBotMessage with GROUP_MESSAGE type."""
        message = AstrBotMessage()
        message.type = MessageType.GROUP_MESSAGE

        assert message.type == MessageType.GROUP_MESSAGE
        assert message.type.value == "GroupMessage"

    def test_other_message_type(self):
        """Test AstrBotMessage with OTHER_MESSAGE type."""
        message = AstrBotMessage()
        message.type = MessageType.OTHER_MESSAGE

        assert message.type == MessageType.OTHER_MESSAGE
        assert message.type.value == "OtherMessage"


class TestAstrBotMessageChain:
    """Tests for AstrBotMessage message chain."""

    def test_message_chain_with_plain_text(self):
        """Test message chain with plain text."""
        message = AstrBotMessage()
        message.message = [Plain(text="Hello world")]

        assert len(message.message) == 1
        assert isinstance(message.message[0], Plain)
        assert message.message[0].text == "Hello world"

    def test_message_chain_with_multiple_components(self):
        """Test message chain with multiple components."""
        message = AstrBotMessage()
        message.message = [
            Plain(text="Hello "),
            Plain(text="world"),
            Image(file="http://example.com/img.jpg"),
        ]

        assert len(message.message) == 3
        assert isinstance(message.message[0], Plain)
        assert isinstance(message.message[1], Plain)
        assert isinstance(message.message[2], Image)

    def test_message_chain_empty(self):
        """Test empty message chain."""
        message = AstrBotMessage()
        message.message = []

        assert len(message.message) == 0