import pandas as pd
import numpy as np
from typing import Dict, List, Optional
import warnings
import logging
warnings.filterwarnings('ignore')

class PEMAnalyzer:
    """
    Price Equation Model (PEM) Analyzer
    Based on PulseEquation EA logic: Polynomial Prediction + Trend Filter
    """
    def __init__(self):
        # Coefficients from MQL5 (g_coeffs)
        self.coeffs = [0.2752466, 0.01058082, 0.55162082, 0.03687016, 0.27721318, 0.1483476, 0.0008025]
        
    def predict_price(self, price_t1, price_t2):
        """
        Calculate predicted price using the polynomial equation
        """
        c = self.coeffs
        prediction = (c[0] * price_t1 +                    # Linear t-1
                      c[1] * (price_t1 ** 2) +             # Quadratic t-1
                      c[2] * price_t2 +                    # Linear t-2
                      c[3] * (price_t2 ** 2) +             # Quadratic t-2
                      c[4] * (price_t1 - price_t2) +       # Price change
                      c[5] * np.sin(price_t1) +            # Cyclic
                      c[6])                                # Constant
        return prediction

    def analyze(self, df: pd.DataFrame, ma_fast_period=108, ma_slow_period=60, adx_threshold=20) -> Dict[str, any]:
        if len(df) < max(ma_fast_period, ma_slow_period) + 5:
            return {"signal": "neutral", "strength": 0, "reason": "Insufficient Data"}
            
        # 1. Price Prediction
        # Get prices t-1 and t-2 (assuming df.iloc[-1] is current forming candle, so t-1 is -2)
        price_t1 = df['close'].iloc[-2]
        price_t2 = df['close'].iloc[-3]
        current_price = df['close'].iloc[-1] # Approximation of current Ask/Bid
        
        predicted_price = self.predict_price(price_t1, price_t2)
        
        # Raw Signal
        raw_signal = "neutral"
        if predicted_price > current_price:
            raw_signal = "buy"
        elif predicted_price < current_price:
            raw_signal = "sell"
            
        # 2. Trend Filter (ADX + MA)
        # Calculate MAs
        ma_fast = df['close'].rolling(window=ma_fast_period).mean().iloc[-2] # Completed candle
        ma_slow = df['close'].rolling(window=ma_slow_period).mean().iloc[-2]
        
        # Calculate ADX (simplified or reuse existing)
        adx = self._calculate_adx(df).iloc[-2]
        
        is_strong_trend = adx >= adx_threshold
        is_uptrend = ma_fast > ma_slow
        is_downtrend = ma_fast < ma_slow
        
        final_signal = "neutral"
        strength = 0
        reason = []
        
        if raw_signal == "buy":
            if is_strong_trend and is_uptrend:
                final_signal = "buy"
                strength = 85
                reason.append(f"PEM: Predicted {predicted_price:.4f} > Curr {current_price:.4f} + Strong Uptrend (ADX={adx:.1f})")
            else:
                reason.append(f"PEM: Raw Buy filtered (Trend mismatch)")
                
        elif raw_signal == "sell":
            if is_strong_trend and is_downtrend:
                final_signal = "sell"
                strength = 85
                reason.append(f"PEM: Predicted {predicted_price:.4f} < Curr {current_price:.4f} + Strong Downtrend (ADX={adx:.1f})")
            else:
                reason.append(f"PEM: Raw Sell filtered (Trend mismatch)")
                
        return {
            "signal": final_signal,
            "strength": strength,
            "reason": "; ".join(reason),
            "prediction": predicted_price,
            "adx": adx,
            "trend": "bullish" if is_uptrend else "bearish"
        }

    def _calculate_adx(self, df, period=14):
        highs = df['high']
        lows = df['low']
        closes = df['close']
        
        plus_dm = highs.diff()
        minus_dm = -lows.diff()
        plus_dm[plus_dm < 0] = 0
        minus_dm[minus_dm < 0] = 0
        
        tr1 = highs - lows
        tr2 = abs(highs - closes.shift())
        tr3 = abs(lows - closes.shift())
        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
        
        atr = tr.rolling(period).mean()
        plus_di = 100 * (plus_dm.rolling(period).mean() / atr)
        minus_di = 100 * (minus_dm.rolling(period).mean() / atr)
        
        dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)
        adx = dx.rolling(period).mean()
        return adx

class AdvancedMarketAnalysis:
    """
    高级市场分析工具类
    基于MQL5文章中的最佳实践，利用Python的Pandas和NumPy库
    提供更强大的技术分析和机器学习功能
    """
    
    def __init__(self):
        self.indicators_cache = {}
    
    def calculate_technical_indicators(self, df: pd.DataFrame) -> Dict[str, float]:
        if len(df) < 20:
            return self._get_default_indicators()
        
        indicators = {}
        # SMA
        indicators['sma_20'] = df['close'].tail(20).mean()
        indicators['sma_50'] = df['close'].tail(50).mean() if len(df) >= 50 else indicators['sma_20']
        
        # EMA
        indicators['ema_12'] = df['close'].ewm(span=12).mean().iloc[-1]
        indicators['ema_26'] = df['close'].ewm(span=26).mean().iloc[-1]
        
        # MACD
        ema_12 = df['close'].ewm(span=12).mean()
        ema_26 = df['close'].ewm(span=26).mean()
        macd_line = ema_12 - ema_26
        macd_signal = macd_line.ewm(span=9).mean()
        indicators['macd'] = macd_line.iloc[-1]
        indicators['macd_signal'] = macd_signal.iloc[-1]
        indicators['macd_histogram'] = indicators['macd'] - indicators['macd_signal']
        
        # RSI
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
        rs = gain / loss
        indicators['rsi'] = 100 - (100 / (1 + rs.iloc[-1])) if not pd.isna(loss.iloc[-1]) and loss.iloc[-1] != 0 else 50
        
        # Bollinger Bands
        bb_period = 20
        bb_std = 2
        sma = df['close'].rolling(window=bb_period).mean()
        std = df['close'].rolling(window=bb_period).std()
        indicators['bb_upper'] = sma.iloc[-1] + (std.iloc[-1] * bb_std)
        indicators['bb_lower'] = sma.iloc[-1] - (std.iloc[-1] * bb_std)
        indicators['bb_middle'] = sma.iloc[-1]
        
        # ATR
        high_low = df['high'] - df['low']
        high_close_prev = abs(df['high'] - df['close'].shift())
        low_close_prev = abs(df['low'] - df['close'].shift())
        true_range = pd.concat([high_low, high_close_prev, low_close_prev], axis=1).max(axis=1)
        indicators['atr'] = true_range.rolling(window=14).mean().iloc[-1]
        
        # Volume
        indicators['volume_sma'] = df['volume'].tail(20).mean()
        indicators['current_volume'] = df['volume'].iloc[-1]
        indicators['volume_ratio'] = indicators['current_volume'] / indicators['volume_sma'] if indicators['volume_sma'] > 0 else 1
        
        # Momentum
        indicators['momentum_5'] = (df['close'].iloc[-1] / df['close'].iloc[-6] - 1) * 100
        indicators['momentum_10'] = (df['close'].iloc[-1] / df['close'].iloc[-11] - 1) * 100
        
        return indicators
    
    def detect_market_regime(self, df: pd.DataFrame) -> Dict[str, any]:
        if len(df) < 50:
            return {"regime": "unknown", "confidence": 0.5, "description": "数据不足"}
        
        returns = df['close'].pct_change().dropna()
        volatility = returns.std() * np.sqrt(252)
        price_change = (df['close'].iloc[-1] / df['close'].iloc[0] - 1) * 100
        
        highs = df['high']
        lows = df['low']
        plus_dm = highs.diff()
        minus_dm = -lows.diff()
        plus_dm[plus_dm < 0] = 0
        minus_dm[minus_dm < 0] = 0
        tr = pd.concat([highs - lows, abs(highs - df['close'].shift()), abs(lows - df['close'].shift())], axis=1).max(axis=1)
        atr = tr.rolling(window=14).mean()
        plus_di = 100 * (plus_dm.rolling(window=14).mean() / atr)
        minus_di = 100 * (minus_dm.rolling(window=14).mean() / atr)
        dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)
        adx = dx.rolling(window=14).mean()
        current_adx = adx.iloc[-1] if not pd.isna(adx.iloc[-1]) else 0
        
        if volatility > 0.3:
            regime = "high_volatility"
            confidence = min(volatility / 0.5, 0.9)
            description = "高波动市场"
        elif current_adx > 25:
            regime = "trending"
            confidence = min(current_adx / 50, 0.9)
            description = "趋势市场"
        else:
            regime = "ranging"
            confidence = 0.7
            description = "震荡市场"
        
        return {"regime": regime, "confidence": confidence, "description": description, "volatility": volatility, "adx": current_adx, "price_change": price_change}
    
    def generate_support_resistance(self, df: pd.DataFrame, lookback_period: int = 100) -> Dict[str, List[float]]:
        if len(df) < lookback_period: lookback_period = len(df)
        recent_data = df.tail(lookback_period)
        recent_high = recent_data['high'].max()
        recent_low = recent_data['low'].min()
        price_range = recent_high - recent_low
        current_price = df['close'].iloc[-1]
        
        support_levels = []
        for i in range(1, 4):
            level = current_price - (price_range * 0.1 * i)
            if level > recent_low: support_levels.append(float(round(level, 4)))
            
        resistance_levels = []
        for i in range(1, 4):
            level = current_price + (price_range * 0.1 * i)
            if level < recent_high: resistance_levels.append(float(round(level, 4)))
            
        if not support_levels: support_levels = [float(round(recent_low, 4))]
        if not resistance_levels: resistance_levels = [float(round(recent_high, 4))]
        
        return {"support_levels": sorted(support_levels), "resistance_levels": sorted(resistance_levels), "current_price": current_price}
    
    def calculate_risk_metrics(self, df: pd.DataFrame) -> Dict[str, float]:
        if len(df) < 30: return self._get_default_risk_metrics()
        returns = df['close'].pct_change().dropna()
        metrics = {
            "volatility": returns.std() * np.sqrt(252),
            "sharpe_ratio": returns.mean() / returns.std() * np.sqrt(252) if returns.std() > 0 else 0,
            "max_drawdown": self._calculate_max_drawdown(df['close']),
            "var_95": np.percentile(returns, 5) * 100,
            "expected_shortfall": returns[returns <= np.percentile(returns, 5)].mean() * 100,
            "skewness": returns.skew(),
            "kurtosis": returns.kurtosis()
        }
        return metrics
        
    def _calculate_max_drawdown(self, prices: pd.Series) -> float:
        cumulative_returns = (1 + prices.pct_change()).cumprod()
        running_max = cumulative_returns.expanding().max()
        drawdown = (cumulative_returns - running_max) / running_max
        return drawdown.min() * 100
    
    def _get_default_indicators(self) -> Dict[str, float]:
        return {"sma_20": 0, "sma_50": 0, "ema_12": 0, "ema_26": 0, "macd": 0, "macd_signal": 0, "macd_histogram": 0, "rsi": 50, "bb_upper": 0, "bb_lower": 0, "bb_middle": 0, "atr": 0, "volume_sma": 0, "current_volume": 0, "volume_ratio": 1, "momentum_5": 0, "momentum_10": 0}
        
    def generate_signal_from_indicators(self, indicators: Dict[str, float]) -> Dict[str, any]:
        signal = "hold"; strength = 0; reasons = []
        if indicators['macd'] > indicators['macd_signal'] and indicators['macd_histogram'] > 0: strength += 25; reasons.append("MACD金叉")
        elif indicators['macd'] < indicators['macd_signal'] and indicators['macd_histogram'] < 0: strength -= 25; reasons.append("MACD死叉")
        if indicators['rsi'] < 30: strength += 20; reasons.append("RSI超卖")
        elif indicators['rsi'] > 70: strength -= 20; reasons.append("RSI超买")
        if indicators['ema_12'] > indicators['ema_26']: strength += 15; reasons.append("EMA金叉")
        elif indicators['ema_12'] < indicators['ema_26']: strength -= 15; reasons.append("EMA死叉")
        current_price = indicators.get('current_price', indicators['sma_20'])
        if current_price < indicators['bb_lower']: strength += 15; reasons.append("价格触及布林带下轨")
        elif current_price > indicators['bb_upper']: strength -= 15; reasons.append("价格触及布林带上轨")
        if indicators['volume_ratio'] > 1.5: strength += 10; reasons.append("成交量放大")
        
        if strength >= 40: signal = "buy"
        elif strength <= -40: signal = "sell"
        return {"signal": signal, "strength": abs(strength), "reasons": reasons, "confidence": min(abs(strength) / 100, 1.0)}

    def _get_default_risk_metrics(self) -> Dict[str, float]:
        return {"volatility": 0.2, "sharpe_ratio": 0, "max_drawdown": 0, "var_95": -2, "expected_shortfall": -3, "skewness": 0, "kurtosis": 0}

    def generate_analysis_summary(self, df: pd.DataFrame) -> Dict[str, any]:
        if len(df) < 20: return {"summary": "数据不足", "recommendation": "hold", "confidence": 0.0}
        indicators = self.calculate_technical_indicators(df)
        market_regime = self.detect_market_regime(df)
        risk_metrics = self.calculate_risk_metrics(df)
        support_resistance = self.generate_support_resistance(df)
        signal_info = self.generate_signal_from_indicators(indicators)
        current_price = df['close'].iloc[-1]
        
        recommendation = "持有"
        if signal_info['signal'] == 'buy': recommendation = "强烈买入" if signal_info['strength'] > 60 else "买入"
        elif signal_info['signal'] == 'sell': recommendation = "强烈卖出" if signal_info['strength'] > 60 else "卖出"
        
        return {
            "summary": f"当前价格: {current_price:.4f}",
            "market_regime": market_regime['description'],
            "recommendation": recommendation,
            "confidence": signal_info['confidence'],
            "risk_level": "高" if risk_metrics['volatility'] > 0.3 else "中",
            "key_indicators": {"RSI": f"{indicators['rsi']:.1f}", "MACD": f"{indicators['macd']:.4f}"},
            "support_levels": support_resistance['support_levels'],
            "resistance_levels": support_resistance['resistance_levels']
        }
    
    def analyze_ifvg(self, df: pd.DataFrame, min_gap_points: int = 100) -> Dict[str, any]:
        if len(df) < 5: return {"signal": "hold", "strength": 0, "reasons": [], "active_zones": []}
        lows = df['low'].values; highs = df['high'].values; closes = df['close'].values; times = df.index
        point = 1.0; min_gap = min_gap_points * point # For Crypto, points are different. Assuming 1.0 for now or passed value
        fvgs = []
        for i in range(2, len(df)):
            if lows[i] > highs[i-2] and (lows[i] - highs[i-2]) > min_gap:
                fvgs.append({'id': f"bull_{i}", 'type': 'bullish', 'top': lows[i], 'bottom': highs[i-2], 'start_time': times[i], 'mitigated': False, 'inverted': False, 'inverted_time': None})
            elif lows[i-2] > highs[i] and (lows[i-2] - highs[i]) > min_gap:
                fvgs.append({'id': f"bear_{i}", 'type': 'bearish', 'top': lows[i-2], 'bottom': highs[i], 'start_time': times[i], 'mitigated': False, 'inverted': False, 'inverted_time': None})
            
            current_low = lows[i]; current_high = highs[i]; current_close = closes[i]
            for fvg in fvgs:
                if fvg['inverted']: continue
                if not fvg['mitigated']:
                    if fvg['type'] == 'bullish' and current_low < fvg['bottom']: fvg['mitigated'] = True
                    elif fvg['type'] == 'bearish' and current_high > fvg['top']: fvg['mitigated'] = True
                if fvg['mitigated']:
                    if fvg['type'] == 'bullish' and current_close < fvg['bottom']: fvg['inverted'] = True; fvg['inverted_time'] = times[i]
                    elif fvg['type'] == 'bearish' and current_close > fvg['top']: fvg['inverted'] = True; fvg['inverted_time'] = times[i]
        
        last_time = times[-1]; signal = "hold"; strength = 0; reasons = []
        latest_inversions = [f for f in fvgs if f['inverted'] and f['inverted_time'] == last_time]
        for inv in latest_inversions:
            if inv['type'] == 'bearish': signal = "buy"; strength = 80; reasons.append("IFVG Bullish Inversion")
            elif inv['type'] == 'bullish': signal = "sell"; strength = 80; reasons.append("IFVG Bearish Inversion")
        
        return {"signal": signal, "strength": strength, "reasons": reasons, "active_zones": [f for f in fvgs if f['start_time'] > times[-50]]}

    def analyze_rvgi_cci_strategy(self, df: pd.DataFrame, sma_period: int = 30, cci_period: int = 14) -> Dict[str, any]:
        if len(df) < max(sma_period, cci_period) + 5: return {"signal": "hold", "strength": 0, "reasons": []}
        closes = df['close']; highs = df['high']; lows = df['low']; opens = df['open']
        sma = closes.rolling(window=sma_period).mean()
        tp = (highs + lows + closes) / 3
        sma_tp = tp.rolling(window=cci_period).mean()
        mad = tp.rolling(window=cci_period).apply(lambda x: np.mean(np.abs(x - np.mean(x))), raw=True).replace(0, 0.000001)
        cci = (tp - sma_tp) / (0.015 * mad)
        
        co = closes - opens; hl = highs - lows
        num_val = (co + 2 * co.shift(1) + 2 * co.shift(2) + co.shift(3)) / 6
        den_val = (hl + 2 * hl.shift(1) + 2 * hl.shift(2) + hl.shift(3)) / 6
        rvi_period = 10
        rvi_num = num_val.rolling(window=rvi_period).mean()
        rvi_den = den_val.rolling(window=rvi_period).mean().replace(0, 0.000001)
        rvi_main = (rvi_num / rvi_den).fillna(0)
        rvi_signal = ((rvi_main + 2 * rvi_main.shift(1) + 2 * rvi_main.shift(2) + rvi_main.shift(3)) / 6).fillna(0)
        
        curr = -1; prev = -2
        price = closes.iloc[curr]; sma_val = sma.iloc[curr]; cci_now = cci.iloc[curr]
        rvi_m_now = rvi_main.iloc[curr]; rvi_s_now = rvi_signal.iloc[curr]
        rvi_m_prev = rvi_main.iloc[prev]; rvi_s_prev = rvi_signal.iloc[prev]
        
        price_above_sma = price > sma_val; price_below_sma = price < sma_val
        rvi_cross_up = (rvi_m_prev <= rvi_s_prev) and (rvi_m_now > rvi_s_now)
        rvi_cross_down = (rvi_m_prev >= rvi_s_prev) and (rvi_m_now < rvi_s_now)
        cci_buy = cci_now <= -100; cci_sell = cci_now >= 100
        
        signal = "hold"; strength = 0; reasons = []
        if price_above_sma and cci_sell and rvi_cross_down: signal = "sell"; strength = 75; reasons.append("RVGI死叉+CCI超买+SMA之上")
        elif price_below_sma and cci_buy and rvi_cross_up: signal = "buy"; strength = 75; reasons.append("RVGI金叉+CCI超卖+SMA之下")
        
        return {"signal": signal, "strength": strength, "reasons": reasons, "indicators": {"sma": sma_val, "cci": cci_now}}

    def analyze_crt_strategy(self, df: pd.DataFrame, range_period: int = 15, confirm_period: int = 1, min_manipulation_pct: float = 5.0) -> Dict[str, any]:
        if len(df) < range_period + confirm_period + 5: return {"signal": "hold", "strength": 0, "reasons": []}
        prev_candle = df.iloc[-2]
        range_high = prev_candle['high']; range_low = prev_candle['low']
        range_open = prev_candle['open']; range_close = prev_candle['close']
        is_bullish_range = range_close > range_open
        
        current_candle = df.iloc[-1]
        current_high = current_candle['high']; current_low = current_candle['low']; current_close = current_candle['close']
        breakout = False; manipulation = False; manipulation_depth = 0.0
        range_size = range_high - range_low
        if range_size == 0: range_size = 0.0001
        
        signal = "hold"; strength = 0; reasons = []
        if is_bullish_range:
            if current_low < range_low:
                breakout = True; manipulation_depth = range_low - current_low
                pct = (manipulation_depth / range_size) * 100
                if current_close > range_low:
                    manipulation = True
                    if pct >= min_manipulation_pct: signal = "buy"; strength = 80; reasons.append(f"CRT Bullish: Downward Manipulation ({pct:.1f}%) & Reclaim")
        else:
            if current_high > range_high:
                breakout = True; manipulation_depth = current_high - range_high
                pct = (manipulation_depth / range_size) * 100
                if current_close < range_high:
                    manipulation = True
                    if pct >= min_manipulation_pct: signal = "sell"; strength = 80; reasons.append(f"CRT Bearish: Upward Manipulation ({pct:.1f}%) & Reclaim")
        
        return {"signal": signal, "strength": strength, "reasons": reasons, "range_info": {"high": range_high, "low": range_low, "direction": "bullish" if is_bullish_range else "bearish", "manipulation_pct": (manipulation_depth / range_size * 100) if breakout else 0}}

class SMCAnalyzer:
    def __init__(self):
        self.last_structure = "neutral" 
        self.ma_period = 200
        self.swing_lookback = 5
        self.atr_threshold = 0.002
        self.allow_bos = True; self.allow_ob = True; self.allow_fvg = True; self.use_sentiment = True

    def analyze(self, df: pd.DataFrame) -> Dict[str, any]:
        if len(df) < 50: return {"signal": "neutral", "structure": "neutral", "reason": "Insufficient Data"}
        
        swings = self._detect_swings(df)
        structure = self._analyze_structure(df, swings)
        ob_info = self._detect_order_blocks(df)
        fvg_info = self._detect_fvg(df)
        sweeps = self._detect_liquidity_sweeps(df, swings)
        pd_info = self._analyze_premium_discount(df, swings)
        
        signal = "neutral"; strength = 0; reasons = []
        is_bullish = structure['trend'] == 'bullish'
        is_bearish = structure['trend'] == 'bearish'
        in_discount = pd_info['zone'] == 'discount'
        in_premium = pd_info['zone'] == 'premium'
        
        if is_bullish and in_discount:
            if ob_info['signal'] == 'buy': signal = 'buy'; strength += 40; reasons.append(f"Bullish OB in Discount: {ob_info['reason']}")
            if sweeps['signal'] == 'buy': signal = 'buy'; strength += 30; reasons.append(f"Liquidity Sweep (Sell-side): {sweeps['reason']}")
            if fvg_info['signal'] == 'buy': signal = 'buy'; strength += 20; reasons.append(f"Bullish FVG Retest: {fvg_info['reason']}")
        elif is_bearish and in_premium:
            if ob_info['signal'] == 'sell': signal = 'sell'; strength += 40; reasons.append(f"Bearish OB in Premium: {ob_info['reason']}")
            if sweeps['signal'] == 'sell': signal = 'sell'; strength += 30; reasons.append(f"Liquidity Sweep (Buy-side): {sweeps['reason']}")
            if fvg_info['signal'] == 'sell': signal = 'sell'; strength += 20; reasons.append(f"Bearish FVG Retest: {fvg_info['reason']}")
                
        return {"signal": signal, "strength": strength, "structure": structure['trend'], "reason": "; ".join(reasons), "details": {"swings": swings, "ob": ob_info, "fvg": fvg_info, "sweeps": sweeps, "premium_discount": pd_info}}

    def _detect_swings(self, df):
        highs = df['high'].values; lows = df['low'].values; n = len(df)
        swing_highs = []; swing_lows = []
        for i in range(5, n-5):
            if all(highs[i] >= highs[i-j] for j in range(1, 6)) and all(highs[i] > highs[i+j] for j in range(1, 6)): swing_highs.append((i, highs[i]))
            if all(lows[i] <= lows[i-j] for j in range(1, 6)) and all(lows[i] < lows[i+j] for j in range(1, 6)): swing_lows.append((i, lows[i]))
        return {"highs": swing_highs, "lows": swing_lows}

    def _analyze_structure(self, df, swings):
        if not swings['highs'] or not swings['lows']: return {"trend": "neutral"}
        last_high = swings['highs'][-1][1]; prev_high = swings['highs'][-2][1] if len(swings['highs']) > 1 else last_high
        last_low = swings['lows'][-1][1]; prev_low = swings['lows'][-2][1] if len(swings['lows']) > 1 else last_low
        current_close = df['close'].iloc[-1]
        trend = "neutral"
        if last_high > prev_high and last_low > prev_low: trend = "bullish"
        elif last_high < prev_high and last_low < prev_low: trend = "bearish"
        if trend == "bullish" and current_close < last_low: trend = "bearish_change"
        elif trend == "bearish" and current_close > last_high: trend = "bullish_change"
        return {"trend": trend}

    def _detect_order_blocks(self, df):
        closes = df['close'].values; opens = df['open'].values; highs = df['high'].values; lows = df['low'].values; current_price = closes[-1]
        for i in range(len(df)-3, len(df)-50, -1):
            if opens[i-1] > closes[i-1]:
                if closes[i] > opens[i] and (closes[i] - opens[i]) > (opens[i-1] - closes[i-1]):
                    ob_high = highs[i-1]; ob_low = lows[i-1]; violated = False
                    for k in range(i+1, len(df)):
                        if closes[k] < ob_low: violated = True; break
                    if not violated and ob_low <= current_price <= ob_high * 1.01: return {"signal": "buy", "reason": f"Retesting Bullish OB from index {i-1}", "level": [ob_low, ob_high]}
            if opens[i-1] < closes[i-1]:
                if closes[i] < opens[i] and (opens[i] - closes[i]) > (closes[i-1] - opens[i-1]):
                    ob_high = highs[i-1]; ob_low = lows[i-1]; violated = False
                    for k in range(i+1, len(df)):
                        if closes[k] > ob_high: violated = True; break
                    if not violated and ob_low * 0.99 <= current_price <= ob_high: return {"signal": "sell", "reason": f"Retesting Bearish OB from index {i-1}", "level": [ob_low, ob_high]}
        return {"signal": "neutral", "reason": "", "level": []}

    def _detect_fvg(self, df):
        highs = df['high'].values; lows = df['low'].values; closes = df['close'].values; current_price = closes[-1]; point = 0.00001
        for i in range(len(df)-1, len(df)-20, -1):
            if lows[i] > highs[i-2]:
                gap_top = lows[i]; gap_bot = highs[i-2]; mitigated = False
                for k in range(i+1, len(df)):
                    if lows[k] < gap_top: mitigated = True
                if (not mitigated or (mitigated and current_price >= gap_bot)) and gap_bot <= current_price <= gap_top: return {"signal": "buy", "reason": f"In Bullish FVG {i}", "zone": [gap_bot, gap_top]}
            if highs[i] < lows[i-2]:
                gap_top = lows[i-2]; gap_bot = highs[i]; mitigated = False
                for k in range(i+1, len(df)):
                    if highs[k] > gap_bot: mitigated = True
                if (not mitigated or (mitigated and current_price <= gap_top)) and gap_bot <= current_price <= gap_top: return {"signal": "sell", "reason": f"In Bearish FVG {i}", "zone": [gap_bot, gap_top]}
        return {"signal": "neutral", "reason": "", "zone": []}

    def _detect_liquidity_sweeps(self, df, swings):
        if not swings['highs'] or not swings['lows']: return {"signal": "neutral"}
        current_high = df['high'].iloc[-1]; current_low = df['low'].iloc[-1]; current_close = df['close'].iloc[-1]
        last_swing_high = swings['highs'][-1][1]; last_swing_low = swings['lows'][-1][1]
        if current_high > last_swing_high and current_close < last_swing_high: return {"signal": "sell", "reason": "Buy-side Liquidity Sweep"}
        if current_low < last_swing_low and current_close > last_swing_low: return {"signal": "buy", "reason": "Sell-side Liquidity Sweep"}
        return {"signal": "neutral", "reason": ""}

    def _analyze_premium_discount(self, df, swings):
        if not swings['highs'] or not swings['lows']: return {"zone": "equilibrium"}
        recent_range_high = max(x[1] for x in swings['highs'][-3:]); recent_range_low = min(x[1] for x in swings['lows'][-3:])
        current_price = df['close'].iloc[-1]; mid_point = (recent_range_high + recent_range_low) / 2
        zone = "equilibrium"
        if current_price > mid_point: zone = "premium"
        elif current_price < mid_point: zone = "discount"
        return {"zone": zone, "range_high": recent_range_high, "range_low": recent_range_low, "equilibrium": mid_point}

class MFHAnalyzer:
    def __init__(self, input_size=16, learning_rate=0.01):
        self.input_size = input_size
        self.learning_rate = learning_rate
        self.horizon = 5 
        self.ma_period = 5 
        self.weights = np.random.randn(input_size) * np.sqrt(1 / input_size)
        self.bias = 0.0
        self.last_features = None
        self.last_prediction = 0.0
        self.count = 0
        self.mean = np.zeros(input_size)
        self.m2 = np.zeros(input_size)
        
    def calculate_features(self, df):
        if len(df) < (self.ma_period + self.horizon + 1): return None
        closes = df['close'].values; opens = df['open'].values; highs = df['high'].values; lows = df['low'].values
        ma_close = df['close'].rolling(window=self.ma_period).mean().values
        ma_open = df['open'].rolling(window=self.ma_period).mean().values
        ma_high = df['high'].rolling(window=self.ma_period).mean().values
        ma_low = df['low'].rolling(window=self.ma_period).mean().values
        curr = -1; prev_h = -1 - self.horizon
        features = np.zeros(16)
        features[0] = closes[curr]; features[1] = opens[curr]; features[2] = highs[curr]; features[3] = lows[curr]
        features[4] = ma_close[curr]; features[5] = ma_open[curr]; features[6] = ma_high[curr]; features[7] = ma_low[curr]
        features[8] = opens[curr] - opens[prev_h]; features[9] = highs[curr] - highs[prev_h]
        features[10] = lows[curr] - lows[prev_h]; features[11] = closes[curr] - closes[prev_h]
        features[12] = ma_close[curr] - ma_close[prev_h]; features[13] = ma_open[curr] - ma_open[prev_h]
        features[14] = ma_high[curr] - ma_high[prev_h]; features[15] = ma_low[curr] - ma_low[prev_h]
        
        if self.count == 0: self.mean = features.copy(); self.m2 = np.zeros_like(features)
        else:
            delta = features - self.mean; self.mean += delta / (self.count + 1)
            delta2 = features - self.mean; self.m2 += delta * delta2
        self.count += 1
        if self.count < 2: std = np.ones_like(features)
        else: variance = self.m2 / (self.count - 1); std = np.sqrt(variance); std[std == 0] = 1.0
        return (features - self.mean) / std

    def predict(self, df):
        features = self.calculate_features(df)
        if features is None: return {"signal": "neutral", "slope": 0.0}
        self.last_features = features
        prediction = np.dot(self.weights, features) + self.bias
        self.last_prediction = prediction
        slope = prediction
        signal = "buy" if slope > 0.001 else "sell" if slope < -0.001 else "neutral"
        return {"signal": signal, "slope": float(slope), "features": features.tolist() if features is not None else []}
        
    def train(self, current_price_change):
        if self.last_features is None: return
        target = current_price_change
        error = target - self.last_prediction
        self.weights += self.learning_rate * error * self.last_features
        self.bias += self.learning_rate * error
        return error

class MTFAnalyzer:
    def __init__(self):
        pass
    def analyze(self, current_df, htf_df):
        curr_trend = self._get_trend(current_df)
        htf_trend = self._get_trend(htf_df)
        signal = "neutral"; strength = 0; reason = ""
        if curr_trend == htf_trend and curr_trend != 0: signal = "buy" if curr_trend > 0 else "sell"; strength = 80; reason = "MTF Alignment (Trend confirmed)"
        elif htf_trend != 0: reason = f"MTF Divergence: HTF {htf_trend}, Curr {curr_trend}"
        return {"signal": signal, "strength": strength, "reason": reason, "htf_trend": htf_trend, "curr_trend": curr_trend}
    def _get_trend(self, df):
        ema20 = df['close'].ewm(span=20).mean().iloc[-1]; ema50 = df['close'].ewm(span=50).mean().iloc[-1]; close = df['close'].iloc[-1]
        if close > ema20 > ema50: return 1
        if close < ema20 < ema50: return -1
        return 0

class MatrixMLAnalyzer:
    def __init__(self, input_size=10, learning_rate=0.01):
        self.input_size = input_size
        self.learning_rate = learning_rate
        self.weights = np.random.randn(input_size) * np.sqrt(1 / input_size)
        self.bias = 0.0
        self.last_inputs = None
        self.last_prediction = 0.0
        
    def sigmoid(self, x): return 1 / (1 + np.exp(-x))
    def sigmoid_derivative(self, x): s = self.sigmoid(x); return s * (1 - s)
    def tanh(self, x): return np.tanh(x)
    def tanh_derivative(self, x): return 1.0 - np.tanh(x)**2

    def predict(self, tick_data_or_returns):
        # Compatible with both tick list (Gold) and direct returns array (Crypto)
        if isinstance(tick_data_or_returns, list) and len(tick_data_or_returns) > 0 and isinstance(tick_data_or_returns[0], dict):
             prices = np.array([t['ask'] for t in tick_data_or_returns])
             returns = np.diff(prices)
        elif isinstance(tick_data_or_returns, (np.ndarray, list, pd.Series)):
             returns = np.array(tick_data_or_returns)
        else:
             return {"signal": "neutral", "strength": 0.0, "raw_output": 0.0}

        if len(returns) < self.input_size: return {"signal": "neutral", "strength": 0.0, "raw_output": 0.0}
        features = returns[-self.input_size:]
        std = np.std(features)
        if std > 0: features = features / std
        else: features = np.zeros_like(features)
        self.last_inputs = features
        linear_output = np.dot(self.weights, features) + self.bias
        prediction = self.tanh(linear_output)
        self.last_prediction = prediction
        signal = "neutral"; strength = abs(prediction) * 100
        if prediction > 0.1: signal = "buy"
        elif prediction < -0.1: signal = "sell"
        return {"signal": signal, "strength": float(strength), "raw_output": float(prediction)}
        
    def train(self, actual_price_change):
        if self.last_inputs is None: return
        target = 1.0 if actual_price_change > 0 else -1.0
        if actual_price_change == 0: target = 0.0
        error = target - self.last_prediction
        derivative = self.tanh_derivative(self.last_prediction)
        self.weights += self.learning_rate * error * derivative * self.last_inputs
        self.bias += self.learning_rate * error * derivative
        return error

class AdvancedMarketAnalysisAdapter(AdvancedMarketAnalysis):
    def analyze_full(self, df: pd.DataFrame, params: Dict[str, any] = None) -> Dict[str, any]:
        if df is None or len(df) < 50: return None
        params = params or {}
        try:
            indicators = self.calculate_technical_indicators(df)
            regime = self.detect_market_regime(df)
            levels = self.generate_support_resistance(df)
            risk = self.calculate_risk_metrics(df)
            signal_info = self.generate_signal_from_indicators(indicators)
            summary = self.generate_analysis_summary(df)
            ifvg = self.analyze_ifvg(df, min_gap_points=params.get('ifvg_gap', 10))
            rvgi_cci = self.analyze_rvgi_cci_strategy(df, sma_period=params.get('rvgi_sma', 10), cci_period=params.get('rvgi_cci', 14))
            return {
                "indicators": indicators,
                "regime": regime,
                "levels": levels,
                "risk": risk,
                "signal_info": signal_info,
                "summary": summary,
                "ifvg": ifvg,
                "rvgi_cci": rvgi_cci
            }
        except Exception as e:
            logging.error(f"Full Analysis failed: {e}")
            return None