#!/usr/bin/env python3
"""
SYSTÈME OPTIMISÉ V3 - Approche Conservatrice

Optimisation UNIQUE et ciblée:
✅ Resserrer SL (seule vraie faiblesse: -43% avg loss)
❌ Garder seuil 2.0 confirmations (pas 2.5 = trop strict)
❌ Garder SHORT (équilibrage nécessaire)
✅ Améliorer profit locking (trailing stop plus agressif)
"""

import pandas as pd
import numpy as np
from hybrid_system import HybridSystem
from martingale_backtester import MartingaleBacktester
import json

class OptimizedSystemV3(HybridSystem):
    """Version hybride avec SL optimisé uniquement"""

    def calculate_adaptive_params(self, regime):
        """Params adaptatifs avec SL RESSERRÉ"""

        # LEVERAGE: Identique au baseline
        if regime['atr_pct'] > 2.0:
            base_leverage = 10
        elif regime['atr_pct'] > 1.0:
            base_leverage = 20
        elif regime['atr_pct'] > 0.5:
            base_leverage = 30
        else:
            base_leverage = 40

        if regime['volume_ratio'] > 2.0:
            leverage = int(base_leverage * 1.2)
        elif regime['volume_ratio'] < 0.5:
            leverage = int(base_leverage * 0.7)
        else:
            leverage = base_leverage

        leverage = min(leverage, 50)

        # TP/SL: SL RÉDUIT (seule optimisation)
        tp_pct = regime['atr_pct'] * 2.0
        sl_pct = regime['atr_pct'] * 0.8  # RÉDUIT de 1.0 à 0.8 (20% plus serré)

        # Limites
        tp_pct = max(0.5, min(tp_pct, 5.0))
        sl_pct = max(0.3, min(sl_pct, 2.5))  # Max 2.5%

        # POSITION SIZE
        if self.consecutive_losses >= 2:
            risk_pct = 0.01
        else:
            risk_pct = 0.02

        risk_amount = self.capital * risk_pct
        position_size = risk_amount / (sl_pct/100 * leverage)
        position_size = min(position_size, self.capital * 0.3)

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

    def should_exit(self, df, i, position, params):
        """Exit avec TRAILING STOP plus agressif"""

        current = df.iloc[i]

        # TP/SL standards
        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'

            # TRAILING STOP: Plus agressif - lock profits plus tôt
            profit = (current['close'] - position['entry']) / position['entry']
            if profit > (params['tp_pct']/100) * 0.4:  # À 40% du TP (vs 50%)
                trailing = position['entry'] + (current['close'] - position['entry']) * 0.8  # Lock 80% (vs 70%)
                if current['close'] < trailing:
                    return True, 'TRAILING'

        else:  # SHORT
            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'

            profit = (position['entry'] - current['close']) / position['entry']
            if profit > (params['tp_pct']/100) * 0.4:
                trailing = position['entry'] - (position['entry'] - current['close']) * 0.8
                if current['close'] > trailing:
                    return True, 'TRAILING'

        return False, None

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

print("=" * 80)
print("🎯 SYSTÈME OPTIMISÉ V3 - Conservative")
print("=" * 80)
print("\nOptimisations ciblées:")
print("  ✅ SL resserré (0.8x ATR vs 1.0x)")
print("  ✅ Trailing stop plus agressif (lock 80% à 40% TP)")
print("  ⚠️  Garder seuil 2.0 confirmations (équilibre)")
print("  ⚠️  Garder SHORT (diversification)")

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

print("\n📊 Test BTC 4h - Walk-Forward Validation:\n")
print("📥 Téléchargement...")
df_full = backtester.fetch_binance_data('BTCUSDT', '4h', 1000)

if df_full is None:
    exit(1)

# Split en 3
n = len(df_full)
periods = [
    ("P1 (Mai-Juil)", df_full.iloc[:n//3]),
    ("P2 (Juil-Sep)", df_full.iloc[n//3:2*n//3]),
    ("P3 (Sep-Nov)", df_full.iloc[2*n//3:])
]

results = []

for name, period_df in periods:
    print(f"🧪 {name}...", end=" ")

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

    if result:
        results.append(result)
        status = "✅" if result['roi'] > 15 else "⚠️" if result['roi'] > 10 else "🔵"
        print(f"{status} ROI: {result['roi']:+.2f}% | WR: {result['win_rate']*100:.1f}% | Trades: {result['trades']} | PF: {result['profit_factor']:.2f}")
    else:
        print(f"❌ Aucun trade")

# Stats
print("\n" + "=" * 80)
print("📊 COMPARAISON vs BASELINE")
print("=" * 80)

if results:
    rois = [r['roi'] for r in results]
    wrs = [r['win_rate'] for r in results]
    pfs = [r['profit_factor'] for r in results]
    trades_counts = [r['trades'] for r in results]

    avg_roi_v3 = np.mean(rois)
    std_roi_v3 = np.std(rois)
    avg_wr_v3 = np.mean(wrs)
    avg_pf_v3 = np.mean(pfs)
    avg_trades = np.mean(trades_counts)

    # Baseline
    baseline_roi = 17.14
    baseline_std = 4.08
    baseline_wr = 0.571
    baseline_pf = 2.26
    baseline_trades = 10

    print(f"\n{'Métrique':<20} {'Baseline':>12} {'V3 Optimisé':>12} {'Delta':>10}")
    print("-" * 65)
    print(f"{'ROI moyen':<20} {baseline_roi:>11.2f}% {avg_roi_v3:>11.2f}% {avg_roi_v3-baseline_roi:>9.2f}%")
    print(f"{'Écart-type ROI':<20} {baseline_std:>11.2f}% {std_roi_v3:>11.2f}% {std_roi_v3-baseline_std:>9.2f}%")
    print(f"{'Win Rate moyen':<20} {baseline_wr*100:>11.1f}% {avg_wr_v3*100:>11.1f}% {(avg_wr_v3-baseline_wr)*100:>9.1f}%")
    print(f"{'Profit Factor moy':<20} {baseline_pf:>12.2f} {avg_pf_v3:>12.2f} {avg_pf_v3-baseline_pf:>10.2f}")
    print(f"{'Trades moyen':<20} {baseline_trades:>12.0f} {avg_trades:>12.0f} {avg_trades-baseline_trades:>10.0f}")

    # Verdict
    print(f"\n🎯 VERDICT:")

    roi_improvement = avg_roi_v3 - baseline_roi
    wr_improvement = avg_wr_v3 - baseline_wr
    std_improvement = baseline_std - std_roi_v3  # Positive = better (lower std)

    if avg_roi_v3 > baseline_roi * 1.1:
        print(f"   ✅ AMÉLIORATION SIGNIFICATIVE ROI (+{roi_improvement:.2f}%)")
    elif avg_roi_v3 > baseline_roi * 1.03:
        print(f"   ✅ Amélioration ROI (+{roi_improvement:.2f}%)")
    elif avg_roi_v3 > baseline_roi * 0.97:
        print(f"   ⚠️  Performance ROI similaire ({roi_improvement:+.2f}%)")
    else:
        print(f"   ❌ ROI inférieur ({roi_improvement:+.2f}%)")

    if avg_wr_v3 > baseline_wr + 0.05:
        print(f"   ✅ Win rate amélioré (+{wr_improvement*100:.1f}%)")
    elif avg_wr_v3 > baseline_wr + 0.02:
        print(f"   ✅ Légère amélioration win rate (+{wr_improvement*100:.1f}%)")

    if std_improvement > 0:
        print(f"   ✅ Variance réduite ({std_roi_v3:.2f}% vs {baseline_std:.2f}%)")

    if avg_pf_v3 > baseline_pf:
        print(f"   ✅ Profit Factor amélioré ({avg_pf_v3:.2f} vs {baseline_pf:.2f})")

    # Sharpe
    sharpe_baseline = baseline_roi / baseline_std
    sharpe_v3 = avg_roi_v3 / std_roi_v3 if std_roi_v3 > 0 else 0

    print(f"\n📊 SHARPE RATIO:")
    print(f"   Baseline: {sharpe_baseline:.2f}")
    print(f"   V3:       {sharpe_v3:.2f}")
    if sharpe_v3 > sharpe_baseline:
        print(f"   ✅ Meilleur risk-adjusted return")

    # Sauvegarder
    with open('optimized_v3_results.json', 'w') as f:
        json.dump({
            'periods': results,
            'stats': {
                'avg_roi': avg_roi_v3,
                'std_roi': std_roi_v3,
                'avg_win_rate': avg_wr_v3,
                'avg_profit_factor': avg_pf_v3,
                'sharpe': sharpe_v3
            },
            'comparison': {
                'roi_improvement': roi_improvement,
                'wr_improvement': wr_improvement,
                'sharpe_improvement': sharpe_v3 - sharpe_baseline
            }
        }, f, indent=2, default=str)

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

print("=" * 80)