#!/usr/bin/env python3
"""
Test Leverage Slider Functionality

This script tests the leverage slider integration in the dashboard:
- Verifies slider range (1x to 100x)
- Tests risk level calculation
- Checks leverage multiplier updates
"""

import sys
import os
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 setup_logging
from core.data_provider import DataProvider
from core.enhanced_orchestrator import EnhancedTradingOrchestrator
from web.dashboard import TradingDashboard

# Setup logging
setup_logging()
import logging
logger = logging.getLogger(__name__)

def test_leverage_calculations():
    """Test leverage risk calculations"""
    
    logger.info("=" * 50)
    logger.info("TESTING LEVERAGE CALCULATIONS")
    logger.info("=" * 50)
    
    test_cases = [
        {'leverage': 1, 'expected_risk': 'Low Risk'},
        {'leverage': 5, 'expected_risk': 'Low Risk'},
        {'leverage': 10, 'expected_risk': 'Medium Risk'},
        {'leverage': 25, 'expected_risk': 'Medium Risk'},
        {'leverage': 30, 'expected_risk': 'High Risk'},
        {'leverage': 50, 'expected_risk': 'High Risk'},
        {'leverage': 75, 'expected_risk': 'Extreme Risk'},
        {'leverage': 100, 'expected_risk': 'Extreme Risk'},
    ]
    
    for test_case in test_cases:
        leverage = test_case['leverage']
        expected_risk = test_case['expected_risk']
        
        # Calculate risk level using same logic as dashboard
        if leverage <= 5:
            actual_risk = "Low Risk"
        elif leverage <= 25:
            actual_risk = "Medium Risk"
        elif leverage <= 50:
            actual_risk = "High Risk"
        else:
            actual_risk = "Extreme Risk"
        
        status = "PASS" if actual_risk == expected_risk else "FAIL"
        logger.info(f"  {leverage:3d}x leverage -> {actual_risk:13s} (expected: {expected_risk:13s}) [{status}]")
        
        if status == "FAIL":
            logger.error(f"Test failed for {leverage}x leverage!")
            return False
    
    logger.info("All leverage calculation tests PASSED!")
    return True

def test_leverage_reward_amplification():
    """Test how different leverage levels amplify rewards"""
    
    logger.info("\n" + "=" * 50)
    logger.info("TESTING LEVERAGE REWARD AMPLIFICATION")
    logger.info("=" * 50)
    
    base_price = 3000.0
    price_changes = [0.001, 0.002, 0.005, 0.01]  # 0.1%, 0.2%, 0.5%, 1.0%
    leverage_levels = [1, 5, 10, 25, 50, 100]
    
    logger.info("Price Change | " + " | ".join([f"{lev:3d}x" for lev in leverage_levels]))
    logger.info("-" * 70)
    
    for price_change_pct in price_changes:
        results = []
        for leverage in leverage_levels:
            # Calculate amplified return
            amplified_return = price_change_pct * leverage * 100  # Convert to percentage
            results.append(f"{amplified_return:6.1f}%")
        
        logger.info(f"    {price_change_pct*100:4.1f}%   | " + " | ".join(results))
    
    logger.info("\nKey insights:")
    logger.info("- 1x leverage: Traditional trading returns")
    logger.info("- 50x leverage: Our current default for enhanced learning")
    logger.info("- 100x leverage: Maximum risk/reward amplification")
    
    return True

def test_dashboard_integration():
    """Test dashboard integration"""
    
    logger.info("\n" + "=" * 50)
    logger.info("TESTING DASHBOARD INTEGRATION")
    logger.info("=" * 50)
    
    try:
        # Initialize components
        logger.info("Creating data provider...")
        data_provider = DataProvider()
        
        logger.info("Creating enhanced orchestrator...")
        orchestrator = EnhancedTradingOrchestrator(data_provider)
        
        logger.info("Creating trading dashboard...")
        dashboard = TradingDashboard(data_provider, orchestrator)
        
        # Test leverage settings
        logger.info(f"Initial leverage: {dashboard.leverage_multiplier}x")
        logger.info(f"Leverage range: {dashboard.min_leverage}x to {dashboard.max_leverage}x")
        logger.info(f"Leverage step: {dashboard.leverage_step}x")
        
        # Test leverage updates
        test_leverages = [10, 25, 50, 75]
        for test_leverage in test_leverages:
            dashboard.leverage_multiplier = test_leverage
            logger.info(f"Set leverage to {dashboard.leverage_multiplier}x")
        
        logger.info("Dashboard integration test PASSED!")
        return True
        
    except Exception as e:
        logger.error(f"Dashboard integration test FAILED: {e}")
        return False

def main():
    """Run all leverage tests"""
    
    logger.info("LEVERAGE SLIDER FUNCTIONALITY TEST")
    logger.info("Testing the 50x leverage system with adjustable slider")
    
    all_passed = True
    
    # Test 1: Leverage calculations
    if not test_leverage_calculations():
        all_passed = False
    
    # Test 2: Reward amplification
    if not test_leverage_reward_amplification():
        all_passed = False
    
    # Test 3: Dashboard integration
    if not test_dashboard_integration():
        all_passed = False
    
    # Final result
    logger.info("\n" + "=" * 50)
    if all_passed:
        logger.info("ALL TESTS PASSED!")
        logger.info("Leverage slider functionality is working correctly.")
        logger.info("\nTo use:")
        logger.info("1. Run: python run_scalping_dashboard.py")
        logger.info("2. Open: http://127.0.0.1:8050")
        logger.info("3. Find the leverage slider in the System & Leverage panel")
        logger.info("4. Adjust leverage from 1x to 100x")
        logger.info("5. Watch risk levels update automatically")
    else:
        logger.error("SOME TESTS FAILED!")
        logger.error("Check the error messages above.")
    
    return 0 if all_passed else 1

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