🔬【検証】ゴトー日にSL/TPつけたら期待値下がる？961パターン総当たりした結果...

SLに引っかかる = 上昇途中で強制的にショート（売り）
TPに引っかかる = 上昇途中で強制的にショート（売り）

📈 通貨ペア: USDJPY
⏰ 時間足: 1分足（SL/TP判定用）
📅 データ: 約1.5年分（500,000本）
🎯 トレード数: 96回（全ゴトー日）/ 15回（25日のみ）
⏰ エントリー: 9:00 JST
💰 決済: 9:55 JST（SL/TPに引っかからなければ）

SLなし: 負けるとき平均 -15pips とか喰らう
SL5pips: 負けても -5pips で済む
→ トータルで改善！

SL/TPなし: 途中+5pips → 最終-10pips（損）
TP5pips:   途中+5pips → TP発動！+5pips（利確）

25日の典型的な動き:
9:00 → 9:55 で +10〜15pips の上昇

SL/TPなし: +10pips 取れる
TP5pips:   +5pips で利確（残り5pips逃す）
SL5pips:   途中の下押しで刈られる（+10pips → -5pips）

弱いゴトー日の典型的な動き:
9:00 → 9:55 で -10pips の下落

SL/TPなし: -10pips の損失
SL5pips:   -5pips で損切り（損失軽減）
TP5pips:   途中+5pipsでも最終-10pips → 利確できてればラッキー

【決済=ショート理論】

強い上昇トレンドがある時:
  → SL/TPは「上昇途中でショートを建てる」のと同じ
  → 期待値減少 ✅

上昇トレンドがない/弱い時:
  → SL/TPは「大負けを防ぐ保険」として機能
  → 期待値改善 ✅

if day == 25:
    # 強い上昇を最大限取る
    entry_long(sl=None, tp=None)

if day in [5, 10, 15, 20]:
    # 損失を抑える
    entry_long(sl=5, tp=5)  # または sl=10, tp=10

if day == 25:
    entry_long(sl=None, tp=None)
else:
    pass  # やらない

"""
ゴトー日 × SL/TP検証（高速版）

高速化ポイント:
1. 全ゴトー日の価格データを一度だけ取得
2. 各日の最高値・最安値・終値を事前計算
3. NumPyでベクトル化処理
"""

import MetaTrader5 as mt5
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from calendar import monthrange

# 設定
SYMBOL = "USDJPY"
TIMEFRAME = mt5.TIMEFRAME_M1
ENTRY_HOUR, ENTRY_MINUTE = 9, 0
EXIT_HOUR, EXIT_MINUTE = 9, 55

# 5pips刻み、0〜150pips
SL_RANGE = list(range(0, 151, 5))
TP_RANGE = list(range(0, 151, 5))


def extract_trade_data(df):
    """
    各ゴトー日のエントリー価格、期間中の最高値・最安値、決済価格を抽出
    """
    trades = []
    df['date'] = df.index.date

    for date in df['date'].unique():
        date_dt = datetime.combine(date, datetime.min.time())
        if not is_gotobi_adjusted(date_dt):
            continue

        day_data = df[df['date'] == date]

        entry_time = datetime.combine(date, datetime.min.time().replace(
            hour=ENTRY_HOUR, minute=ENTRY_MINUTE))
        exit_time = datetime.combine(date, datetime.min.time().replace(
            hour=EXIT_HOUR, minute=EXIT_MINUTE))

        # エントリー価格
        entry_mask = (day_data.index >= entry_time - timedelta(minutes=1)) & \
                     (day_data.index <= entry_time + timedelta(minutes=1))
        entry_data = day_data[entry_mask]
        if len(entry_data) == 0:
            continue

        entry_price = entry_data.iloc[0]['close']

        # 期間中のデータ
        period_mask = (day_data.index >= entry_time) & (day_data.index <= exit_time)
        period_data = day_data[period_mask]
        if len(period_data) == 0:
            continue

        trades.append({
            'date': date,
            'entry_price': entry_price,
            'exit_price': period_data.iloc[-1]['close'],
            'period_high': period_data['high'].max(),
            'period_low': period_data['low'].min(),
            'max_profit_pips': (period_data['high'].max() - entry_price) * 100,
            'max_loss_pips': (entry_price - period_data['low'].min()) * 100,
            'no_sltp_pips': (period_data.iloc[-1]['close'] - entry_price) * 100,
        })

    return pd.DataFrame(trades)


def simulate_fast(trades_df, sl_pips, tp_pips):
    """
    ベクトル化したSL/TP判定
    """
    n = len(trades_df)
    if n == 0:
        return None

    max_profit = trades_df['max_profit_pips'].values
    max_loss = trades_df['max_loss_pips'].values
    no_sltp = trades_df['no_sltp_pips'].values

    # SL/TP判定（ベクトル演算）
    if sl_pips > 0 and tp_pips > 0:
        sl_hit = max_loss >= sl_pips
        tp_hit = max_profit >= tp_pips
        # SL優先（保守的な見積もり）
        pips = np.where(sl_hit, -sl_pips, np.where(tp_hit, tp_pips, no_sltp))
    elif sl_pips > 0:
        sl_hit = max_loss >= sl_pips
        pips = np.where(sl_hit, -sl_pips, no_sltp)
    elif tp_pips > 0:
        tp_hit = max_profit >= tp_pips
        pips = np.where(tp_hit, tp_pips, no_sltp)
    else:
        pips = no_sltp

    return {
        'sl_pips': sl_pips,
        'tp_pips': tp_pips,
        'trades': n,
        'win_rate': (pips > 0).sum() / n * 100,
        'avg_pips': pips.mean(),
    }


def run_analysis(trades_df):
    """全SL/TP組み合わせを高速検証"""
    results = []
    for sl in SL_RANGE:
        for tp in TP_RANGE:
            r = simulate_fast(trades_df, sl, tp)
            if r:
                results.append(r)
    return pd.DataFrame(results)


# 使い方:
# 1. MT5からデータ取得
# 2. trades = extract_trade_data(df)
# 3. results = run_analysis(trades)
# 4. ヒートマップで可視化

# 各日の「最高値」「最安値」「決済価格」を事前計算
# → SL/TPの判定は単純な比較演算で済む

# forループではなく、配列演算で一気に処理
pips = np.where(sl_hit, -sl_pips, np.where(tp_hit, tp_pips, no_sltp))

# 31 × 31 = 961パターンを高速検証
# オーバーフィットを避けて全体傾向を把握