#!/usr/bin/env python3
"""
Test du Clean Trading Engine
Teste l'architecture sans faire de trades réels
"""
import asyncio
import sys
import os

# Ajouter le répertoire parent au path pour les imports
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

from clean_trading_engine import CleanTradingEngine

class TestTradingEngine(CleanTradingEngine):
    """Version test qui n'exécute pas de trades réels"""
    
    def __init__(self):
        super().__init__()
        self.logger.info("Mode TEST activé - Aucun trade réel ne sera exécuté")
        self.test_cycle_count = 0
        self.max_test_cycles = 3  # Faire seulement 3 cycles pour le test
    
    async def _trading_cycle(self):
        """Version test du cycle de trading"""
        self.test_cycle_count += 1
        self.logger.info(f"=== TEST CYCLE {self.test_cycle_count}/{self.max_test_cycles} ===")
        
        try:
            # Test 1: Récupération des positions live
            self.logger.info("TEST 1: Récupération positions live...")
            live_positions = self.position_manager.fetch_live_positions()
            self.logger.info(f"✓ Positions récupérées: {len(live_positions)}")
            
            # Test 2: Analyse des positions
            self.logger.info("TEST 2: Analyse des positions...")
            position_actions = self.position_manager.analyze_positions(live_positions)
            self.logger.info(f"✓ Actions identifiées: {len(position_actions)}")
            
            for action in position_actions:
                self.logger.info(f"  - Action: {action.action} pour {action.params.get('symbol', 'UNKNOWN')} - {action.reason}")
            
            # Test 3: Affichage des positions
            if live_positions:
                positions_summary = self.position_manager.get_positions_summary(live_positions)
                self.logger.info(f"TEST 3: Résumé positions:\n{positions_summary}")
            else:
                self.logger.info("TEST 3: Aucune position live trouvée")
            
            # Test 4: Récupération des signaux
            self.logger.info("TEST 4: Récupération des signaux...")
            signals = self.signal_service.fetch_signals()
            self.logger.info(f"✓ Signaux récupérés: {len(signals)}")
            
            # Test 5: Filtrage des signaux
            self.logger.info("TEST 5: Filtrage des signaux...")
            filtered_signals = self.signal_service.filter_signals(signals, live_positions)
            self.logger.info(f"✓ Signaux filtrés: {len(filtered_signals)}")
            
            # Test 6: Priorisation des signaux
            if filtered_signals:
                prioritized_signals = self.signal_service.get_signal_priority(filtered_signals)
                self.logger.info("TEST 6: Signaux priorisés:")
                for i, signal in enumerate(prioritized_signals[:3], 1):
                    self.logger.info(
                        f"  {i}. {signal.symbol} {signal.signal_type} "
                        f"(conf: {signal.confidence:.2f}, source: {signal.source})"
                    )
            else:
                self.logger.info("TEST 6: Aucun signal à prioriser")
            
            # Arrêter après le nombre de cycles de test
            if self.test_cycle_count >= self.max_test_cycles:
                self.logger.info("Tests terminés avec succès!")
                self.stop()
                
        except Exception as e:
            self.logger.error(f"Erreur pendant le test: {e}")
            import traceback
            traceback.print_exc()
    
    async def _handle_open_signal(self, signal, current_positions):
        """Version test - ne fait pas d'ordre réel"""
        self.logger.info(f"TEST OUVERTURE: {signal.symbol} {signal.signal_type} (simulation seulement)")
    
    async def _handle_close_signal(self, signal, current_positions):
        """Version test - ne fait pas de fermeture réelle"""
        self.logger.info(f"TEST FERMETURE: {signal.symbol} (simulation seulement)")

async def main():
    """Test principal"""
    print("=== DÉMARRAGE DES TESTS DU CLEAN TRADING ENGINE ===")
    
    test_engine = TestTradingEngine()
    
    try:
        await test_engine.start()
        print("Tests terminés!")
    except KeyboardInterrupt:
        test_engine.stop()
        print("Tests interrompus par l'utilisateur")
    except Exception as e:
        print(f"Erreur pendant les tests: {e}")
        import traceback
        traceback.print_exc()

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