import pytest
from unittest.mock import patch, MagicMock
import sys

from confdoc.profiles.manager import ProfileManager


class TestProfileManager:
    def test_list_profiles(self):
        manager = ProfileManager()
        profiles = manager.list_profiles()
        assert "development" in profiles
        assert "staging" in profiles
        assert "production" in profiles
    
    def test_get_profile_info(self):
        manager = ProfileManager()
        info = manager.get_profile_info("development")
        assert info is not None
        assert info["name"] == "Development"
        assert "validation" in info
    
    def test_load_profile(self):
        manager = ProfileManager()
        profile = manager.load_profile("production")
        assert profile is not None
        assert profile["name"] == "Production"
    
    def test_load_nonexistent_profile(self):
        manager = ProfileManager()
        profile = manager.load_profile("nonexistent")
        assert profile is None
    
    def test_save_and_load_custom_profile(self):
        manager = ProfileManager()
        custom_profile = {
            "name": "Custom",
            "description": "A custom profile",
            "validation": {"strict": True},
            "overrides": {"custom_key": "custom_value"}
        }
        manager.save_profile("custom_test", custom_profile)
        
        loaded = manager.load_profile("custom_test")
        assert loaded is not None
        assert loaded["name"] == "Custom"
    
    def test_apply_profile_modifies_schema(self):
        manager = ProfileManager()
        profile = manager.load_profile("development")
        schema = {
            "type": "object",
            "properties": {}
        }
        
        result = manager.apply_profile(schema, profile)
        assert result is not None
    
    def test_create_profile_from_config(self):
        manager = ProfileManager()
        config = {
            "debug": True,
            "log_level": "DEBUG",
            "nested": {"key": "value"}
        }
        
        profile = manager.create_profile_from_config(config, "test_profile", "Test description")
        assert profile["name"] == "test_profile"
        assert profile["description"] == "Test description"
        assert "debug" in profile["overrides"]
        assert "log_level" in profile["overrides"]
    
    def test_merge_profiles(self):
        manager = ProfileManager()
        base = {
            "name": "Base",
            "validation": {"strict": False},
            "overrides": {"key1": "value1"}
        }
        override = {
            "name": "Override",
            "validation": {"strict": True},
            "overrides": {"key2": "value2"}
        }
        
        merged = manager.merge_profiles(base, override)
        assert merged["name"] == "Override"
        assert merged["validation"]["strict"] is True
        assert "key1" in merged["overrides"]
        assert "key2" in merged["overrides"]
    
    def test_get_environment_overrides(self):
        manager = ProfileManager()
        env_vars = {
            "CONFDOC_DEBUG": "true",
            "CONFDOC_LOG_LEVEL": "INFO",
            "OTHER_VAR": "ignored"
        }
        
        overrides = manager.get_environment_overrides(env_vars)
        assert "debug" in overrides
        assert overrides["debug"] is True
        assert "log_level" in overrides
        assert overrides["log_level"] == "INFO"
        assert "OTHER_VAR" not in overrides
    
    def test_parse_env_value_boolean(self):
        manager = ProfileManager()
        assert manager._parse_env_value("true") is True
        assert manager._parse_env_value("True") is True
        assert manager._parse_env_value("false") is False
    
    def test_parse_env_value_integer(self):
        manager = ProfileManager()
        assert manager._parse_env_value("123") == 123
        assert manager._parse_env_value("0") == 0
    
    def test_parse_env_value_float(self):
        manager = ProfileManager()
        assert manager._parse_env_value("3.14") == 3.14
    
    def test_parse_env_value_string(self):
        manager = ProfileManager()
        assert manager._parse_env_value("hello") == "hello"