Code_of_Conquest/api/tests/test_quest_integration.py

"""
Integration tests for Quest Offer Flow.

Tests the end-to-end quest offering pipeline:
- NPC talk endpoint → eligibility check → AI context → response parsing

These tests verify the wiring between components, not the individual
component logic (which is tested in unit tests).
"""

import pytest
from unittest.mock import MagicMock, patch
from dataclasses import dataclass, field
from typing import List, Dict, Optional

from app.ai.response_parser import parse_npc_dialogue, ParsedNPCDialogue
from app.services.quest_eligibility_service import (
    QuestEligibilityService,
    QuestOfferContext,
    QuestEligibilityResult,
    get_quest_eligibility_service,
)
from app.models.quest import (
    Quest,
    QuestReward,
    QuestObjective,
    QuestOfferingTriggers,
    QuestLoreContext,
    QuestDialogueTemplates,
    QuestDifficulty,
    ObjectiveType,
)
from app.api.npcs import _get_location_type


class TestQuestOfferMarkerParsing:
    """Tests for [QUEST_OFFER:quest_id] marker extraction."""

    def test_extracts_quest_id_from_dialogue(self):
        """parse_npc_dialogue extracts quest_id from [QUEST_OFFER:] marker."""
        response = "*leans in* Got a job for ye. [QUEST_OFFER:quest_cellar_rats]"
        result = parse_npc_dialogue(response)

        assert result.quest_offered == "quest_cellar_rats"
        assert "[QUEST_OFFER" not in result.dialogue
        assert "Got a job for ye" in result.dialogue

    def test_extracts_quest_id_multiline(self):
        """parse_npc_dialogue handles multiline responses with marker."""
        response = """*scratches beard* The rats have been getting worse...
[QUEST_OFFER:quest_cellar_rats]
Think you could help me out?"""
        result = parse_npc_dialogue(response)

        assert result.quest_offered == "quest_cellar_rats"
        assert "[QUEST_OFFER" not in result.dialogue
        assert "The rats have been getting worse" in result.dialogue
        assert "help me out" in result.dialogue

    def test_no_quest_marker_returns_none(self):
        """parse_npc_dialogue returns None when no marker present."""
        response = "*waves* Welcome to my shop! What can I do for you?"
        result = parse_npc_dialogue(response)

        assert result.quest_offered is None
        assert result.dialogue == response

    def test_handles_whitespace_in_marker(self):
        """parse_npc_dialogue handles whitespace in marker."""
        response = "[QUEST_OFFER: quest_with_spaces ] Some dialogue here."
        result = parse_npc_dialogue(response)

        assert result.quest_offered == "quest_with_spaces"

    def test_preserves_raw_response(self):
        """parse_npc_dialogue preserves original response in raw_response."""
        response = "*nods* [QUEST_OFFER:quest_test] Indeed."
        result = parse_npc_dialogue(response)

        assert result.raw_response == response
        assert "[QUEST_OFFER" in result.raw_response
        assert "[QUEST_OFFER" not in result.dialogue


class TestLocationTypeExtraction:
    """Tests for _get_location_type helper function."""

    def test_tavern_detection(self):
        """_get_location_type identifies tavern locations."""
        assert _get_location_type("crossville_tavern") == "tavern"
        assert _get_location_type("rusty_anchor_inn") == "tavern"
        assert _get_location_type("VILLAGE_TAVERN") == "tavern"

    def test_shop_detection(self):
        """_get_location_type identifies shop locations."""
        assert _get_location_type("crossville_shop") == "shop"
        assert _get_location_type("market_square") == "shop"
        assert _get_location_type("general_store") == "shop"

    def test_wilderness_detection(self):
        """_get_location_type identifies wilderness locations."""
        assert _get_location_type("dark_forest") == "wilderness"
        assert _get_location_type("mountain_road") == "wilderness"
        assert _get_location_type("northern_wilderness") == "wilderness"

    def test_dungeon_detection(self):
        """_get_location_type identifies dungeon locations."""
        assert _get_location_type("goblin_cave") == "dungeon"
        assert _get_location_type("ancient_dungeon") == "dungeon"
        assert _get_location_type("abandoned_mine") == "dungeon"

    def test_defaults_to_town(self):
        """_get_location_type defaults to town for unknown locations."""
        assert _get_location_type("crossville_town_center") == "town"
        assert _get_location_type("village_square") == "town"
        assert _get_location_type("unknown_location") == "town"


class TestQuestOfferContextSerialization:
    """Tests for QuestOfferContext.to_dict() output."""

    def test_to_dict_includes_required_fields(self):
        """QuestOfferContext.to_dict() includes all fields needed by template."""
        quest = Quest(
            quest_id="quest_test",
            name="Test Quest",
            description="A test quest",
            difficulty=QuestDifficulty.EASY,
            quest_giver_npc_ids=["npc_test"],
            rewards=QuestReward(gold=50, experience=100),
        )

        context = QuestOfferContext(
            quest=quest,
            offer_dialogue="Got a problem, friend.",
            npc_quest_knowledge=["The rats are big", "They came from tunnels"],
            lore_context=QuestLoreContext(backstory="Old tunnels reopened"),
            narrative_hooks=["looks worried", "glances at cellar door"],
        )

        data = context.to_dict()

        # Check all required fields for template
        assert data["quest_id"] == "quest_test"
        assert data["quest_name"] == "Test Quest"
        assert data["quest_description"] == "A test quest"
        assert data["offer_dialogue"] == "Got a problem, friend."
        assert "The rats are big" in data["npc_quest_knowledge"]
        assert "looks worried" in data["narrative_hooks"]
        assert data["lore_backstory"] == "Old tunnels reopened"
        assert data["rewards"]["gold"] == 50
        assert data["rewards"]["experience"] == 100


class TestQuestEligibilityServiceIntegration:
    """Tests for QuestEligibilityService integration."""

    @pytest.fixture
    def mock_character(self):
        """Create a mock character for testing."""
        char = MagicMock()
        char.level = 3
        char.active_quests = []
        char.completed_quests = []
        char.npc_interactions = {
            "npc_test": {
                "relationship_level": 50,
                "custom_flags": {},
            }
        }
        return char

    @pytest.fixture
    def sample_quest(self):
        """Create a sample quest for testing."""
        return Quest(
            quest_id="quest_cellar_rats",
            name="Rat Problem",
            description="Clear the cellar of rats",
            difficulty=QuestDifficulty.EASY,
            quest_giver_npc_ids=["npc_grom"],
            objectives=[
                QuestObjective(
                    objective_id="kill_rats",
                    description="Kill 10 rats",
                    objective_type=ObjectiveType.KILL,
                    required_progress=10,
                    target_enemy_type="giant_rat",
                )
            ],
            rewards=QuestReward(gold=50, experience=100),
            offering_triggers=QuestOfferingTriggers(
                location_types=["tavern", "town"],
                min_character_level=1,
                max_character_level=10,
                probability_weights={"tavern": 0.35, "town": 0.25},
            ),
            lore_context=QuestLoreContext(
                backstory="Rats came from old tunnels",
            ),
            dialogue_templates=QuestDialogueTemplates(
                narrative_hooks=["glances at cellar door"],
            ),
        )

    def test_no_quest_when_max_active(self, mock_character):
        """No quest offered when character has MAX_ACTIVE_QUESTS."""
        mock_character.active_quests = ["quest_1", "quest_2"]

        service = QuestEligibilityService()

        # Mock the quest service to return a quest
        with patch.object(service.quest_service, 'get_quests_for_npc', return_value=[]):
            result = service.check_eligibility(
                npc_id="npc_test",
                character=mock_character,
                location_type="tavern",
            )

        assert not result.should_offer_quest
        assert result.selected_quest_context is None

    def test_eligibility_result_structure(self, mock_character, sample_quest):
        """QuestEligibilityResult has correct structure."""
        service = QuestEligibilityService()

        # Mock to return a quest and force probability roll to succeed
        with patch.object(service.quest_service, 'get_quests_for_npc', return_value=[sample_quest]):
            result = service.check_eligibility(
                npc_id="npc_grom",
                character=mock_character,
                location_type="tavern",
                force_probability=1.0,  # Force offer
            )

        # Verify result structure
        assert isinstance(result.eligible_quests, list)
        assert isinstance(result.should_offer_quest, bool)
        assert isinstance(result.blocking_reasons, dict)

        if result.should_offer_quest:
            assert result.selected_quest_context is not None
            context_dict = result.selected_quest_context.to_dict()
            assert "quest_id" in context_dict
            assert "offer_dialogue" in context_dict


class TestNPCApiQuestIntegration:
    """Tests verifying quest context flows through NPC API."""

    def test_quest_offering_context_added_to_task_context(self):
        """Verify quest_offering_context field exists in task_context structure."""
        # This is a structural test - verify the expected dict key exists
        # in the code path (actual integration would require full app context)

        # The task_context dict should include quest_offering_context
        # Verified by reading npcs.py - this tests the pattern
        expected_task_context_keys = [
            "session_id",
            "character_id",
            "character",
            "npc",
            "npc_full",
            "conversation_topic",
            "game_state",
            "npc_knowledge",
            "revealed_secrets",
            "interaction_count",
            "relationship_level",
            "previous_dialogue",
            "quest_offering_context",  # Our new field
        ]

        # This serves as documentation that the field should exist
        assert "quest_offering_context" in expected_task_context_keys

    def test_generator_accepts_quest_offering_context(self):
        """Verify NarrativeGenerator accepts quest_offering_context parameter."""
        from app.ai.narrative_generator import NarrativeGenerator

        # Check the method signature accepts the parameter
        import inspect
        sig = inspect.signature(NarrativeGenerator.generate_npc_dialogue)
        params = list(sig.parameters.keys())

        assert "quest_offering_context" in params


class TestQuestOfferProbability:
    """Tests for probability-based quest offering."""

    def test_probability_zero_never_offers(self):
        """With force_probability=0, quest should never be offered."""
        char = MagicMock()
        char.level = 5
        char.active_quests = []
        char.completed_quests = []
        char.npc_interactions = {}

        quest = Quest(
            quest_id="quest_test",
            name="Test",
            description="Test",
            difficulty=QuestDifficulty.EASY,
            quest_giver_npc_ids=["npc_test"],
            rewards=QuestReward(),
        )

        service = QuestEligibilityService()

        with patch.object(service.quest_service, 'get_quests_for_npc', return_value=[quest]):
            result = service.check_eligibility(
                npc_id="npc_test",
                character=char,
                force_probability=0.0,  # Never offer
            )

        assert not result.should_offer_quest

    def test_probability_one_always_offers(self):
        """With force_probability=1, quest should always be offered."""
        char = MagicMock()
        char.level = 5
        char.active_quests = []
        char.completed_quests = []
        char.npc_interactions = {"npc_test": {"relationship_level": 50, "custom_flags": {}}}

        quest = Quest(
            quest_id="quest_test",
            name="Test",
            description="Test",
            difficulty=QuestDifficulty.EASY,
            quest_giver_npc_ids=["npc_test"],
            rewards=QuestReward(),
            offering_triggers=QuestOfferingTriggers(
                min_character_level=1,
                max_character_level=10,
            ),
        )

        service = QuestEligibilityService()

        with patch.object(service.quest_service, 'get_quests_for_npc', return_value=[quest]):
            result = service.check_eligibility(
                npc_id="npc_test",
                character=char,
                force_probability=1.0,  # Always offer
            )

        assert result.should_offer_quest
        assert result.selected_quest_context is not None


class TestQuestProgressUpdate:
    """Tests for quest progress update functionality."""

    @pytest.fixture
    def sample_quest_with_kill_objective(self):
        """Create a quest with a kill objective."""
        return Quest(
            quest_id="quest_kill_rats",
            name="Rat Exterminator",
            description="Kill the rats in the cellar",
            difficulty=QuestDifficulty.EASY,
            quest_giver_npc_ids=["npc_innkeeper"],
            objectives=[
                QuestObjective(
                    objective_id="kill_rats",
                    description="Kill 5 giant rats",
                    objective_type=ObjectiveType.KILL,
                    required_progress=5,
                    target_enemy_type="giant_rat",
                )
            ],
            rewards=QuestReward(gold=50, experience=100),
        )

    def test_objective_progress_increment(self):
        """Test that objective progress increments correctly."""
        from app.models.quest import CharacterQuestState, QuestStatus

        state = CharacterQuestState(
            quest_id="quest_test",
            status=QuestStatus.ACTIVE,
            accepted_at="2025-11-29T10:00:00Z",
            objectives_progress={"kill_rats": 0},
        )

        # Update progress
        state.update_progress("kill_rats", 1)
        assert state.get_progress("kill_rats") == 1

        # Update again
        state.update_progress("kill_rats", 2)
        assert state.get_progress("kill_rats") == 3

    def test_objective_completion_check(self, sample_quest_with_kill_objective):
        """Test that is_complete works correctly on objectives."""
        obj = sample_quest_with_kill_objective.objectives[0]

        # Not complete at 0
        obj.current_progress = 0
        assert not obj.is_complete

        # Not complete at 4
        obj.current_progress = 4
        assert not obj.is_complete

        # Complete at 5
        obj.current_progress = 5
        assert obj.is_complete

        # Complete at more than required
        obj.current_progress = 7
        assert obj.is_complete

    def test_quest_completion_requires_all_objectives(self):
        """Test that quest.is_complete requires all objectives done."""
        quest = Quest(
            quest_id="quest_multi",
            name="Multi-Objective Quest",
            description="Do multiple things",
            difficulty=QuestDifficulty.MEDIUM,
            quest_giver_npc_ids=["npc_test"],
            objectives=[
                QuestObjective(
                    objective_id="obj1",
                    description="Do first thing",
                    objective_type=ObjectiveType.KILL,
                    required_progress=3,
                    current_progress=3,  # Complete
                ),
                QuestObjective(
                    objective_id="obj2",
                    description="Do second thing",
                    objective_type=ObjectiveType.COLLECT,
                    required_progress=5,
                    current_progress=2,  # Not complete
                ),
            ],
            rewards=QuestReward(),
        )

        # Quest not complete because obj2 is incomplete
        assert not quest.is_complete

        # Complete obj2
        quest.objectives[1].current_progress = 5
        assert quest.is_complete

    def test_progress_text_formatting(self):
        """Test objective.progress_text formatting."""
        obj = QuestObjective(
            objective_id="test",
            description="Test",
            objective_type=ObjectiveType.KILL,
            required_progress=10,
            current_progress=3,
        )

        assert obj.progress_text == "3/10"

        obj.current_progress = 0
        assert obj.progress_text == "0/10"

        obj.current_progress = 10
        assert obj.progress_text == "10/10"


class TestCombatKillTracking:
    """Tests for combat kill tracking integration."""

    def test_kill_objective_matches_enemy_type(self):
        """Test that kill objectives match against target_enemy_type."""
        obj = QuestObjective(
            objective_id="kill_rats",
            description="Kill 5 giant rats",
            objective_type=ObjectiveType.KILL,
            required_progress=5,
            target_enemy_type="giant_rat",
        )

        # Should match
        assert obj.target_enemy_type == "giant_rat"
        assert obj.objective_type == ObjectiveType.KILL

        # Test non-kill objective doesn't have target
        obj2 = QuestObjective(
            objective_id="collect_items",
            description="Collect 3 rat tails",
            objective_type=ObjectiveType.COLLECT,
            required_progress=3,
            target_item_id="rat_tail",
        )

        assert obj2.objective_type == ObjectiveType.COLLECT
        assert obj2.target_enemy_type is None


class TestQuestRewardsSerialization:
    """Tests for quest rewards serialization."""

    def test_rewards_to_dict(self):
        """Test QuestReward.to_dict() contains all fields."""
        rewards = QuestReward(
            gold=100,
            experience=250,
            items=["health_potion", "sword_of_rats"],
            relationship_bonuses={"npc_innkeeper": 10},
            unlocks_quests=["quest_deeper_tunnels"],
            reveals_locations=["secret_cellar"],
        )

        data = rewards.to_dict()

        assert data["gold"] == 100
        assert data["experience"] == 250
        assert "health_potion" in data["items"]
        assert "sword_of_rats" in data["items"]
        assert data["relationship_bonuses"]["npc_innkeeper"] == 10
        assert "quest_deeper_tunnels" in data["unlocks_quests"]
        assert "secret_cellar" in data["reveals_locations"]

    def test_rewards_from_dict(self):
        """Test QuestReward.from_dict() reconstructs correctly."""
        data = {
            "gold": 50,
            "experience": 100,
            "items": ["item1"],
            "relationship_bonuses": {"npc1": 5},
            "unlocks_quests": [],
            "reveals_locations": [],
        }

        rewards = QuestReward.from_dict(data)

        assert rewards.gold == 50
        assert rewards.experience == 100
        assert rewards.items == ["item1"]
        assert rewards.relationship_bonuses == {"npc1": 5}


class TestQuestStateSerialization:
    """Tests for CharacterQuestState serialization."""

    def test_quest_state_to_dict(self):
        """Test CharacterQuestState.to_dict() serialization."""
        from app.models.quest import CharacterQuestState, QuestStatus

        state = CharacterQuestState(
            quest_id="quest_test",
            status=QuestStatus.ACTIVE,
            accepted_at="2025-11-29T10:00:00Z",
            objectives_progress={"obj1": 3, "obj2": 0},
            completed_at=None,
        )

        data = state.to_dict()

        assert data["quest_id"] == "quest_test"
        assert data["status"] == "active"
        assert data["accepted_at"] == "2025-11-29T10:00:00Z"
        assert data["objectives_progress"]["obj1"] == 3
        assert data["objectives_progress"]["obj2"] == 0
        assert data["completed_at"] is None

    def test_quest_state_from_dict(self):
        """Test CharacterQuestState.from_dict() deserialization."""
        from app.models.quest import CharacterQuestState, QuestStatus

        data = {
            "quest_id": "quest_rats",
            "status": "active",
            "accepted_at": "2025-11-29T12:00:00Z",
            "objectives_progress": {"kill_rats": 5},
            "completed_at": None,
        }

        state = CharacterQuestState.from_dict(data)

        assert state.quest_id == "quest_rats"
        assert state.status == QuestStatus.ACTIVE
        assert state.accepted_at == "2025-11-29T12:00:00Z"
        assert state.get_progress("kill_rats") == 5
        assert state.completed_at is None

    def test_quest_state_completed(self):
        """Test CharacterQuestState with completed status."""
        from app.models.quest import CharacterQuestState, QuestStatus

        data = {
            "quest_id": "quest_done",
            "status": "completed",
            "accepted_at": "2025-11-29T10:00:00Z",
            "objectives_progress": {"obj1": 10},
            "completed_at": "2025-11-29T11:00:00Z",
        }

        state = CharacterQuestState.from_dict(data)

        assert state.status == QuestStatus.COMPLETED
        assert state.completed_at == "2025-11-29T11:00:00Z"