"""Test the headless GUI functionality."""

import pytest
from web_sentinel.gui.headless import HeadlessWebSentinelGUI, MockVar, get_gui_class
from web_sentinel.model import ScanRequest, Finding


class TestMockVar:
    """Test the MockVar class."""
    
    def test_mock_var_initialization(self):
        """Test MockVar initialization."""
        var = MockVar()
        assert var.get() is None
        
        var_with_value = MockVar("test")
        assert var_with_value.get() == "test"
    
    def test_mock_var_set_get(self):
        """Test MockVar set and get operations."""
        var = MockVar()
        var.set("hello")
        assert var.get() == "hello"
        
        var.set(42)
        assert var.get() == 42
        
        var.set(True)
        assert var.get() is True


class TestHeadlessWebSentinelGUI:
    """Test the HeadlessWebSentinelGUI class."""
    
    @pytest.fixture
    def headless_gui(self):
        """Create a HeadlessWebSentinelGUI instance for testing."""
        return HeadlessWebSentinelGUI()
    
    def test_initialization(self, headless_gui):
        """Test HeadlessWebSentinelGUI initialization."""
        assert headless_gui.is_scanning is False
        assert len(headless_gui.scan_results) == 0
        assert headless_gui.timeout_var.get() == 5.0
        assert headless_gui.allow_invasive_var.get() is False
        
        # Test module variables
        assert headless_gui.module_vars['tls'].get() is True
        assert headless_gui.module_vars['headers'].get() is True
        assert headless_gui.module_vars['third-party'].get() is False
    
    def test_get_set_domains(self, headless_gui):
        """Test domain management."""
        # Test empty domains
        domains = headless_gui.get_domains()
        assert domains == []
        
        # Test setting domains
        test_domains = ["example.com", "test.com", "demo.org"]
        headless_gui.set_domains(test_domains)
        retrieved_domains = headless_gui.get_domains()
        assert retrieved_domains == test_domains
    
    def test_get_set_selected_modules(self, headless_gui):
        """Test module selection management."""
        # Test default selection
        selected = headless_gui.get_selected_modules()
        assert 'tls' in selected
        assert 'headers' in selected
        assert 'third-party' not in selected
        
        # Test setting custom selection
        headless_gui.set_selected_modules(['tls', 'injection'])
        selected = headless_gui.get_selected_modules()
        assert selected == ['tls', 'injection']
        
        # Verify other modules are deselected
        assert headless_gui.module_vars['headers'].get() is False
        assert headless_gui.module_vars['tls'].get() is True
        assert headless_gui.module_vars['injection'].get() is True
    
    def test_start_scan_no_domains(self, headless_gui):
        """Test scan with no domains specified."""
        result = headless_gui.start_scan()
        assert result is False
        assert headless_gui.is_scanning is False
    
    def test_start_scan_no_modules(self, headless_gui):
        """Test scan with no modules selected."""
        headless_gui.set_domains(["example.com"])
        headless_gui.set_selected_modules([])  # No modules
        
        result = headless_gui.start_scan()
        assert result is False
        assert headless_gui.is_scanning is False
    
    def test_display_results_empty(self, headless_gui):
        """Test displaying results when no results exist."""
        # Should not crash with empty results
        headless_gui.display_results()
        assert len(headless_gui.scan_results) == 0
    
    def test_display_results_with_data(self, headless_gui, mock_scan_results):
        """Test displaying results with actual data."""
        headless_gui.scan_results = mock_scan_results
        # Should not crash with actual results
        headless_gui.display_results()
    
    def test_export_report_no_results(self, headless_gui):
        """Test exporting report with no results."""
        result = headless_gui.export_report("json")
        assert result is None
    
    def test_run_headless_test(self, headless_gui):
        """Test the headless test functionality."""
        test_domains = ["httpbin.org"]  # Use a real domain for testing
        
        # Run with safe modules only (no network required modules)  
        result = headless_gui.run_headless_test(
            test_domains=test_domains,
            test_modules=['headers']  # Only headers, no TLS to avoid network issues
        )
        
        assert isinstance(result, dict)
        assert "test_timestamp" in result
        assert "domains_tested" in result
        assert "modules_used" in result
        assert "scan_success" in result
        assert result["domains_tested"] == test_domains


class TestGUIClassFactory:
    """Test the GUI class factory function."""
    
    def test_get_gui_class_headless(self):
        """Test getting headless GUI class."""
        gui_class = get_gui_class(headless=True)
        assert gui_class == HeadlessWebSentinelGUI
    
    def test_get_gui_class_tkinter_fallback(self):
        """Test GUI class fallback when tkinter unavailable."""
        # This will try tkinter first, then fall back to headless
        gui_class = get_gui_class(headless=False)
        
        # Should return either WebSentinelGUI or HeadlessWebSentinelGUI
        # depending on tkinter availability
        assert gui_class is not None
        
        # Test that we can instantiate it
        gui_instance = gui_class()
        assert gui_instance is not None