"""Tests for followup_research models."""

from local_deep_research.followup_research.models import (
    FollowUpRequest,
    FollowUpResponse,
)


class TestFollowUpRequest:
    """Tests for FollowUpRequest dataclass."""

    def test_create_with_required_fields(self):
        """Create request with only required fields."""
        request = FollowUpRequest(
            parent_research_id="parent-123",
            question="What is the follow-up question?",
        )

        assert request.parent_research_id == "parent-123"
        assert request.question == "What is the follow-up question?"
        assert request.strategy == "source-based"  # Default
        assert request.max_iterations == 1  # Default
        assert request.questions_per_iteration == 3  # Default

    def test_create_with_all_fields(self):
        """Create request with all fields specified."""
        request = FollowUpRequest(
            parent_research_id="parent-456",
            question="Custom question",
            strategy="iterative",
            max_iterations=5,
            questions_per_iteration=10,
        )

        assert request.parent_research_id == "parent-456"
        assert request.question == "Custom question"
        assert request.strategy == "iterative"
        assert request.max_iterations == 5
        assert request.questions_per_iteration == 10

    def test_to_dict(self):
        """to_dict returns dictionary with all fields."""
        request = FollowUpRequest(
            parent_research_id="parent-789",
            question="Test question",
            strategy="enhanced",
            max_iterations=2,
            questions_per_iteration=5,
        )

        result = request.to_dict()

        assert isinstance(result, dict)
        assert result["parent_research_id"] == "parent-789"
        assert result["question"] == "Test question"
        assert result["strategy"] == "enhanced"
        assert result["max_iterations"] == 2
        assert result["questions_per_iteration"] == 5

    def test_to_dict_with_defaults(self):
        """to_dict includes default values."""
        request = FollowUpRequest(
            parent_research_id="parent-abc",
            question="Question with defaults",
        )

        result = request.to_dict()

        assert result["strategy"] == "source-based"
        assert result["max_iterations"] == 1
        assert result["questions_per_iteration"] == 3

    def test_empty_question(self):
        """Create request with empty question (edge case)."""
        request = FollowUpRequest(
            parent_research_id="parent-123",
            question="",
        )

        assert request.question == ""


class TestFollowUpResponse:
    """Tests for FollowUpResponse dataclass."""

    def test_create_with_all_fields(self):
        """Create response with all fields."""
        sources = [
            {"title": "Source 1", "url": "https://example.com/1"},
            {"title": "Source 2", "url": "https://example.com/2"},
        ]

        response = FollowUpResponse(
            research_id="research-123",
            question="What was asked?",
            answer="This is the answer.",
            sources_used=sources,
            parent_context_used=True,
            reused_links_count=5,
            new_links_count=3,
        )

        assert response.research_id == "research-123"
        assert response.question == "What was asked?"
        assert response.answer == "This is the answer."
        assert len(response.sources_used) == 2
        assert response.parent_context_used is True
        assert response.reused_links_count == 5
        assert response.new_links_count == 3

    def test_to_dict(self):
        """to_dict returns dictionary with all fields."""
        sources = [{"title": "Source", "url": "https://example.com"}]

        response = FollowUpResponse(
            research_id="res-456",
            question="Test Q",
            answer="Test A",
            sources_used=sources,
            parent_context_used=False,
            reused_links_count=0,
            new_links_count=10,
        )

        result = response.to_dict()

        assert isinstance(result, dict)
        assert result["research_id"] == "res-456"
        assert result["question"] == "Test Q"
        assert result["answer"] == "Test A"
        assert result["sources_used"] == sources
        assert result["parent_context_used"] is False
        assert result["reused_links_count"] == 0
        assert result["new_links_count"] == 10

    def test_empty_sources(self):
        """Create response with empty sources list."""
        response = FollowUpResponse(
            research_id="res-empty",
            question="No sources",
            answer="Answer without sources",
            sources_used=[],
            parent_context_used=False,
            reused_links_count=0,
            new_links_count=0,
        )

        assert response.sources_used == []
        result = response.to_dict()
        assert result["sources_used"] == []

    def test_no_parent_context_used(self):
        """Create response without parent context usage."""
        response = FollowUpResponse(
            research_id="res-new",
            question="Fresh research",
            answer="New answer",
            sources_used=[],
            parent_context_used=False,
            reused_links_count=0,
            new_links_count=5,
        )

        assert response.parent_context_used is False
        assert response.reused_links_count == 0

    def test_all_reused_links(self):
        """Create response with all links reused from parent."""
        response = FollowUpResponse(
            research_id="res-reuse",
            question="Reuse question",
            answer="Reuse answer",
            sources_used=[{"title": "Reused", "url": "https://reused.com"}],
            parent_context_used=True,
            reused_links_count=10,
            new_links_count=0,
        )

        assert response.parent_context_used is True
        assert response.reused_links_count == 10
        assert response.new_links_count == 0
