"""
Tests for Dashboard configuration validation
"""

import pytest

from src.dashboard.api import (
    SystemConfig,
    DatabaseConfig,
    OPCUAConfig,
    ModbusConfig,
    RESTAPIConfig,
    MonitoringConfig,
    SecurityConfig,
    validate_configuration,
    ValidationResult
)


class TestDashboardValidation:
    """Test dashboard configuration validation"""
    
    def test_validate_configuration_valid(self):
        """Test validation with valid configuration"""
        config = SystemConfig(
            database=DatabaseConfig(
                db_host="localhost",
                db_port=5432,
                db_name="calejo",
                db_user="calejo",
                db_password="secure_password"
            ),
            opcua=OPCUAConfig(port=4840),
            modbus=ModbusConfig(port=502),
            rest_api=RESTAPIConfig(port=8080),
            monitoring=MonitoringConfig(health_monitor_port=9090),
            security=SecurityConfig()
        )
        
        result = validate_configuration(config)
        assert result.valid == True
        assert len(result.errors) == 0
        assert len(result.warnings) == 0
    
    def test_validate_configuration_missing_database_fields(self):
        """Test validation with missing database fields"""
        config = SystemConfig(
            database=DatabaseConfig(
                db_host="",  # Missing host
                db_port=5432,
                db_name="",  # Missing database name
                db_user="",  # Missing user
                db_password="password"
            ),
            opcua=OPCUAConfig(),
            modbus=ModbusConfig(),
            rest_api=RESTAPIConfig(),
            monitoring=MonitoringConfig(),
            security=SecurityConfig()
        )
        
        result = validate_configuration(config)
        assert result.valid == False
        assert len(result.errors) == 3
        assert "Database host is required" in result.errors
        assert "Database name is required" in result.errors
        assert "Database user is required" in result.errors
    
    def test_validate_configuration_invalid_ports(self):
        """Test validation with invalid port numbers"""
        config = SystemConfig(
            database=DatabaseConfig(db_port=0),  # Invalid port
            opcua=OPCUAConfig(port=70000),  # Invalid port
            modbus=ModbusConfig(port=-1),  # Invalid port
            rest_api=RESTAPIConfig(port=65536),  # Invalid port
            monitoring=MonitoringConfig(health_monitor_port=0),  # Invalid port
            security=SecurityConfig()
        )
        
        result = validate_configuration(config)
        assert result.valid == False
        assert len(result.errors) == 5
        assert "Database port must be between 1 and 65535" in result.errors
        assert "OPC UA port must be between 1 and 65535" in result.errors
        assert "Modbus port must be between 1 and 65535" in result.errors
        assert "REST API port must be between 1 and 65535" in result.errors
        assert "Health monitor port must be between 1 and 65535" in result.errors
    
    def test_validate_configuration_default_credentials_warning(self):
        """Test validation with default credentials (warnings only)"""
        config = SystemConfig(
            database=DatabaseConfig(),
            opcua=OPCUAConfig(),
            modbus=ModbusConfig(),
            rest_api=RESTAPIConfig(),
            monitoring=MonitoringConfig(),
            security=SecurityConfig(
                jwt_secret_key="your-secret-key-change-in-production",
                api_key="your-api-key-here"
            )
        )
        
        result = validate_configuration(config)
        assert result.valid == True  # Should still be valid (just warnings)
        assert len(result.warnings) == 2
        assert "Default JWT secret key detected" in result.warnings[0]
        assert "Default API key detected" in result.warnings[1]
    
    def test_validate_configuration_valid_port_boundaries(self):
        """Test validation with valid port boundary values"""
        config = SystemConfig(
            database=DatabaseConfig(db_port=1),  # Minimum valid port
            opcua=OPCUAConfig(port=65535),  # Maximum valid port
            modbus=ModbusConfig(port=1024),  # Valid port
            rest_api=RESTAPIConfig(port=8080),  # Valid port
            monitoring=MonitoringConfig(health_monitor_port=9090),  # Valid port
            security=SecurityConfig()
        )
        
        result = validate_configuration(config)
        assert result.valid == True
        assert len(result.errors) == 0
    
    def test_validate_configuration_partial_errors(self):
        """Test validation with some valid and some invalid fields"""
        config = SystemConfig(
            database=DatabaseConfig(
                db_host="localhost",  # Valid
                db_port=5432,  # Valid
                db_name="",  # Invalid - missing
                db_user="calejo",  # Valid
                db_password="password"  # Valid
            ),
            opcua=OPCUAConfig(port=70000),  # Invalid port
            modbus=ModbusConfig(port=502),  # Valid
            rest_api=RESTAPIConfig(port=8080),  # Valid
            monitoring=MonitoringConfig(health_monitor_port=9090),  # Valid
            security=SecurityConfig()
        )
        
        result = validate_configuration(config)
        assert result.valid == False
        assert len(result.errors) == 2
        assert "Database name is required" in result.errors
        assert "OPC UA port must be between 1 and 65535" in result.errors
    
    def test_validation_result_structure(self):
        """Test ValidationResult structure"""
        result = ValidationResult(
            valid=True,
            errors=["error1", "error2"],
            warnings=["warning1"]
        )
        
        assert result.valid == True
        assert result.errors == ["error1", "error2"]
        assert result.warnings == ["warning1"]
    
    def test_validation_result_defaults(self):
        """Test ValidationResult with default values"""
        result = ValidationResult(valid=True)
        
        assert result.valid == True
        assert result.errors == []
        assert result.warnings == []