#!/usr/bin/env python3
"""
MARKET DETECTOR SIMPLE - Détection cohérente avec V10 Range

Logique:
1. Utilise V10RangeDetector.is_range_market() (méthode optimisée +132% PnL)
2. Si RANGE détecté → MarketRegime.RANGE
3. Sinon → Compare bull_score vs bear_score

Cohérence totale avec la V10 Range Strategy déjà optimisée.
"""

import pandas as pd
from typing import Dict
from enum import Enum
from dataclasses import dataclass

from bull_strategy import BullDetector
from bear_strategy import BearDetector
from v10_range_strategy import V10RangeDetector


class MarketRegime(Enum):
    """Types de régimes de marché"""
    BULL = "BULL"
    BEAR = "BEAR"
    RANGE = "RANGE"
    UNCERTAIN = "UNCERTAIN"


@dataclass
class MarketAnalysis:
    """Analyse complète du marché"""
    regime: MarketRegime
    confidence: float  # 0-100
    bull_score: float  # 0-100
    bear_score: float  # 0-100
    range_score: float  # 0-100
    volatility: float  # ATR %
    reason: str


class MarketDetector:
    """
    Détecteur de régime simplifié et cohérent

    Priorités:
    1. RANGE (V10RangeDetector - déjà optimisé)
    2. BULL vs BEAR (sur zones non-RANGE)
    """

    def __init__(self):
        self.thresholds = {
            'min_bull_strength': 60,  # Score minimum pour BULL
            'min_bear_strength': 60,  # Score minimum pour BEAR
        }

    def detect(self, df: pd.DataFrame) -> MarketAnalysis:
        """
        Détecte le régime de marché avec méthode simple et cohérente

        Args:
            df: DataFrame avec OHLCV

        Returns:
            MarketAnalysis
        """
        if len(df) < 100:
            return MarketAnalysis(
                regime=MarketRegime.UNCERTAIN,
                confidence=0,
                bull_score=0,
                bear_score=0,
                range_score=0,
                volatility=0,
                reason="Données insuffisantes"
            )

        # 1. PRIORITÉ: Détecter RANGE avec V10RangeDetector (méthode optimisée)
        is_range = V10RangeDetector.is_range_market(df)

        # 2. Calculer volatilité
        tr1 = df['high'] - df['low']
        tr2 = abs(df['high'] - df['close'].shift())
        tr3 = abs(df['low'] - df['close'].shift())
        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
        atr = tr.rolling(14).mean().iloc[-1]
        price = df['close'].iloc[-1]
        volatility_pct = (atr / price) * 100

        # 3. Si RANGE → Utiliser V10 Range (déjà optimisée)
        if is_range:
            return MarketAnalysis(
                regime=MarketRegime.RANGE,
                confidence=100,
                bull_score=0,
                bear_score=0,
                range_score=100,
                volatility=volatility_pct,
                reason=f"RANGE V10 (ATR {volatility_pct:.2f}%, touches S/R confirmées)"
            )

        # 4. Pas RANGE → Calculer BULL vs BEAR
        bull_score = BullDetector.calculate_trend_strength(df)
        bear_score = BearDetector.calculate_trend_strength(df)

        # 5. Classifier BULL vs BEAR
        if bull_score >= self.thresholds['min_bull_strength'] and bull_score > bear_score:
            return MarketAnalysis(
                regime=MarketRegime.BULL,
                confidence=bull_score,
                bull_score=bull_score,
                bear_score=bear_score,
                range_score=0,
                volatility=volatility_pct,
                reason=f"Tendance BULL (score {bull_score:.0f} > {bear_score:.0f})"
            )

        elif bear_score >= self.thresholds['min_bear_strength'] and bear_score > bull_score:
            return MarketAnalysis(
                regime=MarketRegime.BEAR,
                confidence=bear_score,
                bull_score=bull_score,
                bear_score=bear_score,
                range_score=0,
                volatility=volatility_pct,
                reason=f"Tendance BEAR (score {bear_score:.0f} > {bull_score:.0f})"
            )

        else:
            # Scores trop faibles ou trop proches
            return MarketAnalysis(
                regime=MarketRegime.UNCERTAIN,
                confidence=max(bull_score, bear_score),
                bull_score=bull_score,
                bear_score=bear_score,
                range_score=0,
                volatility=volatility_pct,
                reason=f"Indécis (BULL {bull_score:.0f} vs BEAR {bear_score:.0f})"
            )


if __name__ == '__main__':
    print("🔍 Market Detector Simple - Cohérent avec V10 Range")
    print("=" * 80)
    print()
    print("Logique:")
    print("  1. V10RangeDetector.is_range_market() → RANGE")
    print("  2. Sinon: compare bull_score vs bear_score")
    print()
    print("Avantages:")
    print("  ✅ Cohérence totale avec V10 Range optimisée")
    print("  ✅ Même détection de RANGE partout")
    print("  ✅ Simple et clair")