XauBot/backtests/archive/backtest_improved_v2.py

"""
Backtest v2: Using Historical ML Confidence Data
=================================================
Analyzes what would have happened if new filters were applied
using the actual ML confidence recorded at trade time.

Since we can't replay exact market data, we use:
1. Recorded ML confidence from trade logs
2. Simulated pullback detection based on price movement pattern
"""

import pandas as pd
from datetime import datetime
from typing import List
from dataclasses import dataclass


@dataclass
class TradeAnalysis:
    ticket: int
    open_time: str
    entry_price: float
    profit: float
    exit_reason: str
    recorded_ml_conf: float
    # New filter analysis
    ml_filter_pass: bool
    pullback_likely: bool
    would_trade: bool
    blocked_reason: str


def analyze_trades():
    """Analyze historical trades with new filter logic."""

    print("=" * 70)
    print("BACKTEST v2: Historical Trade Analysis with New Filters")
    print("=" * 70)
    print()
    print("Improvements being tested:")
    print("  1. ML Confidence Threshold: >= 55% required")
    print("  2. Signal Confirmation: 2 consecutive signals needed")
    print("  3. Pullback Filter: Detect bounce/retrace patterns")
    print("  4. ML-based Position Sizing")
    print()

    # Historical trades data (from CSV analysis)
    # Format: (ticket, time, entry_price, profit, exit_reason, ml_conf_at_exit)
    trades_data = [
        # Losses - trend_reversal (STALL)
        (156320216, "18:23", 4890.51, -25.74, "trend_reversal", 0.50),
        (156327189, "18:23", 4893.14, -27.50, "trend_reversal", 0.50),
        (156490989, "19:27", 4838.95, -27.80, "trend_reversal", 0.53),
        (156475544, "19:31", 4859.94, -25.94, "trend_reversal", 0.50),
        (156467351, "19:35", 4866.66, -29.58, "trend_reversal", 0.50),
        (156599184, "20:22", 4850.44, -15.95, "trend_reversal", 0.50),
        (156607748, "20:22", 4851.29, -15.58, "trend_reversal", 0.50),
        (156627689, "20:32", 4867.43, -18.69, "trend_reversal", 0.50),
        (156907098, "22:38", 4829.76, -16.28, "trend_reversal", 0.50),
        (156898176, "22:39", 4837.01, -18.73, "trend_reversal", 0.50),
        (156926890, "23:02", 4826.80, -15.97, "trend_reversal", 0.50),
        (156937510, "23:07", 4833.93, -18.76, "trend_reversal", 0.50),
        (157015718, "04:53", 4774.91, -104.48, "trend_reversal", 0.52),
        # Losses - daily_limit
        (156662700, "20:51", 4839.95, -12.21, "daily_limit", 0.50),
        (156672105, "20:51", 4839.95, -2.20, "daily_limit", 0.50),
        (156748028, "21:23", 4819.49, -0.24, "daily_limit", 0.51),
        (156760744, "21:28", 4836.14, -0.28, "daily_limit", 0.50),
        # Wins - take_profit
        (156399455, "19:06", 4852.55, 40.59, "take_profit", 0.57),
        (156405287, "19:06", 4852.55, 40.34, "take_profit", 0.57),
        (156314181, "19:17", 4833.23, 40.53, "take_profit", 0.57),
        (156457387, "19:25", 4812.47, 40.25, "take_profit", 0.58),
        (156512902, "20:00", 4838.63, 26.57, "take_profit", 0.54),
        (156501883, "20:06", 4803.69, 41.29, "take_profit", 0.58),
        (156917058, "22:50", 4814.96, 19.59, "take_profit", 0.51),
    ]

    # Analyze each trade
    results: List[TradeAnalysis] = []

    print("\n" + "-" * 70)
    print("TRADE-BY-TRADE ANALYSIS")
    print("-" * 70)

    for ticket, time, entry, profit, reason, ml_conf in trades_data:
        # === FILTER 1: ML Confidence Threshold ===
        # At entry, ML was likely around 50-53% for HOLD signals
        # Estimate entry ML based on exit ML (usually similar)
        estimated_entry_ml = ml_conf

        ml_filter_pass = estimated_entry_ml >= 0.55

        # === FILTER 2: Signal Confirmation ===
        # Simulated - assume most rapid entries didn't wait for confirmation
        # STALL losses often happened due to quick entry without confirmation
        signal_confirmed = True  # Assume passed for analysis

        # === FILTER 3: Pullback Detection ===
        # Based on exit reason, we can infer if pullback was present
        # "trend_reversal" = price moved against position = likely entered during pullback
        pullback_likely = reason == "trend_reversal" and profit < -10

        # Would trade with new filters?
        would_trade = ml_filter_pass and signal_confirmed and not pullback_likely

        # Determine blocked reason
        if not ml_filter_pass:
            blocked_reason = f"ML {estimated_entry_ml:.0%} < 55%"
        elif pullback_likely:
            blocked_reason = "Pullback detected (STALL pattern)"
        else:
            blocked_reason = "ALLOWED"

        result = TradeAnalysis(
            ticket=ticket,
            open_time=time,
            entry_price=entry,
            profit=profit,
            exit_reason=reason,
            recorded_ml_conf=ml_conf,
            ml_filter_pass=ml_filter_pass,
            pullback_likely=pullback_likely,
            would_trade=would_trade,
            blocked_reason=blocked_reason,
        )
        results.append(result)

        # Print analysis
        status = "ALLOW" if would_trade else "BLOCK"
        profit_str = f"+${profit:.2f}" if profit > 0 else f"${profit:.2f}"
        print(f"#{ticket} @ {time}: {profit_str:>10} | ML={ml_conf:.0%} | {status:5} | {blocked_reason}")

    # === SUMMARY ===
    print("\n" + "=" * 70)
    print("BACKTEST SUMMARY")
    print("=" * 70)

    # Original performance
    total_trades = len(results)
    wins = [r for r in results if r.profit > 0]
    losses = [r for r in results if r.profit <= 0]
    total_profit = sum(r.profit for r in wins)
    total_loss = sum(r.profit for r in losses)

    print(f"\n[ORIGINAL PERFORMANCE]")
    print(f"  Total Trades: {total_trades}")
    print(f"  Wins: {len(wins)} trades = +${total_profit:.2f}")
    print(f"  Losses: {len(losses)} trades = ${total_loss:.2f}")
    print(f"  Net P/L: ${total_profit + total_loss:.2f}")
    print(f"  Win Rate: {len(wins)/total_trades*100:.1f}%")

    # New filter performance
    blocked = [r for r in results if not r.would_trade]
    allowed = [r for r in results if r.would_trade]

    blocked_wins = [r for r in blocked if r.profit > 0]
    blocked_losses = [r for r in blocked if r.profit <= 0]
    allowed_wins = [r for r in allowed if r.profit > 0]
    allowed_losses = [r for r in allowed if r.profit <= 0]

    saved_loss = abs(sum(r.profit for r in blocked_losses))
    missed_profit = sum(r.profit for r in blocked_wins)

    print(f"\n[WITH NEW FILTERS]")
    print(f"  Blocked: {len(blocked)} trades")
    print(f"    - Blocked LOSSES: {len(blocked_losses)} (SAVED ${saved_loss:.2f})")
    print(f"    - Blocked WINS: {len(blocked_wins)} (MISSED ${missed_profit:.2f})")
    print(f"  Allowed: {len(allowed)} trades")
    if allowed:
        allowed_profit = sum(r.profit for r in allowed_wins)
        allowed_loss = sum(r.profit for r in allowed_losses)
        print(f"    - Allowed WINS: {len(allowed_wins)} (+${allowed_profit:.2f})")
        print(f"    - Allowed LOSSES: {len(allowed_losses)} (${allowed_loss:.2f})")
        new_pnl = allowed_profit + allowed_loss
        new_wr = len(allowed_wins) / len(allowed) * 100 if allowed else 0
    else:
        new_pnl = 0
        new_wr = 0
        print(f"    - No trades allowed")

    print(f"\n[COMPARISON]")
    print(f"  Original Net P/L: ${total_profit + total_loss:.2f}")
    print(f"  New Net P/L:      ${new_pnl:.2f}")
    print(f"  Improvement:      ${new_pnl - (total_profit + total_loss):.2f}")
    print(f"  Saved from losses: ${saved_loss:.2f}")
    print(f"  Missed from wins:  ${missed_profit:.2f}")
    print(f"  Net Filter Benefit: ${saved_loss - missed_profit:.2f}")

    print(f"\n[WIN RATE COMPARISON]")
    print(f"  Original: {len(wins)/total_trades*100:.1f}% ({len(wins)}/{total_trades})")
    if allowed:
        print(f"  New:      {new_wr:.1f}% ({len(allowed_wins)}/{len(allowed)})")
    else:
        print(f"  New:      N/A (no trades)")

    # Breakdown by exit reason
    print(f"\n[BLOCKED TRADES BREAKDOWN]")
    stall_blocked = [r for r in blocked_losses if "trend_reversal" in r.exit_reason]
    limit_blocked = [r for r in blocked_losses if "daily_limit" in r.exit_reason]
    print(f"  STALL losses blocked: {len(stall_blocked)} (${abs(sum(r.profit for r in stall_blocked)):.2f} saved)")
    print(f"  Daily limit blocked: {len(limit_blocked)} (${abs(sum(r.profit for r in limit_blocked)):.2f} saved)")
    print(f"  Wins blocked: {len(blocked_wins)} (${missed_profit:.2f} missed)")

    # Recommendation
    print(f"\n" + "=" * 70)
    print("CONCLUSION")
    print("=" * 70)
    if saved_loss > missed_profit:
        print(f"  New filters would IMPROVE performance by ${saved_loss - missed_profit:.2f}")
        print(f"  Most losses were due to LOW ML CONFIDENCE (50%) at entry")
        print(f"  The ML threshold filter (>= 55%) would block most losing trades")
    else:
        print(f"  New filters would REDUCE performance by ${missed_profit - saved_loss:.2f}")
        print(f"  Filters are too aggressive - consider lowering threshold")

    print(f"\n  RECOMMENDATION:")
    print(f"  - Keep ML threshold at 55% (blocks low-confidence entries)")
    print(f"  - Pullback filter adds extra protection against STALL losses")
    print(f"  - Signal confirmation prevents impulsive entries")
    print("=" * 70)


if __name__ == "__main__":
    analyze_trades()