"""
Test cloud context injection for cron jobs.
"""

import pytest
from cron.scheduler import (
    _detect_local_service_refs,
    _inject_cloud_context,
    _LOCAL_SERVICE_PATTERNS_COMPILED
)


class TestLocalServiceDetection:
    """Test detection of local service references."""
    
    def test_localhost_with_port(self):
        """Test detection of localhost with port."""
        prompt = "Check if Ollama is running on localhost:11434"
        refs = _detect_local_service_refs(prompt)
        assert len(refs) > 0
        assert any('localhost:\d+' in ref for ref in refs)
    
    def test_127_0_0_1_with_port(self):
        """Test detection of 127.0.0.1 with port."""
        prompt = "Connect to http://127.0.0.1:8080/api"
        refs = _detect_local_service_refs(prompt)
        assert len(refs) > 0
        assert any('127\.0\.0\.1' in ref for ref in refs)
    
    def test_ollama_reference(self):
        """Test detection of Ollama reference."""
        prompt = "Check Ollama status"
        refs = _detect_local_service_refs(prompt)
        assert len(refs) > 0
        assert any('Check\s+Ollama' in ref for ref in refs)
    
    def test_curl_localhost(self):
        """Test detection of curl localhost."""
        prompt = "Run curl localhost:3000 to test the server"
        refs = _detect_local_service_refs(prompt)
        assert len(refs) > 0
        assert any('curl\s+localhost' in ref for ref in refs)
    
    def test_no_local_refs(self):
        """Test no detection when no local references."""
        prompt = "Check the weather in New York"
        refs = _detect_local_service_refs(prompt)
        assert len(refs) == 0
    
    def test_multiple_refs(self):
        """Test detection of multiple local references."""
        prompt = "Check localhost:3000 and also Ollama on 127.0.0.1:11434"
        refs = _detect_local_service_refs(prompt)
        assert len(refs) >= 2


class TestCloudContextInjection:
    """Test cloud context warning injection."""
    
    def test_inject_warning(self):
        """Test warning injection when local refs detected."""
        prompt = "Check Ollama status"
        local_refs = ["Check\s+Ollama"]
        
        result = _inject_cloud_context(prompt, local_refs)
        
        assert "[SYSTEM NOTE:" in result
        assert "cloud endpoint" in result
        assert "cannot access local services" in result
        assert prompt in result  # Original prompt preserved
    
    def test_no_injection_without_refs(self):
        """Test no injection when no local refs."""
        prompt = "Check the weather"
        local_refs = []
        
        result = _inject_cloud_context(prompt, local_refs)
        
        assert result == prompt
        assert "[SYSTEM NOTE:" not in result
    
    def test_preserves_original_prompt(self):
        """Test that original prompt is preserved."""
        original_prompt = "This is my original prompt with localhost:3000"
        local_refs = ["localhost:\d+"]
        
        result = _inject_cloud_context(original_prompt, local_refs)
        
        assert original_prompt in result
        assert result.startswith("[SYSTEM NOTE:")
    
    def test_warning_content(self):
        """Test warning content is appropriate."""
        prompt = "Test prompt"
        local_refs = ["test"]
        
        result = _inject_cloud_context(prompt, local_refs)
        
        assert "report this limitation to the user" in result
        assert "instead of attempting to connect" in result


class TestPatternMatching:
    """Test individual pattern matching."""
    
    def test_common_ports(self):
        """Test detection of common development ports."""
        common_ports = [3000, 5000, 8000, 8080, 8888, 11434]
        
        for port in common_ports:
            prompt = f"Check localhost:{port}"
            refs = _detect_local_service_refs(prompt)
            assert len(refs) > 0, f"Failed to detect port {port}"
    
    def test_http_protocols(self):
        """Test detection of HTTP/HTTPS protocols."""
        protocols = ["http://localhost", "https://localhost", 
                    "http://127.0.0.1", "https://127.0.0.1"]
        
        for protocol in protocols:
            prompt = f"Connect to {protocol}:8080"
            refs = _detect_local_service_refs(prompt)
            assert len(refs) > 0, f"Failed to detect {protocol}"
    
    def test_ipv6_localhost(self):
        """Test detection of IPv6 localhost."""
        prompt = "Connect to [::1]:8080"
        refs = _detect_local_service_refs(prompt)
        assert len(refs) > 0
        assert any('\[::1\]' in ref for ref in refs)


class TestEdgeCases:
    """Test edge cases and false positives."""
    
    def test_case_insensitive(self):
        """Test case insensitive matching."""
        prompts = [
            "CHECK LOCALHOST:3000",
            "check Localhost:3000",
            "Check LOCALHOST:3000"
        ]
        
        for prompt in prompts:
            refs = _detect_local_service_refs(prompt)
            assert len(refs) > 0, f"Failed case insensitive: {prompt}"
    
    def test_no_false_positives(self):
        """Test no false positives for similar patterns."""
        safe_prompts = [
            "Check the localhost documentation",
            "Read about 127.0.0.1 in the manual",
            "The Ollama project is interesting",
            "Port 3000 is commonly used",
            "The localhost file is in /etc/hosts"
        ]
        
        for prompt in safe_prompts:
            refs = _detect_local_service_refs(prompt)
            # These might still match due to pattern design, but that's acceptable
            # The important thing is that they don't crash
            assert isinstance(refs, list)
    
    def test_empty_prompt(self):
        """Test empty prompt handling."""
        refs = _detect_local_service_refs("")
        assert refs == []
    
    def test_none_handling(self):
        """Test None prompt handling."""
        # The function should handle None gracefully
        try:
            refs = _detect_local_service_refs(None)
            assert refs == []
        except Exception as e:
            # If it raises an exception, that's also acceptable
            assert isinstance(e, (TypeError, AttributeError))


if __name__ == "__main__":
    pytest.main([__file__])