"""
Unit tests for RelationshipInferenceEngine

Tests the intelligent relationship type classification system for knowledge graph associations.
"""

import pytest
import time

from mcp_memory_service.consolidation.relationship_inference import RelationshipInferenceEngine


@pytest.fixture
def engine():
    """Create RelationshipInferenceEngine instance with default settings."""
    return RelationshipInferenceEngine(min_confidence=0.5)


@pytest.fixture
def strict_engine():
    """Create RelationshipInferenceEngine with strict confidence threshold."""
    return RelationshipInferenceEngine(min_confidence=0.8)


class TestRelationshipInferenceEngineInit:
    """Tests for RelationshipInferenceEngine initialization."""

    def test_default_initialization(self):
        """Engine should initialize with default confidence threshold."""
        engine = RelationshipInferenceEngine()
        assert engine.min_confidence == 0.6

    def test_custom_confidence_threshold(self):
        """Engine should accept custom confidence threshold."""
        engine = RelationshipInferenceEngine(min_confidence=0.75)
        assert engine.min_confidence == 0.75

    def test_zero_confidence_threshold(self):
        """Engine should accept zero confidence threshold."""
        engine = RelationshipInferenceEngine(min_confidence=0.0)
        assert engine.min_confidence == 0.0


class TestTypeCombinaticAnalysis:
    """Tests for type combination analysis."""

    @pytest.mark.asyncio
    async def test_learning_fixes_error(self, engine):
        """Learning/insight fixing an error/bug should be detected."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="learning/insight",
            target_type="error/bug",
            source_content="Fixed authentication timeout by adjusting configuration",
            target_content="Authentication error: Request timeout after 30 seconds",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100
        )
        assert rel_type == "fixes"
        assert confidence >= 0.5

    @pytest.mark.asyncio
    async def test_error_fixes_error(self, engine):
        """One error/bug memory may fix another; with stricter typed-label
        thresholds (issue #541) a single resolution keyword at 0.6 confidence
        falls below min_typed_confidence=0.75 and downgrades to 'related'.
        Strong multi-signal cases (content + type combination) still resolve
        to 'fixes' — see TestIntegrationScenarios.test_bug_fix_complete_workflow."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="error/bug",
            target_type="error/bug",
            source_content="Fixed database deadlock issue",
            target_content="Database deadlock on transaction commit",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100
        )
        # error→error type combination gives "causes" at 0.6; resolution
        # keyword gives "fixes" at 0.6; both are below min_typed_confidence=0.75
        # so the result falls back to "related".  Shared keywords are present
        # ("database", "deadlock") so the domain guard passes.
        assert rel_type in ["fixes", "related"]
        assert confidence >= 0.0

    @pytest.mark.asyncio
    async def test_valid_relationship_types_returned(self, engine):
        """Engine should only return valid relationship types."""
        valid_types = ["related", "follows", "supports", "causes", "fixes", "contradicts"]

        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Some content",
            target_content="Other content",
            source_timestamp=time.time(),
            target_timestamp=time.time()
        )

        assert rel_type in valid_types
        assert 0.0 <= confidence <= 1.0


class TestContentSemanticAnalysis:
    """Tests for content semantic analysis."""

    @pytest.mark.asyncio
    async def test_fix_keyword_detection(self, engine):
        """Content with 'fixed' can suggest fixes relationship."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Fixed the configuration bug by updating the settings file",
            target_content="Configuration bug causing application crashes",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100
        )
        # Should detect fix signal or default to related
        assert rel_type in ["fixes", "related"]
        assert confidence >= 0.0

    @pytest.mark.asyncio
    async def test_contradiction_keyword_detection(self, engine):
        """Content with contradiction keywords can be detected."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="However, testing shows that caching actually improves performance",
            target_content="Caching degrades performance",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 50
        )
        # Should detect contradiction or default to related
        assert rel_type in ["contradicts", "related"]
        assert confidence >= 0.0

    @pytest.mark.asyncio
    async def test_no_clear_pattern_defaults_to_related(self, engine):
        """Content without clear patterns should default to 'related'."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Meeting notes about Q1 planning",
            target_content="Team lunch at restaurant",
            source_timestamp=time.time(),
            target_timestamp=time.time()
        )
        assert rel_type == "related"
        assert confidence >= 0.0


class TestTemporalAnalysis:
    """Tests for temporal pattern analysis."""

    @pytest.mark.asyncio
    async def test_temporal_proximity_affects_confidence(self, engine):
        """Temporal proximity should affect confidence scores."""
        now = time.time()

        # Very close in time (1 minute)
        rel_type1, conf1 = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Deployed version 1.0",
            target_content="Checked deployment status",
            source_timestamp=now,
            target_timestamp=now + 60
        )

        # Far apart (1 week)
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Deployed version 1.0",
            target_content="Checked deployment status",
            source_timestamp=now,
            target_timestamp=now + 604800
        )

        # Closer events should have higher or equal confidence
        assert conf1 >= confidence or abs(conf1 - confidence) < 0.1

    @pytest.mark.asyncio
    async def test_sequential_events_detected(self, engine):
        """Sequential events should be recognized."""
        now = time.time()
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Started deployment at 10:00 AM",
            target_content="Deployment completed at 10:15 AM",
            source_timestamp=now,
            target_timestamp=now + 900  # 15 minutes later
        )
        # Should detect temporal relationship
        assert rel_type in ["follows", "related"]
        assert confidence >= 0.0


class TestContradictionDetection:
    """Tests for contradiction detection."""

    @pytest.mark.asyncio
    async def test_negation_detection(self, engine):
        """Negation words can contribute to contradiction detection."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="The cache doesn't improve performance at all",
            target_content="Caching significantly improves performance",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100
        )
        # May detect contradiction or default to related
        assert rel_type in ["contradicts", "related"]
        assert confidence >= 0.0

    @pytest.mark.asyncio
    async def test_explicit_contradiction(self, engine):
        """Explicit contradiction keywords can be detected."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="This contradicts our earlier findings about performance",
            target_content="Performance improved by 50%",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 50
        )
        # May detect contradiction or default to related
        assert rel_type in ["contradicts", "related"]
        assert confidence >= 0.0


class TestConfidenceThreshold:
    """Tests for confidence threshold behavior."""

    @pytest.mark.asyncio
    async def test_strict_threshold_more_related_results(self, strict_engine):
        """Strict threshold should result in more 'related' classifications."""
        rel_type, confidence = await strict_engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Some observation",
            target_content="Another observation",
            source_timestamp=time.time(),
            target_timestamp=time.time()
        )
        # With strict threshold, should default to "related"
        assert rel_type == "related"

    @pytest.mark.asyncio
    async def test_high_confidence_inference(self, engine):
        """Strong signals should result in high-confidence inference."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="learning/insight",
            target_type="error/bug",
            source_content="Fixed the authentication bug by updating timeout configuration",
            target_content="Authentication bug causing timeout errors",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100
        )
        # Multiple strong signals should result in high confidence
        assert rel_type == "fixes"
        assert confidence >= 0.6


class TestEdgeCases:
    """Tests for edge cases and error handling."""

    @pytest.mark.asyncio
    async def test_none_content_causes_error(self, engine):
        """None content currently raises AttributeError - documented behavior."""
        # This documents current behavior - engine expects non-None content
        with pytest.raises(AttributeError):
            await engine.infer_relationship_type(
                source_type="observation",
                target_type="observation",
                source_content=None,
                target_content=None,
                source_timestamp=time.time(),
                target_timestamp=time.time()
            )

    @pytest.mark.asyncio
    async def test_empty_content_handled(self, engine):
        """Empty content should be handled gracefully."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="",
            target_content="",
            source_timestamp=time.time(),
            target_timestamp=time.time()
        )
        assert rel_type == "related"
        assert confidence >= 0.0

    @pytest.mark.asyncio
    async def test_very_long_content(self, engine):
        """Very long content should be processed without errors."""
        long_content = "word " * 5000
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content=long_content,
            target_content="short",
            source_timestamp=time.time(),
            target_timestamp=time.time()
        )
        # Should complete without error
        assert rel_type in ["related", "follows", "supports", "causes", "fixes", "contradicts"]
        assert 0.0 <= confidence <= 1.0

    @pytest.mark.asyncio
    async def test_unicode_content(self, engine):
        """Unicode content should be handled correctly."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="修正了错误 🐛 Fixed bug",
            target_content="发现了错误 Found bug 🔍",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100
        )
        # May detect "fixed" keyword or default to related
        assert rel_type in ["fixes", "related"]
        assert confidence >= 0.0

    @pytest.mark.asyncio
    async def test_special_regex_characters(self, engine):
        """Special regex characters in content should not cause errors."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Fixed bug with pattern: [a-z]+(?:\\d{2,4})?",
            target_content="Bug in regex pattern causing failures",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 50
        )
        # May detect fix signal or default to related
        assert rel_type in ["fixes", "related"]
        assert confidence >= 0.0


class TestTagAnalysis:
    """Tests for tag-based analysis."""

    @pytest.mark.asyncio
    async def test_shared_tags_influence(self, engine):
        """Shared tags should influence relationship detection."""
        # Many shared tags
        rel_type1, conf1 = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="First observation",
            target_content="Second observation",
            source_timestamp=time.time(),
            target_timestamp=time.time(),
            source_tags=["bug", "auth", "urgent"],
            target_tags=["bug", "auth", "critical"]
        )

        # No shared tags
        rel_type2, conf2 = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="First observation",
            target_content="Second observation",
            source_timestamp=time.time(),
            target_timestamp=time.time(),
            source_tags=["feature"],
            target_tags=["docs"]
        )

        # More shared context should result in higher or equal confidence
        assert conf1 >= conf2 or abs(conf1 - conf2) < 0.1

    @pytest.mark.asyncio
    async def test_no_tags_handled(self, engine):
        """Missing tags should not cause errors."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Content",
            target_content="Other content",
            source_timestamp=time.time(),
            target_timestamp=time.time()
        )
        assert rel_type in ["related", "follows", "supports", "causes", "fixes", "contradicts"]
        assert 0.0 <= confidence <= 1.0


class TestIntegrationScenarios:
    """Integration tests for realistic scenarios."""

    @pytest.mark.asyncio
    async def test_bug_fix_complete_workflow(self, engine):
        """Test complete bug discovery → fix workflow."""
        now = time.time()

        rel_type, confidence = await engine.infer_relationship_type(
            source_type="learning/insight",
            target_type="error/bug",
            source_content="Fixed by increasing database timeout from 5s to 30s",
            target_content="Database connection timeout error after 5 seconds",
            source_timestamp=now + 100,
            target_timestamp=now,
            source_tags=["bug", "database", "fix"],
            target_tags=["bug", "database", "timeout"]
        )

        # Multiple strong signals should result in "fixes" with high confidence
        assert rel_type == "fixes"
        assert confidence >= 0.6

    @pytest.mark.asyncio
    async def test_decision_support_chain(self, engine):
        """Test decision support relationships."""
        now = time.time()

        rel_type, confidence = await engine.infer_relationship_type(
            source_type="decision/architecture",
            target_type="decision/tool_choice",
            source_content="Decided to use microservices which supports distributed deployment",
            target_content="Selected Docker for service deployment",
            source_timestamp=now,
            target_timestamp=now + 3600,
            source_tags=["architecture", "planning"],
            target_tags=["architecture", "deployment", "docker"]
        )

        # Should detect relationship (supports or related)
        assert rel_type in ["supports", "related"]
        assert confidence >= 0.0

    @pytest.mark.asyncio
    async def test_conflicting_observations(self, engine):
        """Test detection of conflicting observations."""
        now = time.time()

        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="However, performance tests show caching degrades performance",
            target_content="Caching significantly improves performance",
            source_timestamp=now + 3600,
            target_timestamp=now,
            source_tags=["performance"],
            target_tags=["performance", "caching"]
        )

        # May detect contradiction or default to related
        assert rel_type in ["contradicts", "related"]
        assert confidence >= 0.0

    @pytest.mark.asyncio
    async def test_unrelated_memories(self, engine):
        """Test that clearly unrelated memories default to 'related'."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Meeting notes about quarterly planning",
            target_content="Recipe for chocolate cake",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 10000
        )

        assert rel_type == "related"
        assert confidence >= 0.0


class TestReturnTypes:
    """Tests for return type validation."""

    @pytest.mark.asyncio
    async def test_returns_tuple(self, engine):
        """Engine should always return a tuple of (str, float)."""
        result = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Content",
            target_content="Other content",
            source_timestamp=time.time(),
            target_timestamp=time.time()
        )

        assert isinstance(result, tuple)
        assert len(result) == 2
        assert isinstance(result[0], str)
        assert isinstance(result[1], float)

    @pytest.mark.asyncio
    async def test_confidence_in_valid_range(self, engine):
        """Confidence should always be between 0.0 and 1.0."""
        for _ in range(10):  # Test multiple scenarios
            rel_type, confidence = await engine.infer_relationship_type(
                source_type="observation",
                target_type="observation",
                source_content=f"Content {_}",
                target_content=f"Other {_}",
                source_timestamp=time.time(),
                target_timestamp=time.time() - _
            )

            assert 0.0 <= confidence <= 1.0


# ---------------------------------------------------------------------------
# Tests for GitHub issue #541 fixes
# ---------------------------------------------------------------------------

class TestIssue541ContradictionFalsePositives:
    """
    Regression tests for issue #541 — weak conjunctions must NOT produce
    `contradicts` labels.

    The original engine treated "however", "but", "yet", "although", and
    "nevertheless" as contradiction indicators, causing a near-100% false
    positive rate on typed edges.  These tests verify they are now treated as
    neutral connectors and do not trigger typed labels.
    """

    @pytest.mark.asyncio
    async def test_however_does_not_contradict_unrelated_memories(self, engine):
        """
        Issue #541: two unrelated memories where one uses 'however' must NOT
        receive a 'contradicts' label.
        """
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="However, I decided to take a different route to the office today.",
            target_content="The quarterly budget review meeting is scheduled for Friday.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 600,
        )
        assert rel_type != "contradicts", (
            "Issue #541: 'however' in an unrelated sentence must not trigger 'contradicts'"
        )

    @pytest.mark.asyncio
    async def test_but_does_not_contradict_unrelated_memories(self, engine):
        """Issue #541: 'but' must not cause 'contradicts' for unrelated memories."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="I wanted to write tests, but the meeting ran long.",
            target_content="The lunch special at the cafeteria was pasta today.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 300,
        )
        assert rel_type != "contradicts", (
            "Issue #541: 'but' in unrelated context must not trigger 'contradicts'"
        )

    @pytest.mark.asyncio
    async def test_yet_does_not_contradict_unrelated_memories(self, engine):
        """Issue #541: 'yet' must not cause 'contradicts' for unrelated memories."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="The deployment hasn't finished yet, still processing.",
            target_content="We ordered pizza for the team last Thursday.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 1000,
        )
        assert rel_type != "contradicts", (
            "Issue #541: 'yet' in unrelated context must not trigger 'contradicts'"
        )

    @pytest.mark.asyncio
    async def test_although_does_not_contradict_unrelated_memories(self, engine):
        """Issue #541: 'although' must not cause 'contradicts' for unrelated memories."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Although the build passed, I forgot to update the changelog.",
            target_content="The CI pipeline now runs on every push to the feature branch.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 200,
        )
        assert rel_type != "contradicts", (
            "Issue #541: 'although' in unrelated context must not trigger 'contradicts'"
        )

    @pytest.mark.asyncio
    async def test_nevertheless_does_not_contradict_unrelated_memories(self, engine):
        """Issue #541: 'nevertheless' must not cause 'contradicts' for unrelated memories."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Nevertheless, the team finished the sprint with all tasks done.",
            target_content="The office coffee machine broke down this morning.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 500,
        )
        assert rel_type != "contradicts", (
            "Issue #541: 'nevertheless' in unrelated context must not trigger 'contradicts'"
        )

    @pytest.mark.asyncio
    async def test_strong_contradiction_still_detected(self, engine):
        """
        Issue #541: genuine contradiction indicators (contradicts, disagree,
        opposite, incorrect, wrong) must still produce a 'contradicts' label
        when memories share domain keywords and confidence is sufficient.
        """
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="This contradicts the earlier measurement: caching degrades performance.",
            target_content="Caching measurement shows a 2x speedup in throughput.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 50,
        )
        # "contradicts" keyword + shared domain words ("caching", "performance"/"throughput")
        # → should produce contradicts label
        assert rel_type in ["contradicts", "related"], (
            "Issue #541: strong contradiction keyword with shared domain context "
            "should produce 'contradicts' or 'related', not another typed label"
        )

    @pytest.mark.asyncio
    async def test_wrong_keyword_fires_with_shared_domain(self, engine):
        """Issue #541: 'wrong' triggers 'contradicts' when memories share domain words."""
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="The previous algorithm is wrong — it fails on negative inputs.",
            target_content="The sorting algorithm was assumed to handle all integer values.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100,
        )
        assert rel_type in ["contradicts", "related"]

    @pytest.mark.asyncio
    async def test_contradiction_requires_shared_keywords(self, engine):
        """
        Issue #541: contradiction indicator alone (without shared domain keywords)
        must NOT produce 'contradicts' due to the cross-content guard.
        """
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="The opposite is true for our deployment pipeline.",
            target_content="The cafeteria served soup on Wednesday afternoon.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 200,
        )
        # "opposite" matches but memories share no domain keywords → guard fires
        assert rel_type == "related", (
            "Issue #541: contradiction keyword without shared domain must downgrade to 'related'"
        )


class TestIssue541TypedLabelThresholds:
    """
    Tests verifying min_typed_confidence and min_typed_similarity guards from
    issue #541.
    """

    @pytest.mark.asyncio
    async def test_new_constructor_params_accepted(self):
        """Issue #541: engine should accept new threshold parameters."""
        engine = RelationshipInferenceEngine(
            min_confidence=0.5,
            min_typed_confidence=0.8,
            min_typed_similarity=0.70,
        )
        assert engine.min_confidence == 0.5
        assert engine.min_typed_confidence == 0.8
        assert engine.min_typed_similarity == 0.70

    @pytest.mark.asyncio
    async def test_min_typed_confidence_floored_by_min_confidence(self):
        """
        Issue #541: min_typed_confidence cannot be lower than min_confidence.
        If caller passes a value below min_confidence, it is silently raised.
        """
        engine = RelationshipInferenceEngine(
            min_confidence=0.7,
            min_typed_confidence=0.5,  # lower than min_confidence → should be clamped
        )
        assert engine.min_typed_confidence >= engine.min_confidence

    @pytest.mark.asyncio
    async def test_low_similarity_downgrades_typed_label_to_related(self, engine):
        """
        Issue #541: when cosine similarity < min_typed_similarity (0.65),
        typed labels must be suppressed and fall back to 'related'.
        """
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="learning/insight",
            target_type="error/bug",
            source_content="Fixed the authentication timeout by increasing the limit.",
            target_content="Authentication error: Request timeout after 30 seconds.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100,
            similarity=0.40,  # below default min_typed_similarity=0.65
        )
        assert rel_type == "related", (
            "Issue #541: low cosine similarity must prevent typed labels"
        )

    @pytest.mark.asyncio
    async def test_sufficient_similarity_allows_typed_label(self, engine):
        """
        Issue #541: when cosine similarity >= min_typed_similarity (0.65),
        typed labels may be assigned (given other guards also pass).
        """
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="learning/insight",
            target_type="error/bug",
            source_content="Fixed the authentication timeout by increasing the limit.",
            target_content="Authentication error: Request timeout after 30 seconds.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100,
            similarity=0.80,  # above default min_typed_similarity=0.65
        )
        assert rel_type == "fixes", (
            "Issue #541: sufficient similarity with strong type signal should produce 'fixes'"
        )
        assert confidence >= 0.75

    @pytest.mark.asyncio
    async def test_no_shared_keywords_prevents_typed_label(self, engine):
        """
        Issue #541: type-pair heuristic fires for (learning, error) but
        memories with no overlapping domain keywords must be downgraded to
        'related'.
        """
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="learning/insight",
            target_type="error/bug",
            source_content="Learning piano scales improves finger dexterity.",
            target_content="NullPointerException in the order processing service.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 100,
        )
        assert rel_type == "related", (
            "Issue #541: type-pair heuristic must not fire without shared domain keywords"
        )

    @pytest.mark.asyncio
    async def test_type_combination_with_shared_keywords_produces_typed_label(self, engine):
        """
        Issue #541: (learning, error) pair fires 'fixes' at 0.8 confidence,
        which passes both the shared-keyword guard and min_typed_confidence.
        """
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="learning/insight",
            target_type="error/bug",
            source_content="Resolved the database connection timeout by adjusting pool settings.",
            target_content="Database connection timeout causes service degradation.",
            source_timestamp=time.time(),
            target_timestamp=time.time() - 300,
        )
        assert rel_type == "fixes"
        assert confidence >= 0.75

    @pytest.mark.asyncio
    async def test_related_edges_bypass_typed_confidence_gate(self, engine):
        """
        Issue #541: backward compatibility — 'related' edges must still be
        returned when confidence is between min_confidence and
        min_typed_confidence.
        """
        # Two observations close in time → "follows" at 0.4, below typed gate
        # → falls to "related".  Both return "related" regardless.
        now = time.time()
        rel_type, confidence = await engine.infer_relationship_type(
            source_type="observation",
            target_type="observation",
            source_content="Started the database migration script.",
            target_content="Verified migration completed without errors.",
            source_timestamp=now,
            target_timestamp=now + 1800,  # 30 minutes later, outside 1-hour window
        )
        # Temporal proximity gate (1h) will not fire; no strong typed signal
        assert rel_type in ["related", "follows"]

    @pytest.mark.asyncio
    async def test_default_initialization_typed_params(self):
        """Issue #541: new parameters have correct defaults."""
        engine = RelationshipInferenceEngine()
        assert engine.min_confidence == 0.6
        assert engine.min_typed_confidence == 0.75
        assert engine.min_typed_similarity == 0.65
