//+------------------------------------------------------------------+
//| AdvancedRegimeDetector.mqh                                       |
//| Sophisticated regime detection with ADX/ATR/HHLL classification  |
//+------------------------------------------------------------------+
#property copyright "DualEA Advanced Regime System"
#property version   "1.00"

//+------------------------------------------------------------------+
//| REGIME TYPES ENUM                                                |
//+------------------------------------------------------------------+
enum ENUM_REGIME_TYPE
{
    REGIME_TRENDING_UP,      // Strong upward trend
    REGIME_TRENDING_DOWN,    // Strong downward trend
    REGIME_RANGING_LOW,      // Low volatility range
    REGIME_RANGING_HIGH,     // High volatility range
    REGIME_VOLATILE_UP,      // Volatile upward movement
    REGIME_VOLATILE_DOWN,    // Volatile downward movement
    REGIME_CHOPPY,           // Choppy/noisy market
    REGIME_BREAKING_UP,      // Breaking out upward
    REGIME_BREAKING_DOWN,    // Breaking out downward
    REGIME_UNDEFINED         // Undefined/transition
};

//+------------------------------------------------------------------+
//| REGIME INDICATORS STRUCT                                         |
//+------------------------------------------------------------------+
struct SRegimeIndicators
{
    double adx_value;           // ADX value
    double adx_plus;            // ADX+ value
    double adx_minus;           // ADX- value
    double atr_value;           // ATR value
    double atr_percentile;      // ATR percentile (0-100)
    double hhll_range;          // High-Low range
    double avg_true_range;      // Average true range
    double volatility_percentile; // Volatility percentile
    double trend_strength;      // Trend strength (0-1)
    double range_strength;      // Range strength (0-1)
    double breakout_strength;   // Breakout strength (0-1)
    
    SRegimeIndicators() : 
        adx_value(0), adx_plus(0), adx_minus(0), atr_value(0), atr_percentile(0),
        hhll_range(0), avg_true_range(0), volatility_percentile(0), 
        trend_strength(0), range_strength(0), breakout_strength(0) {}
};

//+------------------------------------------------------------------+
//| REGIME RESULT STRUCT                                             |
//+------------------------------------------------------------------+
struct SRegimeResult
{
    ENUM_REGIME_TYPE current_regime;
    ENUM_REGIME_TYPE previous_regime;
    double confidence;          // Confidence level (0-1)
    string description;         // Human-readable description
    datetime timestamp;         // Regime timestamp
    int duration_bars;          // Duration in bars
    SRegimeIndicators indicators; // Supporting indicators
    
    SRegimeResult() : 
        current_regime(REGIME_UNDEFINED), previous_regime(REGIME_UNDEFINED),
        confidence(0), duration_bars(0), timestamp(0) {}
};

//+------------------------------------------------------------------+
//| ADVANCED REGIME DETECTOR CLASS                                   |
//+------------------------------------------------------------------+
class CAdvancedRegimeDetector
{
private:
    string m_symbol;
    int m_timeframe;
    int m_adx_period;
    int m_atr_period;
    int m_hhll_period;
    int m_lookback_bars;
    
    // Historical data
    double m_adx_buffer[];
    double m_atr_buffer[];
    double m_high_buffer[];
    double m_low_buffer[];
    double m_close_buffer[];
    
    // Thresholds
    double m_adx_trend_threshold;
    double m_adx_strong_trend_threshold;
    double m_atr_high_threshold;
    double m_atr_low_threshold;
    double m_volatility_percentile_high;
    double m_volatility_percentile_low;
    
    // State tracking
    SRegimeResult m_last_regime;
    int m_regime_duration;
    
public:
    CAdvancedRegimeDetector(const string symbol, const int timeframe);
    ~CAdvancedRegimeDetector();
    
    // Configuration
    void SetADXPeriod(const int period) { m_adx_period = period; }
    void SetATRPeriod(const int period) { m_atr_period = period; }
    void SetHHLLPeriod(const int period) { m_hhll_period = period; }
    void SetLookbackBars(const int bars) { m_lookback_bars = bars; }
    void SetADXThresholds(const double trend, const double strong) 
    { 
        m_adx_trend_threshold = trend; 
        m_adx_strong_trend_threshold = strong; 
    }
    void SetATRThresholds(const double high, const double low)
    {
        m_atr_high_threshold = high;
        m_atr_low_threshold = low;
    }
    void SetVolatilityThresholds(const double high, const double low)
    {
        m_volatility_percentile_high = high;
        m_volatility_percentile_low = low;
    }
    
    // Main detection methods
    SRegimeResult DetectCurrentRegime();
    SRegimeResult GetLastRegime() const { return m_last_regime; }
    
    // Indicator calculations
    double CalculateADX(const int shift = 0);
    double CalculateATR(const int shift = 0);
    double CalculateHHLLRange(const int shift = 0);
    double CalculateVolatilityPercentile(const int bars);
    double CalculateTrendStrength();
    double CalculateRangeStrength();
    double CalculateBreakoutStrength();
    
    // Utility methods
    string RegimeToString(const ENUM_REGIME_TYPE regime) const;
    ENUM_REGIME_TYPE DetermineRegime(const SRegimeIndicators& indicators);
    double CalculateRegimeConfidence(const ENUM_REGIME_TYPE regime, const SRegimeIndicators& indicators);
    
private:
    void UpdatePriceBuffers();
    void CalculateIndicators(SRegimeIndicators& indicators);
    bool IsTrending(const SRegimeIndicators& indicators);
    bool IsRanging(const SRegimeIndicators& indicators);
    bool IsVolatile(const SRegimeIndicators& indicators);
    bool IsBreakingOut(const SRegimeIndicators& indicators);
    bool IsChoppy(const SRegimeIndicators& indicators);
};

//+------------------------------------------------------------------+
//| CONSTRUCTOR                                                      |
//+------------------------------------------------------------------+
CAdvancedRegimeDetector::CAdvancedRegimeDetector(const string symbol, const int timeframe)
{
    m_symbol = symbol;
    m_timeframe = timeframe;
    
    // Default parameters
    m_adx_period = 14;
    m_atr_period = 14;
    m_hhll_period = 20;
    m_lookback_bars = 100;
    
    // Default thresholds
    m_adx_trend_threshold = 25.0;
    m_adx_strong_trend_threshold = 35.0;
    m_atr_high_threshold = 2.0;
    m_atr_low_threshold = 0.5;
    m_volatility_percentile_high = 75.0;
    m_volatility_percentile_low = 25.0;
    
    m_regime_duration = 0;
    m_last_regime.current_regime = REGIME_UNDEFINED;
    m_last_regime.timestamp = 0;
    
    ArrayResize(m_adx_buffer, m_lookback_bars);
    ArrayResize(m_atr_buffer, m_lookback_bars);
    ArrayResize(m_high_buffer, m_lookback_bars);
    ArrayResize(m_low_buffer, m_lookback_bars);
    ArrayResize(m_close_buffer, m_lookback_bars);
    
    ArrayInitialize(m_adx_buffer, 0);
    ArrayInitialize(m_atr_buffer, 0);
    ArrayInitialize(m_high_buffer, 0);
    ArrayInitialize(m_low_buffer, 0);
    ArrayInitialize(m_close_buffer, 0);
}

//+------------------------------------------------------------------+
//| DESTRUCTOR                                                       |
//+------------------------------------------------------------------+
CAdvancedRegimeDetector::~CAdvancedRegimeDetector()
{
    // Cleanup handled automatically
}

//+------------------------------------------------------------------+
//| DETECT CURRENT REGIME                                            |
//+------------------------------------------------------------------+
SRegimeResult CAdvancedRegimeDetector::DetectCurrentRegime()
{
    SRegimeResult result;
    result.timestamp = TimeCurrent();
    result.previous_regime = m_last_regime.current_regime;
    
    // Update price buffers
    UpdatePriceBuffers();
    
    // Calculate indicators
    SRegimeIndicators indicators;
    CalculateIndicators(indicators);
    
    // Determine regime
    result.current_regime = DetermineRegime(indicators);
    result.confidence = CalculateRegimeConfidence(result.current_regime, indicators);
    result.description = RegimeToString(result.current_regime);
    result.indicators = indicators;
    
    // Update duration
    if(result.current_regime == result.previous_regime)
    {
        m_regime_duration++;
    }
    else
    {
        m_regime_duration = 1;
    }
    result.duration_bars = m_regime_duration;
    
    // Store result
    m_last_regime = result;
    
    return result;
}

//+------------------------------------------------------------------+
//| UPDATE PRICE BUFFERS                                             |
//+------------------------------------------------------------------+
void CAdvancedRegimeDetector::UpdatePriceBuffers()
{
    // Shift arrays
    for(int i = m_lookback_bars - 1; i > 0; i--)
    {
        m_high_buffer[i] = m_high_buffer[i-1];
        m_low_buffer[i] = m_low_buffer[i-1];
        m_close_buffer[i] = m_close_buffer[i-1];
    }
    
    // Add latest data
    m_high_buffer[0] = iHigh(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, 0);
    m_low_buffer[0]  = iLow(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, 0);
    m_close_buffer[0]= iClose(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, 0);
}

//+------------------------------------------------------------------+
//| CALCULATE INDICATORS                                             |
//+------------------------------------------------------------------+
void CAdvancedRegimeDetector::CalculateIndicators(SRegimeIndicators& indicators)
{
    // Calculate ADX
    indicators.adx_value = CalculateADX();
    {
        int adx_handle = iADX(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, m_adx_period);
        if(adx_handle != INVALID_HANDLE)
        {
            double plus[1], minus[1];
            if(CopyBuffer(adx_handle, 1 /*PLUSDI*/, 0, 1, plus) > 0) indicators.adx_plus = plus[0];
            if(CopyBuffer(adx_handle, 2 /*MINUSDI*/, 0, 1, minus) > 0) indicators.adx_minus = minus[0];
        }
    }
    
    // Calculate ATR
    indicators.atr_value = CalculateATR();
    indicators.avg_true_range = indicators.atr_value;
    
    // Calculate HHLL range
    indicators.hhll_range = CalculateHHLLRange();
    
    // Calculate percentiles
    indicators.atr_percentile = CalculateVolatilityPercentile(m_lookback_bars);
    indicators.volatility_percentile = indicators.atr_percentile;
    
    // Calculate strengths
    indicators.trend_strength = CalculateTrendStrength();
    indicators.range_strength = CalculateRangeStrength();
    indicators.breakout_strength = CalculateBreakoutStrength();
}

//+------------------------------------------------------------------+
//| CALCULATE ADX                                                    |
//+------------------------------------------------------------------+
double CAdvancedRegimeDetector::CalculateADX(const int shift)
{
    int handle = iADX(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, m_adx_period);
    if(handle == INVALID_HANDLE) return 0.0;
    double buf[1];
    if(CopyBuffer(handle, 0 /*MAIN*/, shift, 1, buf) <= 0) return 0.0;
    return buf[0];
}

//+------------------------------------------------------------------+
//| CALCULATE ATR                                                    |
//+------------------------------------------------------------------+
double CAdvancedRegimeDetector::CalculateATR(const int shift)
{
    int handle = iATR(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, m_atr_period);
    if(handle == INVALID_HANDLE) return 0.0;
    double buf[1];
    if(CopyBuffer(handle, 0, shift, 1, buf) <= 0) return 0.0;
    return buf[0];
}

//+------------------------------------------------------------------+
//| CALCULATE HHLL RANGE                                             |
//+------------------------------------------------------------------+
double CAdvancedRegimeDetector::CalculateHHLLRange(const int shift)
{
    int hi_index = iHighest(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, MODE_HIGH, m_hhll_period, shift);
    int lo_index = iLowest(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, MODE_LOW, m_hhll_period, shift);
    double highest = iHigh(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, hi_index);
    double lowest  = iLow(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, lo_index);
    return highest - lowest;
}

//+------------------------------------------------------------------+
//| CALCULATE VOLATILITY PERCENTILE                                  |
//+------------------------------------------------------------------+
double CAdvancedRegimeDetector::CalculateVolatilityPercentile(const int bars)
{
    if(bars <= 0) return 50.0;
    
    double atr_values[];
    ArrayResize(atr_values, bars);
    
    for(int i = 0; i < bars; i++)
    {
        int h = iATR(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, m_atr_period);
        if(h == INVALID_HANDLE) { atr_values[i] = 0.0; continue; }
        double b[1];
        if(CopyBuffer(h, 0, i, 1, b) <= 0) atr_values[i] = 0.0; else atr_values[i] = b[0];
    }
    
    double current_atr = atr_values[0];
    double percentile = 0;
    
    for(int i = 0; i < bars; i++)
    {
        if(atr_values[i] <= current_atr)
            percentile++;
    }
    
    return (percentile / bars) * 100.0;
}

//+------------------------------------------------------------------+
//| CALCULATE TREND STRENGTH                                         |
//+------------------------------------------------------------------+
double CAdvancedRegimeDetector::CalculateTrendStrength()
{
    double adx = CalculateADX();
    
    // Normalize ADX to 0-1 range
    if(adx >= m_adx_strong_trend_threshold)
        return 1.0;
    else if(adx <= m_adx_trend_threshold)
        return 0.0;
    else
        return (adx - m_adx_trend_threshold) / (m_adx_strong_trend_threshold - m_adx_trend_threshold);
}

//+------------------------------------------------------------------+
//| CALCULATE RANGE STRENGTH                                         |
//+------------------------------------------------------------------+
double CAdvancedRegimeDetector::CalculateRangeStrength()
{
    double atr_percentile = CalculateVolatilityPercentile(m_lookback_bars);
    
    // Lower volatility suggests ranging
    if(atr_percentile <= m_volatility_percentile_low)
        return 1.0;
    else if(atr_percentile >= m_volatility_percentile_high)
        return 0.0;
    else
        return 1.0 - ((atr_percentile - m_volatility_percentile_low) / 
                     (m_volatility_percentile_high - m_volatility_percentile_low));
}

//+------------------------------------------------------------------+
//| CALCULATE BREAKOUT STRENGTH                                      |
//+------------------------------------------------------------------+
double CAdvancedRegimeDetector::CalculateBreakoutStrength()
{
    double atr_percentile = CalculateVolatilityPercentile(m_lookback_bars);
    double adx = CalculateADX();
    
    // High volatility + strong trend = breakout
    double volatility_factor = (atr_percentile - m_volatility_percentile_low) / 
                              (m_volatility_percentile_high - m_volatility_percentile_low);
    
    double trend_factor = CalculateTrendStrength();
    
    return MathMin(1.0, volatility_factor * trend_factor);
}

//+------------------------------------------------------------------+
//| DETERMINE REGIME                                                 |
//+------------------------------------------------------------------+
ENUM_REGIME_TYPE CAdvancedRegimeDetector::DetermineRegime(const SRegimeIndicators& indicators)
{
    // Check for undefined regime
    if(indicators.adx_value < 0 || indicators.atr_value <= 0)
        return REGIME_UNDEFINED;
    
    // Check for trending conditions
    bool is_trending = IsTrending(indicators);
    bool is_ranging = IsRanging(indicators);
    bool is_volatile = IsVolatile(indicators);
    bool is_breaking_out = IsBreakingOut(indicators);
    bool is_choppy = IsChoppy(indicators);
    
    // Determine regime based on conditions
    if(is_breaking_out && indicators.breakout_strength > 0.7)
    {
        if(indicators.adx_plus > indicators.adx_minus)
            return REGIME_BREAKING_UP;
        else
            return REGIME_BREAKING_DOWN;
    }
    
    if(is_trending && indicators.trend_strength > 0.8)
    {
        if(indicators.adx_plus > indicators.adx_minus)
            return REGIME_TRENDING_UP;
        else
            return REGIME_TRENDING_DOWN;
    }
    
    if(is_volatile && indicators.volatility_percentile > 75)
    {
        if(indicators.adx_plus > indicators.adx_minus)
            return REGIME_VOLATILE_UP;
        else
            return REGIME_VOLATILE_DOWN;
    }
    
    if(is_ranging && indicators.range_strength > 0.7)
    {
        if(indicators.volatility_percentile < 25)
            return REGIME_RANGING_LOW;
        else
            return REGIME_RANGING_HIGH;
    }
    
    if(is_choppy)
    {
        return REGIME_CHOPPY;
    }
    
    return REGIME_UNDEFINED;
}

//+------------------------------------------------------------------+
//| CHECK IF TRENDING                                                |
//+------------------------------------------------------------------+
bool CAdvancedRegimeDetector::IsTrending(const SRegimeIndicators& indicators)
{
    return indicators.adx_value >= m_adx_trend_threshold;
}

//+------------------------------------------------------------------+
//| CHECK IF RANGING                                                 |
//+------------------------------------------------------------------+
bool CAdvancedRegimeDetector::IsRanging(const SRegimeIndicators& indicators)
{
    return indicators.adx_value < m_adx_trend_threshold && 
           indicators.volatility_percentile <= m_volatility_percentile_high;
}

//+------------------------------------------------------------------+
//| CHECK IF VOLATILE                                                |
//+------------------------------------------------------------------+
bool CAdvancedRegimeDetector::IsVolatile(const SRegimeIndicators& indicators)
{
    return indicators.volatility_percentile > m_volatility_percentile_high;
}

//+------------------------------------------------------------------+
//| CHECK IF BREAKING OUT                                            |
//+------------------------------------------------------------------+
bool CAdvancedRegimeDetector::IsBreakingOut(const SRegimeIndicators& indicators)
{
    return indicators.breakout_strength > 0.6 && 
           indicators.adx_value >= m_adx_strong_trend_threshold;
}

//+------------------------------------------------------------------+
//| CHECK IF CHOPPY                                                  |
//+------------------------------------------------------------------+
bool CAdvancedRegimeDetector::IsChoppy(const SRegimeIndicators& indicators)
{
    return indicators.adx_value < m_adx_trend_threshold && 
           indicators.volatility_percentile > m_volatility_percentile_low &&
           indicators.volatility_percentile < m_volatility_percentile_high;
}

//+------------------------------------------------------------------+
//| CALCULATE REGIME CONFIDENCE                                      |
//+------------------------------------------------------------------+
double CAdvancedRegimeDetector::CalculateRegimeConfidence(const ENUM_REGIME_TYPE regime, 
                                                         const SRegimeIndicators& indicators)
{
    double confidence = 0.0;
    
    switch(regime)
    {
        case REGIME_TRENDING_UP:
        case REGIME_TRENDING_DOWN:
            confidence = indicators.trend_strength;
            break;
            
        case REGIME_RANGING_LOW:
        case REGIME_RANGING_HIGH:
            confidence = indicators.range_strength;
            break;
            
        case REGIME_VOLATILE_UP:
        case REGIME_VOLATILE_DOWN:
            confidence = indicators.volatility_percentile / 100.0;
            break;
            
        case REGIME_BREAKING_UP:
        case REGIME_BREAKING_DOWN:
            confidence = indicators.breakout_strength;
            break;
            
        case REGIME_CHOPPY:
            confidence = 0.5; // Medium confidence for choppy
            break;
            
        default:
            confidence = 0.0;
            break;
    }
    
    return MathMin(1.0, MathMax(0.0, confidence));
}

//+------------------------------------------------------------------+
//| REGIME TO STRING                                                 |
//+------------------------------------------------------------------+
string CAdvancedRegimeDetector::RegimeToString(const ENUM_REGIME_TYPE regime) const
{
    switch(regime)
    {
        case REGIME_TRENDING_UP:     return "TRENDING_UP";
        case REGIME_TRENDING_DOWN:   return "TRENDING_DOWN";
        case REGIME_RANGING_LOW:     return "RANGING_LOW";
        case REGIME_RANGING_HIGH:    return "RANGING_HIGH";
        case REGIME_VOLATILE_UP:     return "VOLATILE_UP";
        case REGIME_VOLATILE_DOWN:   return "VOLATILE_DOWN";
        case REGIME_CHOPPY:          return "CHOPPY";
        case REGIME_BREAKING_UP:     return "BREAKING_UP";
        case REGIME_BREAKING_DOWN:   return "BREAKING_DOWN";
        case REGIME_UNDEFINED:       return "UNDEFINED";
        default:                     return "UNKNOWN";
    }
}