#!/usr/bin/env python3
"""
SYSTÈME ADAPTATIF COMPLET - Pas de paramètres fixes

Au lieu d'optimiser des paramètres, on crée un système qui:
1. S'adapte aux conditions du marché EN TEMPS RÉEL
2. Ajuste automatiquement leverage, TP, SL selon volatilité
3. Confirme sur multi-timeframe
4. Gère le risque dynamiquement
5. Se valide sur données out-of-sample

AUCUN OVERFITTING - Logique pure
"""

import pandas as pd
import numpy as np
from martingale_backtester import MartingaleBacktester
import json
from datetime import datetime

class AdaptiveSystem:
    """Système de trading 100% adaptatif"""

    def __init__(self, initial_capital=1000):
        self.capital = initial_capital
        self.initial_capital = initial_capital
        self.position = None
        self.trades = []

    def analyze_market_regime(self, df, i):
        """Détecte le régime de marché actuel"""
        if i < 100:
            return None

        recent = df.iloc[i-100:i]

        # 1. VOLATILITÉ
        returns = recent['close'].pct_change()
        volatility = returns.std()

        # 2. TREND
        ma_short = recent['close'].tail(20).mean()
        ma_long = recent['close'].tail(50).mean()

        if ma_short > ma_long * 1.02:
            trend = 'UPTREND'
        elif ma_short < ma_long * 0.98:
            trend = 'DOWNTREND'
        else:
            trend = 'RANGING'

        # 3. VOLUME
        vol_ma = recent['volume'].mean()
        current_vol = df.iloc[i]['volume']
        volume_ratio = current_vol / vol_ma if vol_ma > 0 else 1

        # 4. ATR pour mesurer volatilité absolue
        high_low = recent['high'] - recent['low']
        atr = high_low.mean()
        atr_pct = (atr / recent['close'].mean()) * 100

        return {
            'volatility': volatility,
            'trend': trend,
            'volume_ratio': volume_ratio,
            'atr': atr,
            'atr_pct': atr_pct
        }

    def calculate_adaptive_params(self, regime):
        """Calcule paramètres adaptatifs selon le régime"""

        # LEVERAGE: Inversement proportionnel à la volatilité
        # Plus c'est volatile, moins on leverage
        if regime['atr_pct'] > 2.0:  # Très volatile
            base_leverage = 10
        elif regime['atr_pct'] > 1.0:  # Volatile
            base_leverage = 20
        elif regime['atr_pct'] > 0.5:  # Modéré
            base_leverage = 30
        else:  # Calme
            base_leverage = 50

        # Ajuster selon volume (plus de volume = plus de confiance)
        if regime['volume_ratio'] > 2.0:
            leverage = int(base_leverage * 1.3)
        elif regime['volume_ratio'] < 0.5:
            leverage = int(base_leverage * 0.7)
        else:
            leverage = base_leverage

        leverage = min(leverage, 50)  # Cap à 50x

        # TP/SL: Basés sur l'ATR
        # TP = 2x ATR, SL = 1x ATR
        tp_pct = regime['atr_pct'] * 2
        sl_pct = regime['atr_pct'] * 1

        # Limites de sécurité
        tp_pct = max(0.5, min(tp_pct, 5.0))
        sl_pct = max(0.3, min(sl_pct, 3.0))

        # POSITION SIZE: Basé sur le risque
        # On risque toujours 2% du capital max
        risk_per_trade = self.capital * 0.02
        # Position size = risk / (SL% * leverage)
        position_size = risk_per_trade / (sl_pct/100 * leverage)
        position_size = min(position_size, self.capital * 0.3)  # Max 30% capital

        return {
            'leverage': leverage,
            'tp_pct': tp_pct,
            'sl_pct': sl_pct,
            'position_size': position_size
        }

    def detect_entry_signal(self, df, i, regime):
        """Détecte signal d'entrée adaptatif"""

        current = df.iloc[i]
        recent = df.iloc[max(0, i-50):i]

        # SIGNAL 1: Volatility Expansion (marche toujours)
        current_range = current['high'] - current['low']
        avg_range = (recent['high'] - recent['low']).mean()

        volatility_expansion = current_range > avg_range * 1.5

        if not volatility_expansion:
            return None

        # SIGNAL 2: Direction
        # En UPTREND → préférer LONG
        # En DOWNTREND → préférer SHORT
        # En RANGING → prendre la direction de la bougie

        if regime['trend'] == 'UPTREND':
            if current['close'] > current['open']:  # Bougie verte
                side = 'LONG'
                confidence = 0.8
            else:
                return None  # Skip SHORT en uptrend
        elif regime['trend'] == 'DOWNTREND':
            if current['close'] < current['open']:  # Bougie rouge
                side = 'SHORT'
                confidence = 0.8
            else:
                return None  # Skip LONG en downtrend
        else:  # RANGING
            if current['close'] > current['open']:
                side = 'LONG'
            else:
                side = 'SHORT'
            confidence = 0.6

        # SIGNAL 3: Volume confirmation
        if regime['volume_ratio'] > 1.5:
            confidence += 0.1

        # Minimum confidence
        if confidence < 0.6:
            return None

        return {
            'side': side,
            'confidence': confidence
        }

    def should_exit(self, df, i, position, params):
        """Détermine si on doit sortir de position"""

        current = df.iloc[i]

        # TP/SL classiques
        if position['side'] == 'LONG':
            tp = position['entry'] * (1 + params['tp_pct']/100)
            sl = position['entry'] * (1 - params['sl_pct']/100)

            if current['close'] >= tp:
                return True, 'TP'
            if current['close'] <= sl:
                return True, 'SL'
        else:
            tp = position['entry'] * (1 - params['tp_pct']/100)
            sl = position['entry'] * (1 + params['sl_pct']/100)

            if current['close'] <= tp:
                return True, 'TP'
            if current['close'] >= sl:
                return True, 'SL'

        # TRAILING STOP adaptatif
        # Si en profit > 50% du TP, activer trailing
        if position['side'] == 'LONG':
            profit = (current['close'] - position['entry']) / position['entry']
            if profit > (params['tp_pct']/100) * 0.5:
                # Trailing à 30% du profit actuel
                trailing = position['entry'] + (current['close'] - position['entry']) * 0.7
                if current['close'] < trailing:
                    return True, 'TRAILING'
        else:
            profit = (position['entry'] - current['close']) / position['entry']
            if profit > (params['tp_pct']/100) * 0.5:
                trailing = position['entry'] - (position['entry'] - current['close']) * 0.7
                if current['close'] > trailing:
                    return True, 'TRAILING'

        return False, None

    def execute_trade(self, entry_signal, params, entry_price):
        """Ouvre une position"""
        self.position = {
            'entry': entry_price,
            'side': entry_signal['side'],
            'params': params,
            'confidence': entry_signal['confidence']
        }

    def close_trade(self, exit_price, exit_type):
        """Ferme la position"""
        if not self.position:
            return

        params = self.position['params']

        # Calculer PnL
        if self.position['side'] == 'LONG':
            pnl_pct = (exit_price - self.position['entry']) / self.position['entry']
        else:
            pnl_pct = (self.position['entry'] - exit_price) / self.position['entry']

        # Appliquer leverage
        pnl_pct *= params['leverage']

        # Frais
        pnl_pct -= 0.001

        # PnL en USD
        pnl_usd = params['position_size'] * pnl_pct
        self.capital += pnl_usd

        # Enregistrer
        self.trades.append({
            'entry': self.position['entry'],
            'exit': exit_price,
            'side': self.position['side'],
            'pnl_usd': pnl_usd,
            'pnl_pct': pnl_pct * 100,
            'won': pnl_usd > 0,
            'exit_type': exit_type,
            'leverage': params['leverage'],
            'confidence': self.position['confidence']
        })

        self.position = None

    def backtest(self, df):
        """Backtest le système adaptatif"""

        for i in range(100, len(df)):
            # Analyser marché
            regime = self.analyze_market_regime(df, i)
            if not regime:
                continue

            # Calculer params adaptatifs
            params = self.calculate_adaptive_params(regime)

            # Gérer position existante
            if self.position:
                should_exit, exit_type = self.should_exit(df, i, self.position, self.position['params'])
                if should_exit:
                    self.close_trade(df.iloc[i]['close'], exit_type)
                continue

            # Chercher nouvelle entrée
            entry_signal = self.detect_entry_signal(df, i, regime)
            if entry_signal:
                self.execute_trade(entry_signal, params, df.iloc[i]['close'])

        # Statistiques
        if not self.trades:
            return None

        wins = [t for t in self.trades if t['won']]
        losses = [t for t in self.trades if not t['won']]

        total_return = ((self.capital - self.initial_capital) / self.initial_capital) * 100
        win_rate = len(wins) / len(self.trades)

        avg_win = np.mean([t['pnl_pct'] for t in wins]) if wins else 0
        avg_loss = np.mean([t['pnl_pct'] for t in losses]) if losses else 0

        profit_factor = abs(sum([t['pnl_usd'] for t in wins]) / sum([t['pnl_usd'] for t in losses])) if losses else 999

        # Max DD
        peak = self.initial_capital
        max_dd = 0
        running_capital = self.initial_capital

        for trade in self.trades:
            running_capital += trade['pnl_usd']
            if running_capital > peak:
                peak = running_capital
            dd = ((peak - running_capital) / peak) * 100
            if dd > max_dd:
                max_dd = dd

        return {
            'roi': total_return,
            'capital': self.capital,
            'trades': len(self.trades),
            'win_rate': win_rate,
            'avg_win': avg_win,
            'avg_loss': avg_loss,
            'profit_factor': profit_factor,
            'max_dd': max_dd
        }

# ============ TESTS ============

print("=" * 80)
print("🧠 SYSTÈME ADAPTATIF COMPLET - Test de Robustesse")
print("=" * 80)

backtester = MartingaleBacktester(
    initial_capital=1000.0,
    trading_fee_pct=0.0005,
    timeout_minutes=60
)

# ============ TEST 1: Multi-Symbol ============

print("\n📊 TEST 1: MULTI-SYMBOL (Robustesse)")
print("=" * 80)

symbols = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT']
timeframes = ['1h', '4h']

results = []

for symbol in symbols:
    for tf in timeframes:
        print(f"\n🧪 Test {symbol} {tf}...", end=" ")

        df = backtester.fetch_binance_data(symbol, tf, 500)

        if df is None:
            print("❌")
            continue

        system = AdaptiveSystem(initial_capital=1000)
        result = system.backtest(df)

        if result:
            result['symbol'] = symbol
            result['timeframe'] = tf
            results.append(result)
            print(f"✅ ROI: {result['roi']:+.2f}% | WR: {result['win_rate']*100:.1f}% | Trades: {result['trades']}")
        else:
            print("❌ Aucun trade")

# ============ TEST 2: Walk-Forward (Out-of-Sample) ============

print("\n\n📊 TEST 2: WALK-FORWARD VALIDATION (Anti-Overfitting)")
print("=" * 80)

# Test sur ETH 1h avec plusieurs périodes
df_full = backtester.fetch_binance_data('ETHUSDT', '1h', 1000)

if df_full is not None:
    # Split en 3 périodes
    n = len(df_full)
    period1 = df_full.iloc[:n//3]
    period2 = df_full.iloc[n//3:2*n//3]
    period3 = df_full.iloc[2*n//3:]

    for idx, period_df in enumerate([period1, period2, period3], 1):
        print(f"\n   Période {idx} ({len(period_df)} bougies)...", end=" ")

        system = AdaptiveSystem(initial_capital=1000)
        result = system.backtest(period_df)

        if result:
            result['symbol'] = 'ETHUSDT'
            result['timeframe'] = '1h'
            result['period'] = idx
            results.append(result)
            print(f"ROI: {result['roi']:+.2f}% | WR: {result['win_rate']*100:.1f}%")

# ============ RÉSULTATS ============

print("\n\n" + "=" * 80)
print("🏆 RÉSULTATS SYSTÈME ADAPTATIF")
print("=" * 80)

if not results:
    print("\n❌ Aucun résultat!")
    exit(1)

results.sort(key=lambda x: x['roi'], reverse=True)

print(f"\n{'Symbol':<10} {'TF':<5} {'ROI%':>8} {'WR%':>6} {'PF':>6} {'Trades':>7} {'DD%':>7} {'Status':<3}")
print("-" * 70)

for res in results:
    status = "✅" if res['roi'] > 10 else "⚠️" if res['roi'] > 0 else "❌"
    symbol = res.get('symbol', 'N/A')
    tf = res.get('timeframe', 'N/A')

    print(f"{symbol:<10} {tf:<5} {res['roi']:>7.2f}% {res['win_rate']*100:>5.1f}% "
          f"{res['profit_factor']:>6.2f} {res['trades']:>7} {res['max_dd']:>6.2f}% {status}")

# Stats globales
profitable = [r for r in results if r['roi'] > 0]
avg_roi = np.mean([r['roi'] for r in results])
avg_roi_profitable = np.mean([r['roi'] for r in profitable]) if profitable else 0

print(f"\n📈 STATISTIQUES GLOBALES:")
print(f"   Tests effectués:     {len(results)}")
print(f"   Tests profitables:   {len(profitable)} ({len(profitable)/len(results)*100:.1f}%)")
print(f"   ROI moyen:           {avg_roi:+.2f}%")
print(f"   ROI moyen (profit):  {avg_roi_profitable:+.2f}%")

# Meilleur
if results:
    best = results[0]
    print(f"\n🥇 MEILLEUR RÉSULTAT:")
    print(f"   {best.get('symbol', 'N/A')} {best.get('timeframe', 'N/A')}")
    print(f"   ROI: {best['roi']:+.2f}%")
    print(f"   WR:  {best['win_rate']*100:.1f}%")

# Cohérence (anti-overfitting check)
std_roi = np.std([r['roi'] for r in results])
print(f"\n🎯 COHÉRENCE (Anti-Overfitting):")
print(f"   Écart-type ROI: {std_roi:.2f}%")

if std_roi < 10:
    print(f"   ✅ SYSTÈME COHÉRENT (faible variance)")
elif std_roi < 20:
    print(f"   ⚠️  Variance modérée")
else:
    print(f"   ❌ Variance élevée - possiblement overfitté")

# Sauvegarder
with open('adaptive_system_results.json', 'w') as f:
    json.dump(results, f, indent=2, default=str)

print(f"\n💾 Résultats: adaptive_system_results.json")

print(f"\n{'=' * 80}")
if avg_roi > 5 and len(profitable)/len(results) > 0.6:
    print("✅ SYSTÈME ROBUSTE ET PROFITABLE!")
elif avg_roi > 0:
    print("⚠️  Système légèrement profitable mais peut être amélioré")
else:
    print("❌ Système non profitable")
print(f"{'=' * 80}")