#!/usr/bin/env python3
"""
Clean Trading System - Streamlined Entry Point

Simplified entry point with only essential modes:
- test: Test data provider and core components
- web: Live trading dashboard with integrated training pipeline

Streamlined Flow: Data -> Indicators/Pivots -> CNN -> RL -> Orchestrator -> Execution

Usage:
    python main_clean.py --mode [test|web] --symbol ETH/USDT
"""

import asyncio
import argparse
import logging
import sys
from pathlib import Path
from threading import Thread
import time

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

from core.config import get_config, setup_logging, Config
from core.data_provider import DataProvider

logger = logging.getLogger(__name__)

def run_data_test():
    """Test the enhanced data provider and core components"""
    try:
        config = get_config()
        logger.info("Testing Enhanced Data Provider and Core Components...")
        
        # Test data provider with multiple timeframes
        data_provider = DataProvider(
            symbols=['ETH/USDT'],
            timeframes=['1s', '1m', '1h', '4h']
        )
        
        # Test historical data
        logger.info("Testing historical data fetching...")
        df = data_provider.get_historical_data('ETH/USDT', '1h', limit=100)
        if df is not None:
            logger.info(f"[SUCCESS] Historical data: {len(df)} candles loaded")
            logger.info(f"   Columns: {len(df.columns)} total")
            logger.info(f"   Date range: {df['timestamp'].min()} to {df['timestamp'].max()}")
            
            # Show indicator breakdown
            basic_cols = ['timestamp', 'open', 'high', 'low', 'close', 'volume']
            indicators = [col for col in df.columns if col not in basic_cols]
            logger.info(f"   Technical indicators: {len(indicators)}")
        else:
            logger.error("[FAILED] Failed to load historical data")
        
        # Test multi-timeframe feature matrix
        logger.info("Testing multi-timeframe feature matrix...")
        feature_matrix = data_provider.get_feature_matrix('ETH/USDT', ['1h', '4h'], window_size=20)
        if feature_matrix is not None:
            logger.info(f"[SUCCESS] Feature matrix shape: {feature_matrix.shape}")
            logger.info(f"   Timeframes: {feature_matrix.shape[0]}")
            logger.info(f"   Window size: {feature_matrix.shape[1]}")
            logger.info(f"   Features: {feature_matrix.shape[2]}")
        else:
            logger.error("[FAILED] Failed to create feature matrix")
        
        # Test CNN model availability
        try:
            from NN.models.cnn_model import CNNModel
            cnn = CNNModel(n_actions=2)  # 2-action system
            logger.info("[SUCCESS] CNN model initialized with 2 actions (BUY/SELL)")
        except Exception as e:
            logger.warning(f"[WARNING] CNN model not available: {e}")
        
        # Test RL agent availability  
        try:
            from NN.models.dqn_agent import DQNAgent
            agent = DQNAgent(state_shape=(50,), n_actions=2)  # 2-action system
            logger.info("[SUCCESS] RL Agent initialized with 2 actions (BUY/SELL)")
        except Exception as e:
            logger.warning(f"[WARNING] RL Agent not available: {e}")
        
        # Test orchestrator
        try:
            from core.enhanced_orchestrator import EnhancedTradingOrchestrator
            orchestrator = EnhancedTradingOrchestrator(data_provider)
            logger.info("[SUCCESS] Enhanced Trading Orchestrator initialized")
        except Exception as e:
            logger.warning(f"[WARNING] Enhanced Orchestrator not available: {e}")
        
        # Test health check
        health = data_provider.health_check()
        logger.info(f"[SUCCESS] Data provider health check completed")
        
        logger.info("[SUCCESS] Core system test completed successfully!")
        logger.info("2-Action System: BUY/SELL only (no HOLD)")
        logger.info("Streamlined Flow: Data -> Indicators -> CNN -> RL -> Orchestrator -> Execution")
        
    except Exception as e:
        logger.error(f"Error in system test: {e}")
        import traceback
        logger.error(traceback.format_exc())
        raise

def run_web_dashboard():
    """Run the streamlined web dashboard with integrated training pipeline"""
    try:
        logger.info("Starting Streamlined Trading Dashboard...")
        logger.info("2-Action System: BUY/SELL with intelligent position management")
        logger.info("Integrated Training Pipeline: Live data -> Models -> Trading")
        
        # Get configuration
        config = get_config()
        
        # Initialize core components for streamlined pipeline
        from core.data_provider import DataProvider
        from core.enhanced_orchestrator import EnhancedTradingOrchestrator
        from core.trading_executor import TradingExecutor
        
        # Create data provider
        data_provider = DataProvider()
        
        # Verify data connection
        logger.info("[DATA] Verifying live data connection...")
        symbol = config.get('symbols', ['ETH/USDT'])[0]
        test_df = data_provider.get_historical_data(symbol, '1m', limit=10)
        if test_df is not None and len(test_df) > 0:
            logger.info("[SUCCESS] Data connection verified")
            logger.info(f"[SUCCESS] Fetched {len(test_df)} candles for validation")
        else:
            logger.error("[ERROR] Data connection failed - no live data available")
            return
        
        # Load model registry for integrated pipeline
        try:
            from core.model_registry import get_model_registry
            model_registry = get_model_registry()
            logger.info("[MODELS] Model registry loaded for integrated training")
        except ImportError:
            model_registry = {}
            logger.warning("Model registry not available, using empty registry")
        
        # Create streamlined orchestrator with 2-action system
        orchestrator = EnhancedTradingOrchestrator(
            data_provider=data_provider,
            symbols=config.get('symbols', ['ETH/USDT']),
            enhanced_rl_training=True,
            model_registry=model_registry
        )
        logger.info("Enhanced Trading Orchestrator with 2-Action System initialized")
        
        # Create trading executor for live execution
        trading_executor = TradingExecutor()
        
        # Import and create streamlined dashboard
        from web.dashboard import TradingDashboard
        dashboard = TradingDashboard(
            data_provider=data_provider, 
            orchestrator=orchestrator,
            trading_executor=trading_executor
        )
        
        # Start the integrated dashboard
        port = config.get('web', {}).get('port', 8050)
        host = config.get('web', {}).get('host', '127.0.0.1')
        
        logger.info(f"Starting Streamlined Dashboard at http://{host}:{port}")
        logger.info("Live Data Processing: ENABLED")
        logger.info("Integrated CNN Training: ENABLED") 
        logger.info("Integrated RL Training: ENABLED")
        logger.info("Real-time Indicators & Pivots: ENABLED")
        logger.info("Live Trading Execution: ENABLED")
        logger.info("2-Action System: BUY/SELL with position intelligence")
        logger.info("Pipeline: Data -> Indicators -> CNN -> RL -> Orchestrator -> Execution")
        
        dashboard.run(host=host, port=port, debug=False)
        
    except Exception as e:
        logger.error(f"Error in streamlined dashboard: {e}")
        logger.error("Dashboard stopped - trying minimal fallback")
        
        try:
            # Minimal fallback dashboard
            from web.dashboard import TradingDashboard
            from core.data_provider import DataProvider
            
            data_provider = DataProvider()
            dashboard = TradingDashboard(data_provider)
            logger.info("Using minimal fallback dashboard")
            dashboard.run(host='127.0.0.1', port=8050, debug=False)
        except Exception as fallback_error:
            logger.error(f"Fallback dashboard failed: {fallback_error}")
            logger.error(f"Fatal error: {e}")
            import traceback
            logger.error(traceback.format_exc())

async def main():
    """Main entry point with streamlined mode selection"""
    parser = argparse.ArgumentParser(description='Streamlined Trading System - Integrated Pipeline')
    parser.add_argument('--mode', 
                       choices=['test', 'web'], 
                       default='web', 
                       help='Operation mode: test (system check) or web (live trading)')
    parser.add_argument('--symbol', type=str, default='ETH/USDT',
                       help='Primary trading symbol (default: ETH/USDT)')
    parser.add_argument('--port', type=int, default=8050,
                       help='Web dashboard port (default: 8050)')
    parser.add_argument('--debug', action='store_true',
                       help='Enable debug mode')
    
    args = parser.parse_args()
    
    # Setup logging
    setup_logging()
    
    try:
        logger.info("=" * 70)
        logger.info("STREAMLINED TRADING SYSTEM - INTEGRATED PIPELINE")
        logger.info(f"Mode: {args.mode.upper()}")
        logger.info(f"Primary Symbol: {args.symbol}")
        if args.mode == 'web':
            logger.info("Integrated Flow: Data -> Indicators -> CNN -> RL -> Execution")
            logger.info("2-Action System: BUY/SELL with intelligent position management")
        logger.info("=" * 70)
        
        # Route to appropriate mode
        if args.mode == 'test':
            run_data_test()
        elif args.mode == 'web':
            run_web_dashboard()
        
        logger.info("[SUCCESS] Operation completed successfully!")
        
    except KeyboardInterrupt:
        logger.info("System shutdown requested by user")
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        import traceback
        logger.error(traceback.format_exc())
        return 1
    
    return 0

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