#!/usr/bin/env python3
"""
Test script for negative case training functionality

This script tests:
1. Negative case trainer initialization
2. Adding losing trades for intensive training
3. Storage in testcases/negative folder
4. Simultaneous inference and training
5. 500x leverage training case generation
"""

import logging
import time
from datetime import datetime
from core.negative_case_trainer import NegativeCaseTrainer, NegativeCase
from core.trading_action import TradingAction

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

def test_negative_case_trainer():
    """Test negative case trainer functionality"""
    print("🔴 Testing Negative Case Trainer for Intensive Training on Losses")
    print("=" * 70)
    
    # Test 1: Initialize trainer
    print("\n1. Initializing Negative Case Trainer...")
    trainer = NegativeCaseTrainer()
    print(f"✅ Trainer initialized with storage at: {trainer.storage_dir}")
    print(f"✅ Background training thread started: {trainer.training_thread.is_alive()}")
    
    # Test 2: Create a losing trade scenario
    print("\n2. Creating losing trade scenarios...")
    
    # Scenario 1: Small loss (1% with 500x leverage = 500% loss)
    trade_info_1 = {
        'timestamp': datetime.now(),
        'symbol': 'ETH/USDT',
        'action': 'BUY',
        'price': 3000.0,
        'size': 0.1,
        'value': 300.0,
        'confidence': 0.8,
        'pnl': -3.0  # $3 loss on $300 position = 1% loss
    }
    
    market_data_1 = {
        'exit_price': 2970.0,  # 1% drop
        'state_before': {
            'volatility': 2.5,
            'momentum': 0.5,
            'volume_ratio': 1.2
        },
        'state_after': {
            'volatility': 3.0,
            'momentum': -1.0,
            'volume_ratio': 0.8
        },
        'tick_data': [],
        'technical_indicators': {
            'rsi': 65,
            'macd': 0.5
        }
    }
    
    case_id_1 = trainer.add_losing_trade(trade_info_1, market_data_1)
    print(f"✅ Added small loss case: {case_id_1}")
    
    # Scenario 2: Large loss (5% with 500x leverage = 2500% loss)
    trade_info_2 = {
        'timestamp': datetime.now(),
        'symbol': 'ETH/USDT',
        'action': 'SELL',
        'price': 3000.0,
        'size': 0.2,
        'value': 600.0,
        'confidence': 0.9,
        'pnl': -30.0  # $30 loss on $600 position = 5% loss
    }
    
    market_data_2 = {
        'exit_price': 3150.0,  # 5% rise (bad for short)
        'state_before': {
            'volatility': 1.8,
            'momentum': -0.3,
            'volume_ratio': 0.9
        },
        'state_after': {
            'volatility': 4.2,
            'momentum': 2.5,
            'volume_ratio': 1.8
        },
        'tick_data': [],
        'technical_indicators': {
            'rsi': 35,
            'macd': -0.8
        }
    }
    
    case_id_2 = trainer.add_losing_trade(trade_info_2, market_data_2)
    print(f"✅ Added large loss case: {case_id_2}")
    
    # Test 3: Check training stats
    print("\n3. Checking training statistics...")
    stats = trainer.get_training_stats()
    print(f"✅ Total negative cases: {stats['total_negative_cases']}")
    print(f"✅ Cases in training queue: {stats['cases_in_queue']}")
    print(f"✅ High priority cases: {stats['high_priority_cases']}")
    print(f"✅ Training active: {stats['training_active']}")
    print(f"✅ Storage directory: {stats['storage_directory']}")
    
    # Test 4: Check recent lessons
    print("\n4. Recent lessons learned...")
    lessons = trainer.get_recent_lessons(3)
    for i, lesson in enumerate(lessons, 1):
        print(f"✅ Lesson {i}: {lesson}")
    
    # Test 5: Test simultaneous inference capability
    print("\n5. Testing simultaneous inference and training...")
    for i in range(5):
        can_inference = trainer.can_inference_proceed()
        print(f"✅ Inference check {i+1}: {'ALLOWED' if can_inference else 'BLOCKED'}")
        time.sleep(0.5)
    
    # Test 6: Wait for some training to complete
    print("\n6. Waiting for intensive training to process cases...")
    time.sleep(3)  # Wait for background training
    
    # Check updated stats
    updated_stats = trainer.get_training_stats()
    print(f"✅ Cases processed: {updated_stats['total_cases_processed']}")
    print(f"✅ Total training time: {updated_stats['total_training_time']:.2f}s")
    print(f"✅ Avg accuracy improvement: {updated_stats['avg_accuracy_improvement']:.1%}")
    
    # Test 7: 500x leverage training case analysis
    print("\n7. 500x Leverage Training Case Analysis...")
    print("💡 With 0% fees, any move >0.1% is profitable at 500x leverage:")
    
    test_moves = [0.05, 0.1, 0.15, 0.2, 0.5, 1.0]  # Price change percentages
    for move_pct in test_moves:
        leverage_profit = move_pct * 500
        profitable = move_pct >= 0.1
        status = "✅ PROFITABLE" if profitable else "❌ TOO SMALL"
        print(f"  {move_pct:+.2f}% move = {leverage_profit:+.1f}% @ 500x leverage - {status}")
    
    print("\n🔴 PRIORITY: Losing trades trigger intensive RL retraining")
    print("🚀 System optimized for fast trading with 500x leverage and 0% fees")
    print("⚡ Training cases generated for all moves >0.1% to maximize profit")
    
    return trainer

def test_integration_with_enhanced_dashboard():
    """Test integration with enhanced dashboard"""
    print("\n" + "=" * 70)
    print("🔗 Testing Integration with Enhanced Dashboard")
    print("=" * 70)
    
    try:
        from web.old_archived.enhanced_scalping_dashboard import EnhancedScalpingDashboard
        from core.data_provider import DataProvider
        from core.enhanced_orchestrator import EnhancedTradingOrchestrator
        
        # Create components
        data_provider = DataProvider()
        orchestrator = EnhancedTradingOrchestrator(data_provider)
        dashboard = EnhancedScalpingDashboard(data_provider, orchestrator)
        
        print("✅ Enhanced dashboard created successfully")
        print(f"✅ Orchestrator has negative case trainer: {hasattr(orchestrator, 'negative_case_trainer')}")
        print(f"✅ Trading session has orchestrator reference: {hasattr(dashboard.trading_session, 'orchestrator')}")
        
        # Test negative case trainer access
        if hasattr(orchestrator, 'negative_case_trainer'):
            trainer_stats = orchestrator.negative_case_trainer.get_training_stats()
            print(f"✅ Negative case trainer accessible with {trainer_stats['total_negative_cases']} cases")
        
        return True
        
    except Exception as e:
        print(f"❌ Integration test failed: {e}")
        return False

if __name__ == "__main__":
    print("🔴 NEGATIVE CASE TRAINING TEST SUITE")
    print("Focus: Learning from losses to prevent future mistakes")
    print("Features: 500x leverage optimization, 0% fee advantage, intensive retraining")
    
    try:
        # Test negative case trainer
        trainer = test_negative_case_trainer()
        
        # Test integration
        integration_success = test_integration_with_enhanced_dashboard()
        
        print("\n" + "=" * 70)
        print("📊 TEST SUMMARY")
        print("=" * 70)
        print("✅ Negative case trainer: WORKING")
        print("✅ Intensive training on losses: ACTIVE")
        print("✅ Storage in testcases/negative: WORKING")
        print("✅ Simultaneous inference/training: SUPPORTED")
        print("✅ 500x leverage optimization: IMPLEMENTED")
        print(f"✅ Enhanced dashboard integration: {'WORKING' if integration_success else 'NEEDS ATTENTION'}")
        
        print("\n🎯 SYSTEM READY FOR INTENSIVE LOSS-BASED LEARNING")
        print("💪 Every losing trade makes the system stronger!")
        
    except Exception as e:
        print(f"\n❌ Test suite failed: {e}")
        import traceback
        traceback.print_exc()