#!/usr/bin/env python3
"""
Test Enhanced Trading System
Verify that both RL and CNN learning pipelines are active
"""

import asyncio
import logging
import sys
from pathlib import Path

# Add project root to path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))

from core.config import get_config
from core.data_provider import DataProvider
from core.enhanced_orchestrator import EnhancedTradingOrchestrator
from training.enhanced_cnn_trainer import EnhancedCNNTrainer
from training.enhanced_rl_trainer import EnhancedRLTrainer

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

async def test_enhanced_system():
    """Test the enhanced trading system components"""
    logger.info("Testing Enhanced Trading System...")
    
    try:
        # Initialize components
        config = get_config()
        data_provider = DataProvider(config)
        orchestrator = EnhancedTradingOrchestrator(data_provider)
        
        # Initialize trainers
        cnn_trainer = EnhancedCNNTrainer(config, orchestrator)
        rl_trainer = EnhancedRLTrainer(config, orchestrator)
        
        logger.info("COMPONENT STATUS:")
        logger.info(f"✓ Data Provider: {len(config.symbols)} symbols, {len(config.timeframes)} timeframes")
        logger.info(f"✓ Enhanced Orchestrator: Confidence threshold {orchestrator.confidence_threshold}")
        logger.info(f"✓ CNN Trainer: Model initialized")
        logger.info(f"✓ RL Trainer: {len(rl_trainer.agents)} agents initialized")
        
        # Test decision making
        logger.info("\nTesting decision making...")
        decisions_dict = await orchestrator.make_coordinated_decisions()
        decisions = [decision for decision in decisions_dict.values() if decision is not None]
        logger.info(f"✓ Generated {len(decisions)} trading decisions")
        
        for decision in decisions:
            logger.info(f"  - {decision.action} {decision.symbol} @ ${decision.price:.2f} (conf: {decision.confidence:.1%})")
        
        # Test RL learning capability
        logger.info("\nTesting RL learning capability...")
        for symbol, agent in rl_trainer.agents.items():
            buffer_size = len(agent.replay_buffer)
            epsilon = agent.epsilon
            logger.info(f"  - {symbol} RL Agent: Buffer={buffer_size}, Epsilon={epsilon:.3f}")
        
        # Test CNN training capability
        logger.info("\nTesting CNN training capability...")
        perfect_moves = orchestrator.get_perfect_moves_for_training()
        logger.info(f"  - Perfect moves available: {len(perfect_moves)}")
        
        if len(perfect_moves) > 0:
            logger.info("  - CNN ready for training on perfect moves")
        else:
            logger.info("  - CNN waiting for perfect moves to accumulate")
        
        # Test configuration
        logger.info("\nTraining Configuration:")
        logger.info(f"  - CNN training interval: {config.training.get('cnn_training_interval', 'N/A')} seconds")
        logger.info(f"  - RL training interval: {config.training.get('rl_training_interval', 'N/A')} seconds")
        logger.info(f"  - Min perfect moves for CNN: {config.training.get('min_perfect_moves', 'N/A')}")
        logger.info(f"  - Min experiences for RL: {config.training.get('min_experiences', 'N/A')}")
        logger.info(f"  - Continuous learning: {config.training.get('continuous_learning', False)}")
        
        logger.info("\n✅ Enhanced Trading System test completed successfully!")
        logger.info("LEARNING SYSTEMS STATUS:")
        logger.info("✓ RL agents ready for continuous learning from trading decisions")
        logger.info("✓ CNN trainer ready for pattern learning from perfect moves")
        logger.info("✓ Enhanced orchestrator coordinating multi-modal decisions")
        
        return True
        
    except Exception as e:
        logger.error(f"❌ Test failed: {e}")
        import traceback
        traceback.print_exc()
        return False

async def main():
    """Main test function"""
    logger.info("🚀 Starting Enhanced Trading System Test...")
    
    success = await test_enhanced_system()
    
    if success:
        logger.info("\n🎉 All tests passed! Enhanced trading system is ready.")
        logger.info("You can now run the enhanced dashboard or main trading system.")
    else:
        logger.error("\n💥 Tests failed! Please check the configuration and try again.")
        sys.exit(1)

if __name__ == "__main__":
    asyncio.run(main())