"""
Unit tests for configuration management
"""
import pytest
from pathlib import Path
from drt.config.models import (
    DatabaseConnection,
    DatabasePair,
    ComparisonSettings,
    RowCountSettings,
    SchemaSettings,
    AggregateSettings,
    ReportingSettings,
    LoggingSettings,
    Config
)


class TestDatabaseConnection:
    """Test DatabaseConnection model"""
    
    def test_database_connection_minimal(self):
        """Test creating a minimal database connection"""
        conn = DatabaseConnection(
            server="SQLSERVER01",
            database="TestDB"
        )
        assert conn.server == "SQLSERVER01"
        assert conn.database == "TestDB"
        assert conn.timeout.connection == 30
        assert conn.timeout.query == 300
    
    def test_database_connection_with_timeout(self):
        """Test database connection with custom timeout"""
        conn = DatabaseConnection(
            server="SQLSERVER01",
            database="TestDB",
            timeout={"connection": 60, "query": 600}
        )
        assert conn.timeout.connection == 60
        assert conn.timeout.query == 600


class TestDatabasePair:
    """Test DatabasePair model"""
    
    def test_database_pair_creation(self):
        """Test creating a database pair"""
        pair = DatabasePair(
            name="Test_Pair",
            enabled=True,
            baseline=DatabaseConnection(
                server="SQLSERVER01",
                database="PROD_DB"
            ),
            target=DatabaseConnection(
                server="SQLSERVER01",
                database="TEST_DB"
            )
        )
        assert pair.name == "Test_Pair"
        assert pair.enabled is True
        assert pair.baseline.database == "PROD_DB"
        assert pair.target.database == "TEST_DB"


class TestComparisonSettings:
    """Test ComparisonSettings model"""
    
    def test_comparison_settings_health_check(self):
        """Test health check mode settings"""
        settings = ComparisonSettings(
            mode="health_check",
            row_count=RowCountSettings(enabled=True, tolerance_percent=0.0),
            schema=SchemaSettings(
                enabled=True,
                checks={
                    "column_names": True,
                    "data_types": True
                }
            ),
            aggregates=AggregateSettings(enabled=False)
        )
        assert settings.mode == "health_check"
        assert settings.row_count.enabled is True
        assert settings.aggregates.enabled is False
    
    def test_comparison_settings_full_mode(self):
        """Test full mode settings"""
        settings = ComparisonSettings(
            mode="full",
            row_count=RowCountSettings(enabled=True, tolerance_percent=0.0),
            schema=SchemaSettings(enabled=True),
            aggregates=AggregateSettings(enabled=True, tolerance_percent=0.01)
        )
        assert settings.mode == "full"
        assert settings.aggregates.enabled is True
        assert settings.aggregates.tolerance_percent == 0.01


class TestReportingSettings:
    """Test ReportingSettings model"""
    
    def test_reporting_settings_defaults(self):
        """Test default reporting settings"""
        settings = ReportingSettings()
        assert settings.output_dir == "./reports"
        assert settings.formats.html is True
        assert settings.formats.csv is True
        assert settings.formats.pdf is False
        assert settings.include_timestamp is True
    
    def test_reporting_settings_custom(self):
        """Test custom reporting settings"""
        settings = ReportingSettings(
            output_dir="./custom_reports",
            filename_prefix="custom_test",
            formats={"html": True, "csv": False, "pdf": True}
        )
        assert settings.output_dir == "./custom_reports"
        assert settings.filename_prefix == "custom_test"
        assert settings.formats.pdf is True


class TestLoggingSettings:
    """Test LoggingSettings model"""
    
    def test_logging_settings_defaults(self):
        """Test default logging settings"""
        settings = LoggingSettings()
        assert settings.level == "INFO"
        assert settings.output_dir == "./logs"
        assert settings.console.enabled is True
        assert settings.file.enabled is True
    
    def test_logging_settings_custom(self):
        """Test custom logging settings"""
        settings = LoggingSettings(
            level="DEBUG",
            console={"enabled": True, "level": "WARNING"}
        )
        assert settings.level == "DEBUG"
        assert settings.console.level == "WARNING"


class TestConfig:
    """Test Config model"""
    
    def test_config_minimal(self):
        """Test creating a minimal config"""
        config = Config(
            database_pairs=[
                DatabasePair(
                    name="Test",
                    enabled=True,
                    baseline=DatabaseConnection(
                        server="SERVER01",
                        database="PROD"
                    ),
                    target=DatabaseConnection(
                        server="SERVER01",
                        database="TEST"
                    )
                )
            ],
            comparison=ComparisonSettings(
                mode="health_check",
                row_count=RowCountSettings(enabled=True),
                schema=SchemaSettings(enabled=True),
                aggregates=AggregateSettings(enabled=False)
            ),
            tables=[]
        )
        assert len(config.database_pairs) == 1
        assert config.comparison.mode == "health_check"
        assert len(config.tables) == 0
    
    def test_config_with_tables(self):
        """Test config with table definitions"""
        from drt.models.table import TableInfo
        
        config = Config(
            database_pairs=[
                DatabasePair(
                    name="Test",
                    enabled=True,
                    baseline=DatabaseConnection(server="S1", database="D1"),
                    target=DatabaseConnection(server="S1", database="D2")
                )
            ],
            comparison=ComparisonSettings(
                mode="health_check",
                row_count=RowCountSettings(enabled=True),
                schema=SchemaSettings(enabled=True),
                aggregates=AggregateSettings(enabled=False)
            ),
            tables=[
                TableInfo(
                    schema="dbo",
                    name="TestTable",
                    enabled=True,
                    expected_in_target=True
                )
            ]
        )
        assert len(config.tables) == 1
        assert config.tables[0].name == "TestTable"