"""Admin routes — user management panel."""
from flask import Blueprint, render_template, request
from app.helpers.auth import admin_required

admin_bp = Blueprint('admin', __name__, url_prefix='/admin')


@admin_bp.route('/')
@admin_required
def dashboard():
    """Admin dashboard — system overview (users, payments, sync)."""
    return render_template('admin/admin_dashboard.html')


@admin_bp.route('/users')
@admin_required
def users():
    """User manager — list all users, approve/reject."""
    from app.models.user import User
    from app.helpers.asset_filter import get_allowed_markets

    status_filter = request.args.get('status', 'all')
    query = User.query

    if status_filter == 'pending':
        query = query.filter_by(is_approved=False, is_active=True)
    elif status_filter == 'active':
        query = query.filter_by(is_approved=True, is_active=True)
    elif status_filter == 'disabled':
        query = query.filter_by(is_active=False)

    users_list = query.order_by(User.created_at.desc()).all()
    pending_count = User.query.filter_by(is_approved=False, is_active=True).count()

    # Build user_id → allowed_markets map for template
    user_markets = {u.id: get_allowed_markets(u.id) for u in users_list}

    return render_template('admin/users.html',
                           users=users_list,
                           status_filter=status_filter,
                           pending_count=pending_count,
                           user_markets=user_markets)


@admin_bp.route('/sync')
@admin_required
def sync_dashboard():
    """Admin sync dashboard — manage remote sync via GUI."""
    return render_template('admin/sync.html')


@admin_bp.route('/ml')
@admin_required
def ml_dashboard():
    """Admin ML control panel — mode toggle, stats, bulk scan triggers."""
    return render_template('admin/ml.html')


@admin_bp.route('/workflow')
@admin_required
def workflow():
    """Pipeline workflow — visual DAG for sync → scan → recommendations."""
    return render_template('admin/workflow.html')


@admin_bp.route('/tier-management')
@admin_required
def tier_management():
    """Admin tier management — feature tiers, pricing, QRIS upload."""
    return render_template('admin/tier_management.html')


@admin_bp.route('/subscription-payments')
@admin_required
def subscription_payments():
    """Admin subscription payment verification — approve/reject pending payments."""
    return render_template('admin/subscription_payments.html')


@admin_bp.route('/landing-page')
@admin_required
def landing_page_cms():
    """Admin landing page CMS — edit hero, features, FAQ, footer."""
    from app.helpers.landing_content import get_landing_content
    return render_template('admin/landing_page_cms.html', landing=get_landing_content())


@admin_bp.route('/oversold-bounce')
@admin_required
def oversold_bounce():
    """Oversold Bounce Screener — deeply oversold assets ready to bounce."""
    return render_template('admin/oversold_bounce.html')


@admin_bp.route('/breakout')
@admin_required
def breakout():
    """Breakout Detector — assets about to break out of their range."""
    return render_template('admin/breakout_detector.html')


@admin_bp.route('/passive-income')
@admin_required
def passive_income():
    """Passive Income Screener — consistent daily grinding profit."""
    return render_template('admin/passive_income.html')


@admin_bp.route('/smart-accumulation')
@admin_required
def smart_accumulation():
    """Smart Accumulation — accumulation phase before price rally."""
    return render_template('admin/smart_accumulation.html')


@admin_bp.route('/swing-trade')
@admin_required
def swing_trade():
    """Swing Trade Setup — optimal swing trade setups."""
    return render_template('admin/swing_trade.html')


@admin_bp.route('/sell-signal')
@admin_required
def sell_signal():
    """Sell Signal Screener — identify overbought/exit candidates."""
    return render_template('admin/sell_signal.html')


@admin_bp.route('/portfolio-health')
@admin_required
def portfolio_health():
    """Portfolio Health Monitor — health status of all tracked assets."""
    return render_template('admin/portfolio_health.html')


@admin_bp.route('/meta-screener')
@admin_required
def meta_screener():
    """Meta-Screener — unified ranking combining all 6 screeners."""
    return render_template('admin/meta_screener.html')


@admin_bp.route('/market-regime')
@admin_required
def market_regime():
    """Market Regime Dashboard — overall market health & phase."""
    return render_template('admin/market_regime.html')


@admin_bp.route('/dca')
@admin_bp.route('/dca-optimizer')
@admin_required
def dca_optimizer():
    """DCA Optimizer — best assets for dollar-cost averaging."""
    return render_template('admin/dca_optimizer.html')


@admin_bp.route('/correlation')
@admin_required
def correlation_scanner():
    """Correlation Scanner — correlated asset groups & diversification."""
    return render_template('admin/correlation_scanner.html')


# ─── Wave 3: Advanced Insights ───────────────────────────────────────────────

@admin_bp.route('/signal-performance')
@admin_required
def signal_performance():
    """Signal Performance Tracker — win rates, accuracy, outcome history."""
    return render_template('admin/signal_performance.html')


@admin_bp.route('/sector-rotation')
@admin_required
def sector_rotation():
    """Sector Rotation — sector strength & rotation signals."""
    return render_template('admin/sector_rotation.html')


@admin_bp.route('/momentum-heatmap')
@admin_required
def momentum_heatmap():
    """Momentum Heatmap — price change visualization grid."""
    return render_template('admin/momentum_heatmap.html')


@admin_bp.route('/anomaly-detector')
@admin_required
def anomaly_detector():
    """Anomaly Detector — unusual price & volume patterns."""
    return render_template('admin/anomaly_detector.html')


@admin_bp.route('/risk-calculator')
@admin_required
def risk_calculator():
    """Risk Calculator — position sizing & risk management."""
    return render_template('admin/risk_calculator.html')


@admin_bp.route('/leaderboard')
@admin_required
def leaderboard():
    """Leaderboard — top performing assets ranked by composite score."""
    return render_template('admin/leaderboard.html')


# ─── Wave 4: Profit Maximizer Tools ──────────────────────────────────────────

@admin_bp.route('/telegram-alerts')
@admin_required
def telegram_alerts():
    """Telegram Alert Bot — configure & monitor alert notifications."""
    return render_template('admin/telegram_alerts.html')


@admin_bp.route('/performance-attribution')
@admin_required
def performance_attribution():
    """Performance Attribution — which strategies generate the most profit."""
    return render_template('admin/performance_attribution.html')


@admin_bp.route('/scan-scheduler')
@admin_required
def scan_scheduler():
    """Auto-Scan Scheduler — automated periodic scans with alerts."""
    return render_template('admin/scan_scheduler.html')


@admin_bp.route('/price-alerts')
@admin_required
def price_alerts():
    """Watchlist Price Alerts — set & monitor price targets."""
    return render_template('admin/price_alerts.html')


@admin_bp.route('/portfolio-optimizer')
@admin_required
def portfolio_optimizer():
    """Portfolio Optimizer — optimal asset allocation (Markowitz)."""
    return render_template('admin/portfolio_optimizer.html')


# ─── Wave 5: Profit Maximizer Pro Tools ──────────────────────────────────────

@admin_bp.route('/adaptive-sltp')
@admin_required
def adaptive_sltp():
    """Adaptive SL/TP Optimizer — dynamic stop-loss & take-profit levels."""
    return render_template('admin/adaptive_sltp.html')


@admin_bp.route('/trade-journal')
@admin_required
def trade_journal():
    """Trade Journal — log, track & analyze your actual trades."""
    return render_template('admin/trade_journal.html')


@admin_bp.route('/smart-entry')
@admin_required
def smart_entry():
    """Smart Entry Timing — find optimal entry windows after signals."""
    return render_template('admin/smart_entry.html')


@admin_bp.route('/liquidity-analysis')
@admin_required
def liquidity_analysis():
    """Liquidity Analysis — execution risk & volume confirmation."""
    return render_template('admin/liquidity_analysis.html')


@admin_bp.route('/ml-health')
@admin_required
def ml_health():
    """ML Health Monitor — model accuracy tracking & degradation alerts."""
    return render_template('admin/ml_health.html')


# ─── Wave 6: Edge Maximizer Tools ────────────────────────────────────────────

@admin_bp.route('/session-analysis')
@admin_required
def session_analysis():
    """Sessions & Hourly Analysis — best/worst trading hours."""
    return render_template('admin/session_analysis.html')


@admin_bp.route('/funding-rate')
@admin_required
def funding_rate():
    """Funding Rate Analysis — leverage positioning & contrarian signals."""
    return render_template('admin/funding_rate.html')


@admin_bp.route('/pain-points')
@admin_required
def pain_points():
    """Pain Point Filter — identify & avoid toxic patterns."""
    return render_template('admin/pain_points.html')


@admin_bp.route('/confluence')
@admin_required
def confluence():
    """Confluence Scoring — multi-factor signal validation."""
    return render_template('admin/confluence.html')


@admin_bp.route('/kelly-sizing')
@admin_required
def kelly_sizing():
    """Kelly Criterion — optimal position sizing calculator."""
    return render_template('admin/kelly_sizing.html')


# ─── Wave 7: Quantum Edge Tools ───────────────────────────────────────────────

@admin_bp.route('/regime-sizing')
@admin_required
def regime_sizing():
    """Volatility Regime Sizer — dynamic position sizing per volatility regime."""
    return render_template('admin/regime_sizing.html')


@admin_bp.route('/cycle-predictor')
@admin_required
def cycle_predictor():
    """Cycle Predictor — mean reversion cycle completion forecasts."""
    return render_template('admin/cycle_predictor.html')


@admin_bp.route('/microstructure')
@admin_required
def microstructure():
    """Microstructure Exploiter — intra-candle reversal patterns."""
    return render_template('admin/microstructure.html')


@admin_bp.route('/drawdown-recovery')
@admin_required
def drawdown_recovery():
    """Drawdown Recovery — ranked recovery opportunities after crashes."""
    return render_template('admin/drawdown_recovery.html')


@admin_bp.route('/contagion')
@admin_required
def contagion():
    """Contagion Detector — cascading selloff prediction & safe havens."""
    return render_template('admin/contagion.html')


# ─── Wave 8: Alpha Shield Tools ───────────────────────────────────────────────

@admin_bp.route('/winrate-collapse')
@admin_required
def winrate_collapse():
    """Win Rate Collapse — edge degradation detection & alerts."""
    return render_template('admin/winrate_collapse.html')


@admin_bp.route('/pair-trading')
@admin_required
def pair_trading():
    """Pair Trader — statistical arbitrage from correlated pair divergence."""
    return render_template('admin/pair_trading.html')


@admin_bp.route('/liquidation-predictor')
@admin_required
def liquidation_predictor():
    """Liquidation Predictor — forced liquidation cascade forecasts."""
    return render_template('admin/liquidation_predictor.html')


@admin_bp.route('/capital-allocation')
@admin_required
def capital_allocation():
    """Capital Allocator — intraday Sharpe-weighted allocation optimizer."""
    return render_template('admin/capital_allocation.html')


@admin_bp.route('/reentry-filter')
@admin_required
def reentry_filter():
    """Re-entry Filter — post-exit cooldown & behavioral edge protection."""
    return render_template('admin/reentry_filter.html')


# ─── Wave 9: Signal Harvester Tools ───────────────────────────────────────────

@admin_bp.route('/earnings-screener')
@admin_required
def earnings_screener():
    """Earnings Screener — pre/post-earnings trade setups."""
    return render_template('admin/earnings_screener.html')


@admin_bp.route('/insider-detector')
@admin_required
def insider_detector():
    """Insider Detector — accumulation/distribution pattern detection."""
    return render_template('admin/insider_detector.html')


@admin_bp.route('/dividend-optimizer')
@admin_required
def dividend_optimizer():
    """Dividend Optimizer — capture timing & DRIP compounding."""
    return render_template('admin/dividend_optimizer.html')


@admin_bp.route('/event-arbitrage')
@admin_required
def event_arbitrage():
    """Event Arbitrage — cross-asset correlation exploitation."""
    return render_template('admin/event_arbitrage.html')


@admin_bp.route('/recovery-predictor')
@admin_required
def recovery_predictor():
    """Recovery Predictor — ML-based recovery path forecasting."""
    return render_template('admin/recovery_predictor.html')


# ── Wave 10: Conviction Engine ───────────────────────────────────────────────

@admin_bp.route('/analyst-conviction')
@admin_required
def analyst_conviction():
    """Analyst Conviction Detector — consensus shifts & upgrade cascades."""
    return render_template('admin/analyst_conviction.html')


@admin_bp.route('/options-flow')
@admin_required
def options_flow():
    """Options Flow Monitor — put/call ratios & unusual activity."""
    return render_template('admin/options_flow.html')


@admin_bp.route('/fundamental-momentum')
@admin_required
def fundamental_momentum():
    """Fundamental Momentum — financial quality & growth scoring."""
    return render_template('admin/fundamental_momentum.html')


@admin_bp.route('/social-momentum')
@admin_required
def social_momentum():
    """Social Momentum — community growth & sentiment spikes."""
    return render_template('admin/social_momentum.html')


@admin_bp.route('/whale-tracker')
@admin_required
def whale_tracker():
    """Whale Tracker — institutional accumulation & volume anomalies."""
    return render_template('admin/whale_tracker.html')


# ── Wave 11: Master Strategy Suite ───────────────────────────────────────────

@admin_bp.route('/signal-orchestrator')
@admin_required
def signal_orchestrator():
    """Signal Orchestrator — master aggregator combining all tool signals."""
    return render_template('admin/signal_orchestrator.html')


@admin_bp.route('/backtest')
@admin_required
def backtest():
    """Backtest Engine — test strategies against historical data."""
    return render_template('admin/backtest.html')


@admin_bp.route('/supply-demand')
@admin_required
def supply_demand():
    """Supply/Demand Zones — institutional S/R from volume profile."""
    return render_template('admin/supply_demand.html')


@admin_bp.route('/news-sentiment')
@admin_required
def news_sentiment():
    """News Sentiment — news-based sentiment analysis."""
    return render_template('admin/news_sentiment.html')


@admin_bp.route('/risk-parity')
@admin_required
def risk_parity():
    """Risk Parity — equal risk contribution portfolio allocation."""
    return render_template('admin/risk_parity.html')


# ── Wave 12: Profit Maximizer Suite ──────────────────────────────────────────

@admin_bp.route('/multi-timeframe')
@admin_required
def multi_timeframe():
    """Multi-Timeframe Confluence — signals aligned across 1H/4H/D/W."""
    return render_template('admin/multi_timeframe.html')


@admin_bp.route('/volume-profile')
@admin_required
def volume_profile():
    """Volume Profile — POC, Value Area, HVN/LVN analysis."""
    return render_template('admin/volume_profile.html')


@admin_bp.route('/chart-patterns')
@admin_required
def chart_patterns():
    """AI Chart Pattern Recognition — H&S, triangles, wedges, flags."""
    return render_template('admin/chart_patterns.html')


@admin_bp.route('/smart-money')
@admin_required
def smart_money():
    """Smart Money Concepts — order blocks, FVG, liquidity sweeps."""
    return render_template('admin/smart_money.html')


@admin_bp.route('/mean-reversion')
@admin_required
def mean_reversion():
    """Mean Reversion Scanner — z-score, Bollinger, Hurst exponent."""
    return render_template('admin/mean_reversion.html')


@admin_bp.route('/monte-carlo')
@admin_required
def monte_carlo():
    """Monte Carlo Simulator — VaR, CVaR, probability of ruin."""
    return render_template('admin/monte_carlo.html')


@admin_bp.route('/gap-scanner')
@admin_required
def gap_scanner():
    """Gap Scanner — detect and analyze price gaps with fill probability."""
    return render_template('admin/gap_scanner.html')


@admin_bp.route('/auto-rebalancer')
@admin_required
def auto_rebalancer():
    """Auto-Rebalancer — portfolio rebalancing suggestions."""
    return render_template('admin/auto_rebalancer.html')


@admin_bp.route('/volatility-squeeze')
@admin_required
def volatility_squeeze():
    """Volatility Squeeze — Bollinger-Keltner squeeze detector."""
    return render_template('admin/volatility_squeeze.html')


@admin_bp.route('/cross-asset')
@admin_required
def cross_asset():
    """Cross-Asset Correlation — intermarket analysis dashboard."""
    return render_template('admin/cross_asset.html')


# ═══════════════════════════════════════════════════════════════════════════════
# WAVE 13 — ADVANCED TRADING EDGE
# ═══════════════════════════════════════════════════════════════════════════════


@admin_bp.route('/harmonic-patterns')
@admin_required
def harmonic_patterns():
    """Harmonic Pattern Scanner — Gartley, Butterfly, Bat, Crab, Shark."""
    return render_template('admin/harmonic_patterns.html')


@admin_bp.route('/ichimoku')
@admin_required
def ichimoku():
    """Ichimoku Cloud Scanner — Tenkan/Kijun, Cloud, Chikou analysis."""
    return render_template('admin/ichimoku.html')


@admin_bp.route('/wyckoff')
@admin_required
def wyckoff():
    """Wyckoff Phase Analyzer — Accumulation/Distribution/Markup/Markdown."""
    return render_template('admin/wyckoff.html')


@admin_bp.route('/vwap')
@admin_required
def vwap():
    """VWAP Analysis Suite — bands, anchored VWAP, deviation."""
    return render_template('admin/vwap.html')


@admin_bp.route('/fibonacci-clusters')
@admin_required
def fibonacci_clusters():
    """Fibonacci Cluster Zones — multi-fib confluence zones."""
    return render_template('admin/fibonacci_clusters.html')


@admin_bp.route('/market-maker')
@admin_required
def market_maker():
    """Market Maker Detector — absorption, spoofing, distribution."""
    return render_template('admin/market_maker.html')


@admin_bp.route('/fear-greed')
@admin_required
def fear_greed():
    """Fear & Greed Index — composite sentiment index."""
    return render_template('admin/fear_greed.html')


@admin_bp.route('/ml-ensemble')
@admin_required
def ml_ensemble():
    """ML Ensemble Predictor — RF + GBM + Ridge combined."""
    return render_template('admin/ml_ensemble.html')


@admin_bp.route('/regime-strategy')
@admin_required
def regime_strategy():
    """Regime Strategy Selector — auto-select best strategy per regime."""
    return render_template('admin/regime_strategy.html')


@admin_bp.route('/on-chain')
@admin_required
def on_chain():
    """On-Chain Analytics — exchange flow, whale detection, MVRV."""
    return render_template('admin/on_chain.html')


# ── Wave 14 — Execution Excellence ────────────────────────────────────────────

@admin_bp.route('/divergence-scanner')
@admin_required
def divergence_scanner():
    """Divergence Scanner — RSI, MACD, OBV & Volume divergences."""
    return render_template('admin/divergence_scanner.html')


@admin_bp.route('/order-flow')
@admin_required
def order_flow():
    """Order Flow Imbalance — buy/sell pressure & delta volume."""
    return render_template('admin/order_flow.html')


@admin_bp.route('/grid-bot')
@admin_required
def grid_bot():
    """Adaptive Grid Bot — optimal grid parameters per volatility."""
    return render_template('admin/grid_bot.html')


@admin_bp.route('/swing-failure')
@admin_required
def swing_failure():
    """Swing Failure Pattern — failed breakout/breakdown detection."""
    return render_template('admin/swing_failure.html')


@admin_bp.route('/market-profile')
@admin_required
def market_profile():
    """Market Profile TPO — POC, Value Area, Single Prints."""
    return render_template('admin/market_profile.html')


@admin_bp.route('/trailing-stop')
@admin_required
def trailing_stop():
    """Trailing Stop Engine — 6 trailing strategies comparison."""
    return render_template('admin/trailing_stop.html')


@admin_bp.route('/compound-growth')
@admin_required
def compound_growth():
    """Compound Growth Planner — portfolio growth projections."""
    return render_template('admin/compound_growth.html')


@admin_bp.route('/profit-factor')
@admin_required
def profit_factor():
    """Profit Factor Analyzer — strategy PF comparison."""
    return render_template('admin/profit_factor.html')


@admin_bp.route('/trade-timing')
@admin_required
def trade_timing():
    """Trade Timing Index — hour, session & day patterns."""
    return render_template('admin/trade_timing.html')


@admin_bp.route('/ai-coach')
@admin_required
def ai_coach():
    """AI Portfolio Coach — personalized portfolio recommendations."""
    return render_template('admin/ai_coach.html')


# ── Wave 15 — Alpha Generation & Mastery ─────────────────────────────────────

@admin_bp.route('/elliott-wave')
@admin_required
def elliott_wave():
    """Elliott Wave Counter — automated wave counting & targets."""
    return render_template('admin/elliott_wave.html')


@admin_bp.route('/liquidation-heatmap')
@admin_required
def liquidation_heatmap():
    """Liquidation Heatmap — leveraged position liquidation zones."""
    return render_template('admin/liquidation_heatmap.html')


@admin_bp.route('/social-sentiment')
@admin_required
def social_sentiment():
    """Social Sentiment Index — behavioral sentiment proxy."""
    return render_template('admin/social_sentiment.html')


@admin_bp.route('/strategy-backtester')
@admin_required
def strategy_backtester():
    """Strategy Backtester — full backtesting with equity curves."""
    return render_template('admin/strategy_backtester.html')


# ── Wave 16 — Mastery & Intelligence Suite ──────────────────────────────────

@admin_bp.route('/stress-test')
@admin_required
def stress_test():
    """Portfolio Stress Test — crash scenario analysis & vulnerability."""
    return render_template('admin/stress_test.html')


@admin_bp.route('/market-breadth')
@admin_required
def market_breadth():
    """Market Breadth Scanner — advance/decline, market health metrics."""
    return render_template('admin/market_breadth.html')


@admin_bp.route('/relative-strength')
@admin_required
def relative_strength():
    """Relative Strength Ranker — RS vs BTC/market benchmark."""
    return render_template('admin/relative_strength.html')


@admin_bp.route('/exit-planner')
@admin_required
def exit_planner():
    """Exit Strategy Planner — staged profit-taking plans."""
    return render_template('admin/exit_planner.html')


@admin_bp.route('/accumulation-zone')
@admin_required
def accumulation_zone():
    """Accumulation Zone Detector — smart entry zone identification."""
    return render_template('admin/accumulation_zone.html')


@admin_bp.route('/volatility-surface')
@admin_required
def volatility_surface():
    """Volatility Surface Analyzer — vol structure across assets."""
    return render_template('admin/volatility_surface.html')


@admin_bp.route('/alpha-decay')
@admin_required
def alpha_decay():
    """Alpha Decay Monitor — signal freshness & staleness tracking."""
    return render_template('admin/alpha_decay.html')


@admin_bp.route('/whale-flow')
@admin_required
def whale_flow():
    """Whale Flow Aggregator — aggregate whale movement patterns."""
    return render_template('admin/whale_flow.html')


@admin_bp.route('/trend-strength')
@admin_required
def trend_strength():
    """Trend Strength Index — composite trend scoring system."""
    return render_template('admin/trend_strength.html')


@admin_bp.route('/risk-reward')
@admin_required
def risk_reward():
    """Risk-Reward Scanner — optimal R:R entry point detection."""
    return render_template('admin/risk_reward.html')


# ── Wave 17 — Ultimate Profit Engine ────────────────────────────────────────

@admin_bp.route('/sniper-entry')
@admin_required
def sniper_entry():
    """Sniper Entry — precision entry combining ALL signal sources."""
    return render_template('admin/sniper_entry.html')


@admin_bp.route('/reversal-radar')
@admin_required
def reversal_radar():
    """Reversal Radar — early trend reversal detection."""
    return render_template('admin/reversal_radar.html')


@admin_bp.route('/money-flow')
@admin_required
def money_flow():
    """Money Flow Tracker — capital flow between sectors & assets."""
    return render_template('admin/money_flow.html')


@admin_bp.route('/catalyst-calendar')
@admin_required
def catalyst_calendar():
    """Catalyst Calendar — event-driven profit opportunities."""
    return render_template('admin/catalyst_calendar.html')


@admin_bp.route('/smart-money-copy')
@admin_required
def smart_money_copy():
    """Smart Money Copier — mirror whale/institutional patterns."""
    return render_template('admin/smart_money_copy.html')


@admin_bp.route('/cascade-profiter')
@admin_required
def cascade_profiter():
    """Cascade Profiter — profit from liquidation cascades."""
    return render_template('admin/cascade_profiter.html')


@admin_bp.route('/correlation-breakout')
@admin_required
def correlation_breakout():
    """Correlation Breakout — assets breaking from BTC/market correlation."""
    return render_template('admin/correlation_breakout.html')


@admin_bp.route('/momentum-rotator')
@admin_required
def momentum_rotator():
    """Momentum Rotator — auto-rotate to hottest sectors/assets."""
    return render_template('admin/momentum_rotator.html')


@admin_bp.route('/profit-maximizer')
@admin_required
def profit_maximizer():
    """Profit Maximizer — staged profit-taking + trailing optimization."""
    return render_template('admin/profit_maximizer.html')


@admin_bp.route('/ai-trade-architect')
@admin_required
def ai_trade_architect():
    """AI Trade Architect — AI-generated complete trade plans."""
    return render_template('admin/ai_trade_architect.html')


# ══════════════════════════════════════════════════════════════════════════════
#  WAVE 18 — Wealth Acceleration Suite (Features 102-111)
# ══════════════════════════════════════════════════════════════════════════════


@admin_bp.route('/wealth-dashboard')
@admin_required
def wealth_dashboard():
    """Wealth Dashboard — aggregate portfolio intelligence & market overview."""
    return render_template('admin/wealth_dashboard.html')


@admin_bp.route('/income-streams')
@admin_required
def income_streams():
    """Income Stream Mapper — find assets for passive income strategies."""
    return render_template('admin/income_streams.html')


@admin_bp.route('/whale-momentum')
@admin_required
def whale_momentum():
    """Whale Momentum Decoder — detect institutional/whale activity patterns."""
    return render_template('admin/whale_momentum.html')


@admin_bp.route('/momentum-cascade')
@admin_required
def momentum_cascade():
    """Momentum Cascade Finder — multi-timeframe momentum alignment."""
    return render_template('admin/momentum_cascade.html')


@admin_bp.route('/position-architect')
@admin_required
def position_architect():
    """Position Architect — generate complete position plans."""
    return render_template('admin/position_architect.html')


@admin_bp.route('/market-cycle')
@admin_required
def market_cycle():
    """Market Cycle Navigator — macro cycle phase analysis."""
    return render_template('admin/market_cycle.html')


@admin_bp.route('/crypto-season')
@admin_required
def crypto_season():
    """Crypto Season Detector — BTC vs altcoin season detection."""
    return render_template('admin/crypto_season.html')


@admin_bp.route('/alpha-generator')
@admin_required
def alpha_generator():
    """Alpha Generator — highest alpha potential identification."""
    return render_template('admin/alpha_generator.html')


@admin_bp.route('/entry-zones')
@admin_required
def entry_zones():
    """Entry Zone Mapper — precise buy/sell/wait zones."""
    return render_template('admin/entry_zones.html')


@admin_bp.route('/profit-lock')
@admin_required
def profit_lock():
    """Profit Lock System — systematic profit-locking rules."""
    return render_template('admin/profit_lock.html')


# ==========================================================================
#  WAVE 19 — Precision Profit Engine (Features 112-121)
# ==========================================================================

@admin_bp.route('/probability-matrix')
@admin_required
def probability_matrix():
    """Feature 112: Probability Matrix — win probability for each asset."""
    return render_template('admin/probability_matrix.html')


@admin_bp.route('/precision-timer')
@admin_required
def precision_timer():
    """Feature 113: Precision Timer — optimal entry timing."""
    return render_template('admin/precision_timer.html')


@admin_bp.route('/profit-velocity')
@admin_required
def profit_velocity():
    """Feature 114: Profit Velocity Tracker — speed of profit generation."""
    return render_template('admin/profit_velocity.html')


@admin_bp.route('/risk-thermometer')
@admin_required
def risk_thermometer():
    """Feature 115: Risk Thermometer — danger temperature gauge."""
    return render_template('admin/risk_thermometer.html')


@admin_bp.route('/signal-convergence')
@admin_required
def signal_convergence():
    """Feature 116: Signal Convergence Map — bullish signal stacking."""
    return render_template('admin/signal_convergence.html')


@admin_bp.route('/wealth-compounder')
@admin_required
def wealth_compounder():
    """Feature 117: Wealth Compounder — compound growth projections."""
    return render_template('admin/wealth_compounder.html')


@admin_bp.route('/gem-finder')
@admin_required
def gem_finder():
    """Feature 118: Gem Finder — undervalued high-potential assets."""
    return render_template('admin/gem_finder.html')


@admin_bp.route('/cycle-sync')
@admin_required
def cycle_sync():
    """Feature 119: Cycle Synchronizer — synchronized asset cycles."""
    return render_template('admin/cycle_sync.html')


@admin_bp.route('/smart-sizing')
@admin_required
def smart_sizing():
    """Feature 120: Smart Sizing Engine — optimal position sizing."""
    return render_template('admin/smart_sizing.html')


@admin_bp.route('/wealth-protector')
@admin_required
def wealth_protector():
    """Feature 121: Wealth Protector — protect accumulated wealth."""
    return render_template('admin/wealth_protector.html')


# ==========================================================================
# Wave 20 — Wealth Certainty Engine (Features 122-131)
# ==========================================================================

# Note: trade_journal (122), exit_planner (123), dca_optimizer (124),
# and risk_parity (130) already registered in earlier waves.


@admin_bp.route('/portfolio-rebalancer')
@admin_required
def portfolio_rebalancer():
    """Feature 125: Portfolio Rebalancer — drift detection & rebalancing."""
    return render_template('admin/portfolio_rebalancer.html')


@admin_bp.route('/profit-scheduler')
@admin_required
def profit_scheduler():
    """Feature 126: Profit Scheduler — systematic profit-taking schedule."""
    return render_template('admin/profit_scheduler.html')


@admin_bp.route('/correlation-radar')
@admin_required
def correlation_radar():
    """Feature 127: Correlation Radar — asset correlation matrix."""
    return render_template('admin/correlation_radar.html')


@admin_bp.route('/regime-detector')
@admin_required
def regime_detector():
    """Feature 128: Regime Detector — market regime classification."""
    return render_template('admin/regime_detector.html')


@admin_bp.route('/drawdown-shield')
@admin_required
def drawdown_shield():
    """Feature 129: Drawdown Shield — drawdown monitor & protection."""
    return render_template('admin/drawdown_shield.html')


@admin_bp.route('/stress-tester')
@admin_required
def stress_tester():
    """Feature 131: Stress Tester — crash scenario simulator."""
    return render_template('admin/stress_tester.html')


# ── Wave 21 — Tactical Alpha Suite (Features 132-141) ────────────

@admin_bp.route('/momentum-scanner')
@admin_required
def momentum_scanner():
    """Feature 132: Momentum Scanner — multi-timeframe momentum ranking."""
    return render_template('admin/momentum_scanner.html')


@admin_bp.route('/value-detector')
@admin_required
def value_detector():
    """Feature 133: Value Detector — undervalued/overvalued detection."""
    return render_template('admin/value_detector.html')


@admin_bp.route('/breakout-predictor')
@admin_required
def breakout_predictor():
    """Feature 134: Breakout Predictor — breakout probability scoring."""
    return render_template('admin/breakout_predictor.html')


@admin_bp.route('/support-resistance-map')
@admin_required
def support_resistance_map():
    """Feature 135: Support Resistance Map — key S/R level mapping."""
    return render_template('admin/support_resistance_map.html')


@admin_bp.route('/trend-reversal')
@admin_required
def trend_reversal():
    """Feature 136: Trend Reversal — reversal signal detection."""
    return render_template('admin/trend_reversal.html')


@admin_bp.route('/volatility-rank')
@admin_required
def volatility_rank():
    """Feature 137: Volatility Rank — volatility ranking & classification."""
    return render_template('admin/volatility_rank.html')


@admin_bp.route('/price-action')
@admin_required
def price_action():
    """Feature 138: Price Action — price action pattern analysis."""
    return render_template('admin/price_action.html')


@admin_bp.route('/market-microstructure')
@admin_required
def market_microstructure():
    """Feature 139: Market Microstructure — spread & liquidity depth."""
    return render_template('admin/market_microstructure.html')


@admin_bp.route('/pair-trader')
@admin_required
def pair_trader():
    """Feature 140: Pair Trader — pair trading opportunity finder."""
    return render_template('admin/pair_trader.html')


@admin_bp.route('/alpha-composite')
@admin_required
def alpha_composite():
    """Feature 141: Alpha Composite — composite alpha score."""
    return render_template('admin/alpha_composite.html')


# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
#  WAVE 22 — Profit Maximizer Engine (Features 142-151)  🟠 orange theme
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

@admin_bp.route('/multibagger')
@admin_required
def multibagger():
    """Feature 142: Multibagger Screener — identify high-growth potential."""
    return render_template('admin/multibagger.html')


@admin_bp.route('/position-sizer')
@admin_required
def position_sizer():
    """Feature 143: Position Size Calculator — Kelly Criterion."""
    return render_template('admin/position_sizer.html')


@admin_bp.route('/profit-target')
@admin_required
def profit_target():
    """Feature 144: Profit Target Optimizer — dynamic TP levels."""
    return render_template('admin/profit_target.html')


@admin_bp.route('/dca-planner')
@admin_required
def dca_planner():
    """Feature 145: DCA Strategy Planner — smart DCA zones."""
    return render_template('admin/dca_planner.html')


@admin_bp.route('/risk-reward-matrix')
@admin_required
def risk_reward_matrix():
    """Feature 146: Risk/Reward Matrix — R:R analysis."""
    return render_template('admin/risk_reward_matrix.html')


@admin_bp.route('/compound-growth-sim')
@admin_required
def compound_growth_sim():
    """Feature 147: Compound Growth Simulator."""
    return render_template('admin/compound_growth_simulator.html')


@admin_bp.route('/confluence-radar')
@admin_required
def confluence_radar():
    """Feature 148: Trade Confluence Radar — multi-signal alignment."""
    return render_template('admin/confluence_radar.html')


@admin_bp.route('/sector-rotation-tracker')
@admin_required
def sector_rotation_tracker():
    """Feature 149: Sector Rotation Tracker."""
    return render_template('admin/sector_rotation_tracker.html')


@admin_bp.route('/whale-accumulation')
@admin_required
def whale_accumulation():
    """Feature 150: Whale Accumulation Detector."""
    return render_template('admin/whale_accumulation.html')


@admin_bp.route('/exit-optimizer')
@admin_required
def exit_optimizer():
    """Feature 151: Exit Strategy Optimizer."""
    return render_template('admin/exit_optimizer.html')


@admin_bp.route('/docs')
@admin_required
def docs_index():
    """Documentation hub — render docs/index.md with sidebar navigation."""
    from app.helpers.markdown_renderer import list_docs, get_doc
    all_docs = list_docs()
    doc = get_doc('index')
    return render_template('admin/docs.html',
                           docs=all_docs, doc=doc, current_slug='index')


@admin_bp.route('/docs/<slug>')
@admin_required
def docs_page(slug):
    """Render a specific docs/<slug>.md page."""
    from app.helpers.markdown_renderer import list_docs, get_doc
    all_docs = list_docs()
    doc = get_doc(slug)
    if not doc:
        return render_template('admin/docs.html',
                               docs=all_docs, doc=None, current_slug=slug), 404
    return render_template('admin/docs.html',
                           docs=all_docs, doc=doc, current_slug=slug)