#!/usr/bin/env python3
"""
Test script to debug trading execution issues
"""

import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))

from core.trading_executor import TradingExecutor
from core.orchestrator import TradingOrchestrator
from core.data_provider import DataProvider
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def test_trading_execution():
    """Test trading execution in simulation mode"""
    
    logger.info("=" * 60)
    logger.info("TESTING TRADING EXECUTION")
    logger.info("=" * 60)
    
    # Initialize components
    logger.info("1. Initializing components...")
    data_provider = DataProvider()
    orchestrator = TradingOrchestrator(data_provider)
    trading_executor = TradingExecutor()
    
    # Check trading executor status
    logger.info("2. Checking trading executor status...")
    logger.info(f"   Trading enabled: {trading_executor.trading_enabled}")
    logger.info(f"   Trading mode: {trading_executor.trading_mode}")
    logger.info(f"   Simulation mode: {trading_executor.simulation_mode}")
    logger.info(f"   Exchange connected: {trading_executor.exchange is not None}")
    
    # Check account balance
    logger.info("3. Checking account balance...")
    try:
        balance = trading_executor.get_account_balance()
        logger.info(f"   Account balance: {balance}")
    except Exception as e:
        logger.error(f"   Error getting balance: {e}")
    
    # Test manual trade execution
    logger.info("4. Testing manual trade execution...")
    symbol = 'ETH/USDT'
    action = 'BUY'
    quantity = 0.01
    
    try:
        logger.info(f"   Executing: {action} {quantity} {symbol}")
        result = trading_executor.execute_trade(symbol, action, quantity)
        logger.info(f"   Result: {result}")
        
        if result:
            # Check positions
            positions = trading_executor.get_positions()
            logger.info(f"   Positions after trade: {positions}")
        
    except Exception as e:
        logger.error(f"   Error executing trade: {e}")
        import traceback
        traceback.print_exc()
    
    # Test orchestrator decision making
    logger.info("5. Testing orchestrator decisions...")
    try:
        import asyncio
        
        async def test_decision():
            decision = await orchestrator.make_trading_decision(symbol)
            if decision:
                logger.info(f"   Decision: {decision.action} (confidence: {decision.confidence:.3f})")
                
                # Test executing the decision
                if decision.action != 'HOLD':
                    result = trading_executor.execute_signal(
                        symbol=decision.symbol,
                        action=decision.action,
                        confidence=decision.confidence,
                        current_price=decision.price
                    )
                    logger.info(f"   Execution result: {result}")
            else:
                logger.info("   No decision made")
        
        asyncio.run(test_decision())
        
    except Exception as e:
        logger.error(f"   Error testing orchestrator: {e}")
        import traceback
        traceback.print_exc()
    
    # Check safety conditions
    logger.info("6. Testing safety conditions...")
    try:
        # Check if safety conditions are blocking trades
        symbol_test = 'ETH/USDT'
        action_test = 'BUY'
        
        # Access private method for testing (not ideal but for debugging)
        if hasattr(trading_executor, '_check_safety_conditions'):
            safety_ok = trading_executor._check_safety_conditions(symbol_test, action_test)
            logger.info(f"   Safety conditions OK for {action_test} {symbol_test}: {safety_ok}")
            
            # Check individual safety conditions
            config = trading_executor.mexc_config
            logger.info(f"   Emergency stop: {config.get('emergency_stop', False)}")
            logger.info(f"   Allowed symbols: {config.get('allowed_symbols', [])}")
            logger.info(f"   Daily loss: {trading_executor.daily_loss} / {config.get('max_daily_loss_usd', 5.0)}")
            logger.info(f"   Daily trades: {trading_executor.daily_trades} / {config.get('max_trades_per_hour', 2) * 24}")
            logger.info(f"   Concurrent positions: {len(trading_executor.positions)} / {config.get('max_concurrent_positions', 1)}")
        
    except Exception as e:
        logger.error(f"   Error checking safety conditions: {e}")
    
    logger.info("=" * 60)
    logger.info("TEST COMPLETE")
    logger.info("=" * 60)

if __name__ == "__main__":
    test_trading_execution()