"""
Comprehensive unit tests for network module.
"""

import tempfile
from pathlib import Path
from unittest.mock import Mock, patch

import pytest

from cleveragents.network import AgentNetwork


class TestAgentNetwork:
    """Test cases for AgentNetwork class."""

    def test_agent_network_init_without_config_files(self):
        """Test AgentNetwork initialization without config files."""
        with patch('cleveragents.network.ConfigurationManager') as mock_config_manager:
            mock_config_instance = Mock()
            mock_config_manager.return_value = mock_config_instance

            network = AgentNetwork()

            # Should create ConfigurationManager
            assert network.config_manager == mock_config_instance
            mock_config_manager.assert_called_once()

            # Should not call load_files or validate
            mock_config_instance.load_files.assert_not_called()
            mock_config_instance.validate.assert_not_called()

            # agent_factory should be None
            assert network.agent_factory is None

    def test_agent_network_init_with_config_files(self):
        """Test AgentNetwork initialization with config files."""
        with patch('cleveragents.network.ConfigurationManager') as mock_config_manager:
            mock_config_instance = Mock()
            mock_config_manager.return_value = mock_config_instance

            config_files = [Path("config1.yaml"), Path("config2.yaml")]
            network = AgentNetwork(config_files=config_files)

            # Should create ConfigurationManager
            assert network.config_manager == mock_config_instance

            # Should call load_files and validate
            mock_config_instance.load_files.assert_called_once_with(config_files)
            mock_config_instance.validate.assert_called_once()

            # agent_factory should be None
            assert network.agent_factory is None

    def test_agent_network_init_with_single_config_file(self):
        """Test AgentNetwork initialization with single config file."""
        with patch('cleveragents.network.ConfigurationManager') as mock_config_manager:
            mock_config_instance = Mock()
            mock_config_manager.return_value = mock_config_instance

            config_files = [Path("config.yaml")]
            network = AgentNetwork(config_files=config_files)

            # Should call load_files with the list
            mock_config_instance.load_files.assert_called_once_with(config_files)
            mock_config_instance.validate.assert_called_once()

    def test_agent_network_init_with_verbose_flag(self):
        """Test AgentNetwork initialization with verbose flag."""
        with patch('cleveragents.network.ConfigurationManager') as mock_config_manager:
            mock_config_instance = Mock()
            mock_config_manager.return_value = mock_config_instance

            # verbose flag is accepted but not currently used
            network = AgentNetwork(_verbose=True)

            assert network.config_manager == mock_config_instance

    def test_agent_network_init_with_empty_config_list(self):
        """Test AgentNetwork initialization with empty config list."""
        with patch('cleveragents.network.ConfigurationManager') as mock_config_manager:
            mock_config_instance = Mock()
            mock_config_manager.return_value = mock_config_instance

            # Empty list is falsy, so load_files should not be called
            network = AgentNetwork(config_files=[])

            mock_config_instance.load_files.assert_not_called()
            mock_config_instance.validate.assert_not_called()

    @pytest.mark.asyncio
    async def test_process_raises_not_implemented_error(self):
        """Test that process method raises NotImplementedError."""
        with patch('cleveragents.network.ConfigurationManager'):
            network = AgentNetwork()

            with pytest.raises(NotImplementedError, match="AgentNetwork processing not yet implemented"):
                await network.process("test message")

    @pytest.mark.asyncio
    async def test_process_with_context_raises_not_implemented_error(self):
        """Test that process method with context raises NotImplementedError."""
        with patch('cleveragents.network.ConfigurationManager'):
            network = AgentNetwork()

            context = {"key": "value"}
            with pytest.raises(NotImplementedError, match="AgentNetwork processing not yet implemented"):
                await network.process("test message", context=context)

    @pytest.mark.asyncio
    async def test_process_with_none_context(self):
        """Test that process method with None context raises NotImplementedError."""
        with patch('cleveragents.network.ConfigurationManager'):
            network = AgentNetwork()

            with pytest.raises(NotImplementedError):
                await network.process("test message", context=None)

    @pytest.mark.asyncio
    async def test_process_with_empty_message(self):
        """Test that process method with empty message raises NotImplementedError."""
        with patch('cleveragents.network.ConfigurationManager'):
            network = AgentNetwork()

            with pytest.raises(NotImplementedError):
                await network.process("")

    def test_agent_network_config_manager_attribute(self):
        """Test that AgentNetwork has config_manager attribute."""
        with patch('cleveragents.network.ConfigurationManager') as mock_config_manager:
            mock_config_instance = Mock()
            mock_config_manager.return_value = mock_config_instance

            network = AgentNetwork()

            # Should have config_manager attribute
            assert hasattr(network, 'config_manager')
            assert network.config_manager is not None

    def test_agent_network_agent_factory_attribute(self):
        """Test that AgentNetwork has agent_factory attribute."""
        with patch('cleveragents.network.ConfigurationManager'):
            network = AgentNetwork()

            # Should have agent_factory attribute
            assert hasattr(network, 'agent_factory')

    def test_agent_network_agent_factory_initially_none(self):
        """Test that agent_factory is initially None."""
        with patch('cleveragents.network.ConfigurationManager'):
            network = AgentNetwork()

            assert network.agent_factory is None

    def test_agent_network_integration_with_real_paths(self):
        """Test AgentNetwork with real file paths (not opening files)."""
        with patch('cleveragents.network.ConfigurationManager') as mock_config_manager:
            mock_config_instance = Mock()
            mock_config_manager.return_value = mock_config_instance

            # Use real Path objects
            with tempfile.TemporaryDirectory() as tmpdir:
                config_file = Path(tmpdir) / "config.yaml"

                network = AgentNetwork(config_files=[config_file])

                # Should have been called with the path
                mock_config_instance.load_files.assert_called_once_with([config_file])

    def test_agent_network_with_multiple_config_files(self):
        """Test AgentNetwork with multiple config files."""
        with patch('cleveragents.network.ConfigurationManager') as mock_config_manager:
            mock_config_instance = Mock()
            mock_config_manager.return_value = mock_config_instance

            config_files = [
                Path("config1.yaml"),
                Path("config2.yaml"),
                Path("config3.yaml")
            ]

            network = AgentNetwork(config_files=config_files)

            mock_config_instance.load_files.assert_called_once_with(config_files)
            mock_config_instance.validate.assert_called_once()

    def test_agent_network_verbose_parameter_accepted(self):
        """Test that verbose parameter is accepted without error."""
        with patch('cleveragents.network.ConfigurationManager'):
            # Should not raise any errors
            network_verbose = AgentNetwork(_verbose=True)
            network_not_verbose = AgentNetwork(_verbose=False)

            assert network_verbose is not None
            assert network_not_verbose is not None


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