"""
Tests for Default Indicator Configurations System

Tests the comprehensive default indicator configurations, categories,
trading strategies, and preset management functionality.
"""

import pytest
from typing import Dict, Any

from components.charts.config.defaults import (
    IndicatorCategory,
    TradingStrategy,
    IndicatorPreset,
    CATEGORY_COLORS,
    create_trend_indicators,
    create_momentum_indicators,
    create_volatility_indicators,
    create_strategy_presets,
    get_all_default_indicators,
    get_indicators_by_category,
    get_indicators_for_timeframe,
    get_strategy_indicators,
    get_strategy_info,
    get_available_strategies,
    get_available_categories,
    create_custom_preset
)

from components.charts.config.indicator_defs import (
    ChartIndicatorConfig,
    validate_indicator_configuration
)


class TestIndicatorCategories:
    """Test indicator category functionality."""
    
    def test_trend_indicators_creation(self):
        """Test creation of trend indicators."""
        trend_indicators = create_trend_indicators()
        
        # Should have multiple SMA and EMA configurations
        assert len(trend_indicators) > 10
        
        # Check specific indicators exist
        assert "sma_20" in trend_indicators
        assert "sma_50" in trend_indicators
        assert "ema_12" in trend_indicators
        assert "ema_26" in trend_indicators
        
        # Validate all configurations
        for name, preset in trend_indicators.items():
            assert isinstance(preset, IndicatorPreset)
            assert preset.category == IndicatorCategory.TREND
            
            # Validate the actual configuration
            is_valid, errors = validate_indicator_configuration(preset.config)
            assert is_valid, f"Invalid trend indicator {name}: {errors}"
    
    def test_momentum_indicators_creation(self):
        """Test creation of momentum indicators."""
        momentum_indicators = create_momentum_indicators()
        
        # Should have multiple RSI and MACD configurations
        assert len(momentum_indicators) > 8
        
        # Check specific indicators exist
        assert "rsi_14" in momentum_indicators
        assert "macd_12_26_9" in momentum_indicators
        
        # Validate all configurations
        for name, preset in momentum_indicators.items():
            assert isinstance(preset, IndicatorPreset)
            assert preset.category == IndicatorCategory.MOMENTUM
            
            is_valid, errors = validate_indicator_configuration(preset.config)
            assert is_valid, f"Invalid momentum indicator {name}: {errors}"
    
    def test_volatility_indicators_creation(self):
        """Test creation of volatility indicators."""
        volatility_indicators = create_volatility_indicators()
        
        # Should have multiple Bollinger Bands configurations
        assert len(volatility_indicators) > 3
        
        # Check specific indicators exist
        assert "bb_20_20" in volatility_indicators
        
        # Validate all configurations
        for name, preset in volatility_indicators.items():
            assert isinstance(preset, IndicatorPreset)
            assert preset.category == IndicatorCategory.VOLATILITY
            
            is_valid, errors = validate_indicator_configuration(preset.config)
            assert is_valid, f"Invalid volatility indicator {name}: {errors}"


class TestStrategyPresets:
    """Test trading strategy preset functionality."""
    
    def test_strategy_presets_creation(self):
        """Test creation of strategy presets."""
        strategy_presets = create_strategy_presets()
        
        # Should have all strategy types
        expected_strategies = [strategy.value for strategy in TradingStrategy]
        for strategy in expected_strategies:
            assert strategy in strategy_presets
            
            preset = strategy_presets[strategy]
            assert "name" in preset
            assert "description" in preset
            assert "timeframes" in preset
            assert "indicators" in preset
            assert len(preset["indicators"]) > 0
    
    def test_get_strategy_indicators(self):
        """Test getting indicators for specific strategies."""
        scalping_indicators = get_strategy_indicators(TradingStrategy.SCALPING)
        assert len(scalping_indicators) > 0
        assert "ema_5" in scalping_indicators
        assert "rsi_7" in scalping_indicators
        
        day_trading_indicators = get_strategy_indicators(TradingStrategy.DAY_TRADING)
        assert len(day_trading_indicators) > 0
        assert "sma_20" in day_trading_indicators
        assert "rsi_14" in day_trading_indicators
    
    def test_get_strategy_info(self):
        """Test getting complete strategy information."""
        scalping_info = get_strategy_info(TradingStrategy.SCALPING)
        assert "name" in scalping_info
        assert "description" in scalping_info
        assert "timeframes" in scalping_info
        assert "indicators" in scalping_info
        assert "1m" in scalping_info["timeframes"]
        assert "5m" in scalping_info["timeframes"]


class TestDefaultIndicators:
    """Test default indicator functionality."""
    
    def test_get_all_default_indicators(self):
        """Test getting all default indicators."""
        all_indicators = get_all_default_indicators()
        
        # Should have indicators from all categories
        assert len(all_indicators) > 20
        
        # Validate all indicators
        for name, preset in all_indicators.items():
            assert isinstance(preset, IndicatorPreset)
            assert preset.category in [cat for cat in IndicatorCategory]
            
            is_valid, errors = validate_indicator_configuration(preset.config)
            assert is_valid, f"Invalid default indicator {name}: {errors}"
    
    def test_get_indicators_by_category(self):
        """Test filtering indicators by category."""
        trend_indicators = get_indicators_by_category(IndicatorCategory.TREND)
        momentum_indicators = get_indicators_by_category(IndicatorCategory.MOMENTUM)
        volatility_indicators = get_indicators_by_category(IndicatorCategory.VOLATILITY)
        
        # All should have indicators
        assert len(trend_indicators) > 0
        assert len(momentum_indicators) > 0
        assert len(volatility_indicators) > 0
        
        # Check categories are correct
        for preset in trend_indicators.values():
            assert preset.category == IndicatorCategory.TREND
        
        for preset in momentum_indicators.values():
            assert preset.category == IndicatorCategory.MOMENTUM
        
        for preset in volatility_indicators.values():
            assert preset.category == IndicatorCategory.VOLATILITY
    
    def test_get_indicators_for_timeframe(self):
        """Test filtering indicators by timeframe."""
        scalping_indicators = get_indicators_for_timeframe("1m")
        day_trading_indicators = get_indicators_for_timeframe("1h")
        position_indicators = get_indicators_for_timeframe("1d")
        
        # All should have some indicators
        assert len(scalping_indicators) > 0
        assert len(day_trading_indicators) > 0
        assert len(position_indicators) > 0
        
        # Check timeframes are included
        for preset in scalping_indicators.values():
            assert "1m" in preset.recommended_timeframes
        
        for preset in day_trading_indicators.values():
            assert "1h" in preset.recommended_timeframes


class TestUtilityFunctions:
    """Test utility functions for defaults system."""
    
    def test_get_available_strategies(self):
        """Test getting available trading strategies."""
        strategies = get_available_strategies()
        
        # Should have all strategy types
        assert len(strategies) == len(TradingStrategy)
        
        for strategy in strategies:
            assert "value" in strategy
            assert "name" in strategy
            assert "description" in strategy
            assert "timeframes" in strategy
    
    def test_get_available_categories(self):
        """Test getting available indicator categories."""
        categories = get_available_categories()
        
        # Should have all category types
        assert len(categories) == len(IndicatorCategory)
        
        for category in categories:
            assert "value" in category
            assert "name" in category
            assert "description" in category
    
    def test_create_custom_preset(self):
        """Test creating custom indicator presets."""
        custom_configs = [
            {
                "name": "Custom SMA",
                "indicator_type": "sma",
                "parameters": {"period": 15},
                "color": "#123456"
            },
            {
                "name": "Custom RSI",
                "indicator_type": "rsi", 
                "parameters": {"period": 10},
                "color": "#654321"
            }
        ]
        
        custom_presets = create_custom_preset(
            name="Test Custom",
            description="Test custom preset",
            category=IndicatorCategory.TREND,
            indicator_configs=custom_configs,
            recommended_timeframes=["5m", "15m"]
        )
        
        # Should create presets for valid configurations
        assert len(custom_presets) == 2
        
        for preset in custom_presets.values():
            assert preset.category == IndicatorCategory.TREND
            assert "5m" in preset.recommended_timeframes
            assert "15m" in preset.recommended_timeframes


class TestColorSchemes:
    """Test color scheme functionality."""
    
    def test_category_colors_exist(self):
        """Test that color schemes exist for categories."""
        required_categories = [
            IndicatorCategory.TREND,
            IndicatorCategory.MOMENTUM,
            IndicatorCategory.VOLATILITY
        ]
        
        for category in required_categories:
            assert category in CATEGORY_COLORS
            colors = CATEGORY_COLORS[category]
            
            # Should have multiple color options
            assert "primary" in colors
            assert "secondary" in colors
            assert "tertiary" in colors
            assert "quaternary" in colors
            
            # Colors should be valid hex codes
            for color_name, color_value in colors.items():
                assert color_value.startswith("#")
                assert len(color_value) == 7


class TestIntegration:
    """Test integration with existing systems."""
    
    def test_default_indicators_match_schema(self):
        """Test that default indicators match their schemas."""
        all_indicators = get_all_default_indicators()
        
        for name, preset in all_indicators.items():
            config = preset.config
            
            # Should validate against schema
            is_valid, errors = validate_indicator_configuration(config)
            assert is_valid, f"Default indicator {name} validation failed: {errors}"
    
    def test_strategy_indicators_exist_in_defaults(self):
        """Test that strategy indicators exist in default configurations."""
        all_indicators = get_all_default_indicators()
        
        for strategy in TradingStrategy:
            strategy_indicators = get_strategy_indicators(strategy)
            
            for indicator_name in strategy_indicators:
                # Each strategy indicator should exist in defaults
                # Note: Some might not exist yet, but most should
                if indicator_name in all_indicators:
                    preset = all_indicators[indicator_name]
                    assert isinstance(preset, IndicatorPreset)
    
    def test_timeframe_recommendations_valid(self):
        """Test that timeframe recommendations are valid."""
        all_indicators = get_all_default_indicators()
        valid_timeframes = ["1m", "5m", "15m", "1h", "4h", "1d", "1w"]
        
        for name, preset in all_indicators.items():
            for timeframe in preset.recommended_timeframes:
                assert timeframe in valid_timeframes, f"Invalid timeframe {timeframe} for {name}"


class TestPresetValidation:
    """Test that all presets are properly validated."""
    
    def test_all_trend_indicators_valid(self):
        """Test that all trend indicators are valid."""
        trend_indicators = create_trend_indicators()
        
        for name, preset in trend_indicators.items():
            # Test the preset structure
            assert isinstance(preset.name, str)
            assert isinstance(preset.description, str)
            assert preset.category == IndicatorCategory.TREND
            assert isinstance(preset.recommended_timeframes, list)
            assert len(preset.recommended_timeframes) > 0
            
            # Test the configuration
            config = preset.config
            is_valid, errors = validate_indicator_configuration(config)
            assert is_valid, f"Trend indicator {name} failed validation: {errors}"
    
    def test_all_momentum_indicators_valid(self):
        """Test that all momentum indicators are valid."""
        momentum_indicators = create_momentum_indicators()
        
        for name, preset in momentum_indicators.items():
            config = preset.config
            is_valid, errors = validate_indicator_configuration(config)
            assert is_valid, f"Momentum indicator {name} failed validation: {errors}"
    
    def test_all_volatility_indicators_valid(self):
        """Test that all volatility indicators are valid."""
        volatility_indicators = create_volatility_indicators()
        
        for name, preset in volatility_indicators.items():
            config = preset.config
            is_valid, errors = validate_indicator_configuration(config)
            assert is_valid, f"Volatility indicator {name} failed validation: {errors}"


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