import pandas as pd
import numpy as np

def run_simulation():
    print("--- U2Predator V4.1 Trailing Simulator ---")
    df = pd.read_parquet('native_rates_M1.parquet')
    
    # Calculate Donchian Channels
    df['dc_fast_h'] = df['high'].rolling(14).max()
    df['dc_fast_l'] = df['low'].rolling(14).min()
    df['dc_fast_mid'] = (df['dc_fast_h'] + df['dc_fast_l']) / 2

    df['dc_slow_h'] = df['high'].rolling(21).max()
    df['dc_slow_l'] = df['low'].rolling(21).min()
    df['dc_slow_mid'] = (df['dc_slow_h'] + df['dc_slow_l']) / 2
    
    df['mid_gap'] = df['dc_fast_mid'] - df['dc_slow_mid']
    
    # Shift to prevent lookahead
    df['dc_f_mid_1'] = df['dc_fast_mid'].shift(1)
    df['dc_s_mid_1'] = df['dc_slow_mid'].shift(1)
    
    df['mid_upper'] = df[['dc_f_mid_1', 'dc_s_mid_1']].max(axis=1)
    df['mid_lower'] = df[['dc_f_mid_1', 'dc_s_mid_1']].min(axis=1)

    # Simplified Entry: True Crossover + Expansion
    df['is_bull_cross'] = (df['open'].shift(1) < df['mid_upper']) & (df['close'].shift(1) > df['mid_upper'])
    df['is_bear_cross'] = (df['open'].shift(1) > df['mid_lower']) & (df['close'].shift(1) < df['mid_lower'])
    
    df['gap_expansion'] = df['mid_gap'].abs() >= 1.00 # 100 pts
    
    # Entry Signals
    df['signal'] = 0
    df.loc[df['is_bull_cross'] & df['gap_expansion'] & (df['mid_gap'] > 0), 'signal'] = 1
    df.loc[df['is_bear_cross'] & df['gap_expansion'] & (df['mid_gap'] < 0), 'signal'] = -1
    
    # Simulate Trades
    trades = []
    in_trade = False
    trade_dir = 0
    entry_price = 0
    hard_sl = 0
    locked_sl = 0
    max_float = 0
    
    points = 0.01 # Assuming 2 decimal pricing for Gold, 1 point = 0.01 (Wait, MT5 XAUUSD pnt = 0.01)
    
    for row in df.itertuples():
        if getattr(row, 'signal') == 1 and not in_trade:
            in_trade = True
            trade_dir = 1
            entry_price = getattr(row, 'open')
            hard_sl = entry_price - 21.00 # 2100 pts SL Mode A
            locked_sl = hard_sl
            max_float = 0
            continue
            
        if getattr(row, 'signal') == -1 and not in_trade:
            in_trade = True
            trade_dir = -1
            entry_price = getattr(row, 'open')
            hard_sl = entry_price + 21.00
            locked_sl = hard_sl
            max_float = 0
            continue
            
        if in_trade:
            if trade_dir == 1:
                current_high_float = (getattr(row, 'high') - entry_price) / points
                current_low_float = (getattr(row, 'low') - entry_price) / points
                close_float = (getattr(row, 'close') - entry_price) / points
                
                max_float = max(max_float, current_high_float)
                
                # Check Lock Updates (evaluate HIGH of candle)
                if max_float >= 600:
                    locked_sl = max(locked_sl, entry_price + 5.00) # Stage 3 Lock 500pts minimum
                elif max_float >= 450:
                    locked_sl = max(locked_sl, entry_price + 3.50) # Stage 2 Lock 350pts
                elif max_float >= 350:
                    locked_sl = max(locked_sl, entry_price + 3.00) # Stage 1 Lock 300pts
                
                # Check Exit (evaluate LOW of candle against SL)
                if getattr(row, 'low') <= locked_sl:
                    pnl = (locked_sl - entry_price) / points
                    pnl -= 50 # 50 pts Spread penalty
                    trades.append(pnl)
                    in_trade = False
                    
            elif trade_dir == -1:
                current_high_float = (entry_price - getattr(row, 'low')) / points
                current_low_float = (entry_price - getattr(row, 'high')) / points
                
                max_float = max(max_float, current_high_float)
                
                if max_float >= 600:
                    locked_sl = min(locked_sl, entry_price - 5.00)
                elif max_float >= 450:
                    locked_sl = min(locked_sl, entry_price - 3.50)
                elif max_float >= 350:
                    locked_sl = min(locked_sl, entry_price - 3.00)
                    
                if getattr(row, 'high') >= locked_sl:
                    pnl = (entry_price - locked_sl) / points
                    pnl -= 50 # 50 pts Spread penalty
                    trades.append(pnl)
                    in_trade = False

    t_df = pd.Series(trades)
    print(f"Total Trades: {len(t_df)}")
    if len(t_df) > 0:
        print(f"Wins: {len(t_df[t_df > 0])}")
        print(f"Losses: {len(t_df[t_df < 0])}")
        print(f"Win Rate: {(len(t_df[t_df > 0]) / len(t_df))*100:.2f}%")
        print(f"Avg Win: {t_df[t_df > 0].mean():.2f} pts")
        print(f"Avg Loss: {t_df[t_df < 0].mean():.2f} pts")
        print(f"Net Profit Expected: {t_df.sum():.2f} pts")

if __name__ == '__main__':
    run_simulation()