"""
Unit Tests for Configuration Module.

Tests Settings class and configuration loading.
"""

import pytest
import os
from unittest.mock import patch

from app.config import Settings, get_settings, settings


class TestSettingsDefaults:
    """Tests for Settings default values."""
    
    def test_settings_instance_exists(self):
        """Test settings instance is created."""
        assert settings is not None
        assert isinstance(settings, Settings)
    
    def test_default_environment(self):
        """Test default environment is development."""
        s = Settings()
        assert s.ENVIRONMENT == "development"
    
    def test_default_debug_false(self):
        """Test default DEBUG is False."""
        s = Settings()
        assert s.DEBUG is False
    
    def test_default_log_level(self):
        """Test default log level is INFO."""
        s = Settings()
        assert s.LOG_LEVEL == "INFO"
    
    def test_default_max_turns(self):
        """Test default max turns is 20."""
        s = Settings()
        assert s.MAX_TURNS == 20
    
    def test_default_session_ttl(self):
        """Test default session TTL is 3600."""
        s = Settings()
        assert s.SESSION_TTL == 3600
    
    def test_default_scam_threshold(self):
        """Test default scam threshold is 0.7."""
        s = Settings()
        assert s.SCAM_THRESHOLD == 0.7
    
    def test_default_api_port(self):
        """Test default API port is 8000."""
        s = Settings()
        assert s.API_PORT == 8000
    
    def test_default_api_host(self):
        """Test default API host is 0.0.0.0."""
        s = Settings()
        assert s.API_HOST == "0.0.0.0"
    
    def test_default_groq_model(self):
        """Test default Groq model."""
        s = Settings()
        assert "llama" in s.GROQ_MODEL.lower()
    
    def test_default_max_message_length(self):
        """Test default max message length is 5000."""
        s = Settings()
        assert s.MAX_MESSAGE_LENGTH == 5000


class TestSettingsEnvironmentProperties:
    """Tests for environment check properties."""
    
    def test_is_production_false_by_default(self):
        """Test is_production is False by default."""
        s = Settings()
        assert s.is_production is False
    
    def test_is_development_true_by_default(self):
        """Test is_development is True by default."""
        s = Settings()
        assert s.is_development is True
    
    def test_is_testing_false_by_default(self):
        """Test is_testing is False by default."""
        s = Settings()
        assert s.is_testing is False
    
    @patch.dict(os.environ, {"ENVIRONMENT": "production"})
    def test_is_production_true_in_production(self):
        """Test is_production is True when ENVIRONMENT=production."""
        s = Settings()
        assert s.is_production is True
        assert s.is_development is False
        assert s.is_testing is False
    
    @patch.dict(os.environ, {"ENVIRONMENT": "testing"})
    def test_is_testing_true_in_testing(self):
        """Test is_testing is True when ENVIRONMENT=testing."""
        s = Settings()
        assert s.is_testing is True
        assert s.is_production is False
        assert s.is_development is False


class TestSettingsValidation:
    """Tests for Settings.validate method."""
    
    def test_validate_returns_list(self):
        """Test validate returns a list."""
        s = Settings()
        result = s.validate()
        
        assert isinstance(result, list)
    
    def test_validate_no_errors_in_development(self):
        """Test validate returns no errors in development."""
        s = Settings()
        s.ENVIRONMENT = "development"
        result = s.validate()
        
        assert result == []
    
    @patch.dict(os.environ, {"ENVIRONMENT": "production"})
    def test_validate_errors_in_production_without_keys(self):
        """Test validate returns errors in production without required keys."""
        s = Settings()
        s.GROQ_API_KEY = None
        s.POSTGRES_URL = None
        s.REDIS_URL = None
        
        result = s.validate()
        
        assert len(result) > 0
        assert any("GROQ_API_KEY" in e for e in result)
        assert any("POSTGRES_URL" in e for e in result)
        assert any("REDIS_URL" in e for e in result)
    
    @patch.dict(os.environ, {
        "ENVIRONMENT": "production",
        "GROQ_API_KEY": "test-key",
        "POSTGRES_URL": "postgresql://test",
        "REDIS_URL": "redis://test"
    })
    def test_validate_no_errors_in_production_with_keys(self):
        """Test validate returns no errors in production with all keys."""
        s = Settings()
        
        result = s.validate()
        
        assert result == []


class TestSettingsFromEnvironment:
    """Tests for loading settings from environment variables."""
    
    @patch.dict(os.environ, {"DEBUG": "true"})
    def test_debug_from_env(self):
        """Test DEBUG is loaded from environment."""
        s = Settings()
        assert s.DEBUG is True
    
    @patch.dict(os.environ, {"LOG_LEVEL": "DEBUG"})
    def test_log_level_from_env(self):
        """Test LOG_LEVEL is loaded from environment."""
        s = Settings()
        assert s.LOG_LEVEL == "DEBUG"
    
    @patch.dict(os.environ, {"MAX_TURNS": "30"})
    def test_max_turns_from_env(self):
        """Test MAX_TURNS is loaded from environment."""
        s = Settings()
        assert s.MAX_TURNS == 30
    
    @patch.dict(os.environ, {"SCAM_THRESHOLD": "0.8"})
    def test_scam_threshold_from_env(self):
        """Test SCAM_THRESHOLD is loaded from environment."""
        s = Settings()
        assert s.SCAM_THRESHOLD == 0.8
    
    @patch.dict(os.environ, {"API_PORT": "9000"})
    def test_api_port_from_env(self):
        """Test API_PORT is loaded from environment."""
        s = Settings()
        assert s.API_PORT == 9000
    
    @patch.dict(os.environ, {"GROQ_API_KEY": "test-key-123"})
    def test_groq_api_key_from_env(self):
        """Test GROQ_API_KEY is loaded from environment."""
        s = Settings()
        assert s.GROQ_API_KEY == "test-key-123"
    
    @patch.dict(os.environ, {"RATE_LIMIT_PER_MINUTE": "50"})
    def test_rate_limit_from_env(self):
        """Test RATE_LIMIT_PER_MINUTE is loaded from environment."""
        s = Settings()
        assert s.RATE_LIMIT_PER_MINUTE == 50


class TestGetSettings:
    """Tests for get_settings function."""
    
    def test_get_settings_returns_settings(self):
        """Test get_settings returns Settings instance."""
        result = get_settings()
        
        assert isinstance(result, Settings)
    
    def test_get_settings_cached(self):
        """Test get_settings returns cached instance."""
        result1 = get_settings()
        result2 = get_settings()
        
        assert result1 is result2


class TestSettingsAttributes:
    """Tests for Settings attribute types."""
    
    def test_groq_max_tokens_is_int(self):
        """Test GROQ_MAX_TOKENS is an integer."""
        s = Settings()
        assert isinstance(s.GROQ_MAX_TOKENS, int)
    
    def test_groq_temperature_is_float(self):
        """Test GROQ_TEMPERATURE is a float."""
        s = Settings()
        assert isinstance(s.GROQ_TEMPERATURE, float)
    
    def test_session_ttl_is_int(self):
        """Test SESSION_TTL is an integer."""
        s = Settings()
        assert isinstance(s.SESSION_TTL, int)
    
    def test_rate_limit_per_hour_is_int(self):
        """Test RATE_LIMIT_PER_HOUR is an integer."""
        s = Settings()
        assert isinstance(s.RATE_LIMIT_PER_HOUR, int)
    
    def test_api_prefix(self):
        """Test API_PREFIX is set correctly."""
        s = Settings()
        assert s.API_PREFIX == "/api/v1"
    
    def test_model_configuration(self):
        """Test model configuration settings."""
        s = Settings()
        
        assert s.INDICBERT_MODEL is not None
        assert s.SPACY_MODEL is not None
        assert s.EMBEDDING_MODEL is not None