"""
多策略组合回测 — 目标: 1000 USDT/月

思路: 同时运行多个不同参数的 EMA 策略，它们在不同时间段产生信号，
      彼此信号不重叠时各自独立开仓，等于"多个策略并行跑"。

条件:
    - 每笔: 100 USDT 保证金, 100x 杠杆, 名义 10,000 USDT
    - 90% 返佣
    - 最低持仓 > 3 分钟
    - ETH 合约, 2025 全年

测试方案:
    A) 单策略加大仓位 (500U/1000U)
    B) 多策略组合 (3-5个不同参数策略并行)
    C) 降低 ATR 门槛 + 更宽止损
    D) 综合最优方案
"""
import sys, time, datetime, sqlite3
from pathlib import Path

class EMA:
    __slots__ = ('k', 'v')
    def __init__(self, p):
        self.k = 2.0 / (p + 1); self.v = None
    def update(self, x):
        self.v = x if self.v is None else x * self.k + self.v * (1 - self.k)
        return self.v

def load():
    db = Path(__file__).parent.parent / 'models' / 'database.db'
    s = int(datetime.datetime(2025,1,1).timestamp()) * 1000
    e = int(datetime.datetime(2026,1,1).timestamp()) * 1000
    conn = sqlite3.connect(str(db))
    rows = conn.cursor().execute(
        "SELECT id,open,high,low,close FROM bitmart_eth_1m WHERE id>=? AND id<? ORDER BY id", (s,e)
    ).fetchall()
    conn.close()
    return [(datetime.datetime.fromtimestamp(r[0]/1000.0), r[1], r[2], r[3], r[4]) for r in rows]


def run_strategy(data, fp, sp, bp, atr_min, sl_pct, mh, notional=10000.0):
    """单策略回测，返回交易列表"""
    ef=EMA(fp); es=EMA(sp); eb=EMA(bp)
    H=[]; L=[]; C=[]
    pf_=None; ps_=None
    pos=0; op=0.0; ot=None; pend=None
    hsl=sl_pct*1.5; AP=14
    FEE_RATE=0.0006; REB_RATE=0.90; MIN_H=200
    trades=[]

    for dt,o_,h_,l_,c_ in data:
        p=c_; H.append(h_); L.append(l_); C.append(p)
        fast=ef.update(p); slow=es.update(p); big=eb.update(p)
        atr_pct=0.0
        if len(H)>AP+1:
            s=0.0
            for i in range(-AP,0):
                tr=H[i]-L[i]; d1=abs(H[i]-C[i-1]); d2=abs(L[i]-C[i-1])
                if d1>tr: tr=d1
                if d2>tr: tr=d2
                s+=tr
            atr_pct=s/(AP*p) if p>0 else 0
        cu=pf_ is not None and pf_<=ps_ and fast>slow
        cd=pf_ is not None and pf_>=ps_ and fast<slow
        pf_=fast; ps_=slow

        if pos!=0 and ot is not None:
            pp=(p-op)/op if pos==1 else (op-p)/op
            hsec=(dt-ot).total_seconds()
            if -pp>=hsl:
                pnl=notional*pp; fee=notional*FEE_RATE*2; reb=fee*REB_RATE
                trades.append((pos, op, p, pnl, fee, reb, hsec, ot, dt))
                pos=0; op=0; ot=None; pend=None; continue
            if hsec>=MIN_H:
                dc=False
                if -pp>=sl_pct: dc=True
                elif hsec>=mh: dc=True
                elif pos==1 and cd: dc=True
                elif pos==-1 and cu: dc=True
                elif pend=='cl' and pos==1: dc=True
                elif pend=='cs' and pos==-1: dc=True
                if dc:
                    pnl=notional*pp; fee=notional*FEE_RATE*2; reb=fee*REB_RATE
                    trades.append((pos, op, p, pnl, fee, reb, hsec, ot, dt))
                    pos=0; op=0; ot=None; pend=None
                    if atr_pct>=atr_min:
                        if (cd or fast<slow) and p<big: pos=-1; op=p; ot=dt
                        elif (cu or fast>slow) and p>big: pos=1; op=p; ot=dt
                    continue
            else:
                if pos==1 and cd: pend='cl'
                elif pos==-1 and cu: pend='cs'

        if pos==0 and atr_pct>=atr_min:
            if cu and p>big: pos=1; op=p; ot=dt
            elif cd and p<big: pos=-1; op=p; ot=dt

    if pos!=0:
        p=data[-1][4]; dt=data[-1][0]
        pp=(p-op)/op if pos==1 else (op-p)/op
        pnl=notional*pp; fee=notional*FEE_RATE*2; reb=fee*REB_RATE
        trades.append((pos, op, p, pnl, fee, reb, (dt-ot).total_seconds(), ot, dt))
    return trades


def analyze(trades, label, notional=10000.0):
    """分析交易结果，返回摘要字典"""
    if not trades:
        return {'label': label, 'n': 0, 'net': 0, 'pnl': 0, 'reb': 0, 'fee': 0, 'dd': 0, 'monthly': {}}
    n = len(trades)
    total_pnl = sum(t[3] for t in trades)
    total_fee = sum(t[4] for t in trades)
    total_reb = sum(t[5] for t in trades)
    net = total_pnl - (total_fee - total_reb)

    # 最大回撤
    cum=0; peak=0; dd=0
    for t in trades:
        cum += t[3] - (t[4] - t[5])
        if cum > peak: peak = cum
        if peak - cum > dd: dd = peak - cum

    # 月度
    monthly = {}
    for t in trades:
        k = t[8].strftime('%Y-%m')
        if k not in monthly: monthly[k] = {'n': 0, 'net': 0}
        monthly[k]['n'] += 1
        monthly[k]['net'] += t[3] - (t[4] - t[5])

    wr = len([t for t in trades if t[3]>0]) / n * 100
    return {'label': label, 'n': n, 'net': net, 'pnl': total_pnl, 'reb': total_reb,
            'fee': total_fee, 'dd': dd, 'wr': wr, 'monthly': monthly}


def merge_trades(all_trade_lists):
    """合并多个策略的交易（检查时间冲突：同一时间只能有一个持仓）"""
    # 简单合并：按开仓时间排序，跳过与已有持仓重叠的交易
    all_trades = []
    for trades in all_trade_lists:
        for t in trades:
            all_trades.append(t)
    all_trades.sort(key=lambda x: x[7])  # 按开仓时间排序

    merged = []
    last_close = None
    for t in all_trades:
        open_time = t[7]
        close_time = t[8]
        if last_close is None or open_time >= last_close:
            merged.append(t)
            last_close = close_time
    return merged


def print_comparison(results):
    """打印对比表"""
    print(f"\n{'='*110}", flush=True)
    print(f"  COMPARISON: Target = 1000 USDT/month = 12,000 USDT/year", flush=True)
    print(f"{'='*110}", flush=True)
    print(f"  {'方案':<40} {'交易数':>6} {'年净利':>10} {'月均':>8} {'胜率':>6} {'返佣':>10} {'最大回撤':>10} {'达标':>4}", flush=True)
    print(f"  {'-'*104}", flush=True)

    for r in results:
        monthly_avg = r['net'] / 12
        ok = "Yes" if monthly_avg >= 1000 else "No"
        print(f"  {r['label']:<40} {r['n']:>6} {r['net']:>+10.0f} {monthly_avg:>+8.0f} {r.get('wr',0):>5.1f}% {r['reb']:>10.0f} {r['dd']:>10.0f} {ok:>4}", flush=True)

    print(f"{'='*110}", flush=True)

    # 打印最佳方案的月度明细
    best = max(results, key=lambda x: x['net'])
    print(f"\n  最佳方案: {best['label']}", flush=True)
    print(f"  年净利: {best['net']:+.0f} USDT | 月均: {best['net']/12:+.0f} USDT\n", flush=True)

    if best['monthly']:
        print(f"  {'月份':<8} {'笔数':>5} {'净利润':>10}", flush=True)
        print(f"  {'-'*28}", flush=True)
        for m in sorted(best['monthly'].keys()):
            d = best['monthly'][m]
            print(f"  {m:<8} {d['n']:>5} {d['net']:>+10.0f}", flush=True)
        print(f"  {'-'*28}", flush=True)
        print(f"  {'合计':<8} {best['n']:>5} {best['net']:>+10.0f}", flush=True)


def main():
    print("Loading data...", flush=True)
    data = load()
    print(f"{len(data)} bars loaded\n", flush=True)

    NOTIONAL = 10000.0  # 100U * 100x
    results = []

    # ============================
    # 方案 1: 原始策略（基线）
    # ============================
    t1 = run_strategy(data, 8, 21, 120, 0.003, 0.004, 1800, NOTIONAL)
    results.append(analyze(t1, "A1: EMA(8/21) ATR>0.3% [基线]", NOTIONAL))
    print(f"  A1 done: {len(t1)} trades", flush=True)

    # ============================
    # 方案 2: 加大仓位 - 500U (5倍)
    # ============================
    t2 = run_strategy(data, 8, 21, 120, 0.003, 0.004, 1800, 50000.0)
    results.append(analyze(t2, "A2: 基线 x5 (500U保证金)", 50000.0))
    print(f"  A2 done: {len(t2)} trades", flush=True)

    # ============================
    # 方案 3: 加大仓位 - 1000U (10倍)
    # ============================
    t3 = run_strategy(data, 8, 21, 120, 0.003, 0.004, 1800, 100000.0)
    results.append(analyze(t3, "A3: 基线 x10 (1000U保证金)", 100000.0))
    print(f"  A3 done: {len(t3)} trades", flush=True)

    # ============================
    # 方案 4: 降低ATR到0.15%（更多交易）
    # ============================
    t4 = run_strategy(data, 8, 21, 120, 0.0015, 0.004, 1800, NOTIONAL)
    results.append(analyze(t4, "B1: ATR>0.15% (更频繁)", NOTIONAL))
    print(f"  B1 done: {len(t4)} trades", flush=True)

    # ============================
    # 方案 5: ATR>0.1% + 宽止损0.8%
    # ============================
    t5 = run_strategy(data, 8, 21, 120, 0.001, 0.008, 1800, NOTIONAL)
    results.append(analyze(t5, "B2: ATR>0.1% SL=0.8%", NOTIONAL))
    print(f"  B2 done: {len(t5)} trades", flush=True)

    # ============================
    # 方案 6: ATR>0.2% + SL=0.8% + 更长持仓3600s
    # ============================
    t6 = run_strategy(data, 8, 21, 120, 0.002, 0.008, 3600, NOTIONAL)
    results.append(analyze(t6, "B3: ATR>0.2% SL=0.8% MH=3600", NOTIONAL))
    print(f"  B3 done: {len(t6)} trades", flush=True)

    # ============================
    # 方案 7: 多策略组合（3个不同EMA参数并行，无时间重叠）
    # ============================
    s1 = run_strategy(data, 8, 21, 120, 0.003, 0.004, 1800, NOTIONAL)
    s2 = run_strategy(data, 13, 55, 200, 0.002, 0.005, 1800, NOTIONAL)
    s3 = run_strategy(data, 30, 80, 200, 0.002, 0.008, 3600, NOTIONAL)
    merged3 = merge_trades([s1, s2, s3])
    results.append(analyze(merged3, "C1: 3策略组合 (不重叠)", NOTIONAL))
    print(f"  C1 done: {len(s1)}+{len(s2)}+{len(s3)} -> {len(merged3)} merged", flush=True)

    # ============================
    # 方案 8: 5策略组合
    # ============================
    s4 = run_strategy(data, 20, 55, 120, 0.002, 0.006, 1800, NOTIONAL)
    s5 = run_strategy(data, 8, 34, 200, 0.002, 0.005, 1800, NOTIONAL)
    merged5 = merge_trades([s1, s2, s3, s4, s5])
    results.append(analyze(merged5, "C2: 5策略组合 (不重叠)", NOTIONAL))
    print(f"  C2 done: -> {len(merged5)} merged", flush=True)

    # ============================
    # 方案 9: 3策略组合 + 加大仓位到 300U
    # ============================
    s1b = run_strategy(data, 8, 21, 120, 0.003, 0.004, 1800, 30000.0)
    s2b = run_strategy(data, 13, 55, 200, 0.002, 0.005, 1800, 30000.0)
    s3b = run_strategy(data, 30, 80, 200, 0.002, 0.008, 3600, 30000.0)
    merged3b = merge_trades([s1b, s2b, s3b])
    results.append(analyze(merged3b, "D1: 3策略+300U仓位", 30000.0))
    print(f"  D1 done: -> {len(merged3b)} merged", flush=True)

    # ============================
    # 方案 10: 3策略组合 + 500U仓位
    # ============================
    s1c = run_strategy(data, 8, 21, 120, 0.003, 0.004, 1800, 50000.0)
    s2c = run_strategy(data, 13, 55, 200, 0.002, 0.005, 1800, 50000.0)
    s3c = run_strategy(data, 30, 80, 200, 0.002, 0.008, 3600, 50000.0)
    merged3c = merge_trades([s1c, s2c, s3c])
    results.append(analyze(merged3c, "D2: 3策略+500U仓位", 50000.0))
    print(f"  D2 done: -> {len(merged3c)} merged", flush=True)

    # ============================
    # 方案 11: 多策略并行（允许同时持仓，各策略独立运行）
    # ============================
    # 如果账户允许同时持有多个仓位（不同策略各自独立）
    s1_r = analyze(s1, "sub1")
    s2_r = analyze(run_strategy(data, 13, 55, 200, 0.002, 0.005, 1800, NOTIONAL), "sub2")
    s3_r = analyze(run_strategy(data, 30, 80, 200, 0.002, 0.008, 3600, NOTIONAL), "sub3")
    s4_r = analyze(run_strategy(data, 20, 55, 120, 0.002, 0.006, 1800, NOTIONAL), "sub4")
    s5_r = analyze(run_strategy(data, 8, 34, 200, 0.002, 0.005, 1800, NOTIONAL), "sub5")

    # 合并月度（允许重叠 = 各自独立计算再加总）
    parallel_net = s1_r['net'] + s2_r['net'] + s3_r['net'] + s4_r['net'] + s5_r['net']
    parallel_reb = s1_r['reb'] + s2_r['reb'] + s3_r['reb'] + s4_r['reb'] + s5_r['reb']
    parallel_fee = s1_r['fee'] + s2_r['fee'] + s3_r['fee'] + s4_r['fee'] + s5_r['fee']
    parallel_pnl = s1_r['pnl'] + s2_r['pnl'] + s3_r['pnl'] + s4_r['pnl'] + s5_r['pnl']
    parallel_n = s1_r['n'] + s2_r['n'] + s3_r['n'] + s4_r['n'] + s5_r['n']
    parallel_dd = max(s1_r['dd'], s2_r['dd'], s3_r['dd'], s4_r['dd'], s5_r['dd']) * 2  # 保守估计

    # 合并月度
    all_months = set()
    for sr in [s1_r, s2_r, s3_r, s4_r, s5_r]:
        all_months.update(sr['monthly'].keys())
    parallel_monthly = {}
    for m in all_months:
        n_m = 0; net_m = 0
        for sr in [s1_r, s2_r, s3_r, s4_r, s5_r]:
            if m in sr['monthly']:
                n_m += sr['monthly'][m]['n']
                net_m += sr['monthly'][m]['net']
        parallel_monthly[m] = {'n': n_m, 'net': net_m}

    results.append({
        'label': "E1: 5策略并行(允许同时持仓) 100U each",
        'n': parallel_n, 'net': parallel_net, 'pnl': parallel_pnl,
        'reb': parallel_reb, 'fee': parallel_fee, 'dd': parallel_dd,
        'wr': 0, 'monthly': parallel_monthly
    })
    print(f"  E1 done: {parallel_n} total trades (parallel)", flush=True)

    # ============================
    # 方案 12: 5策略并行 + 200U仓位
    # ============================
    N2 = 20000.0
    ps1 = analyze(run_strategy(data, 8, 21, 120, 0.003, 0.004, 1800, N2), "p1")
    ps2 = analyze(run_strategy(data, 13, 55, 200, 0.002, 0.005, 1800, N2), "p2")
    ps3 = analyze(run_strategy(data, 30, 80, 200, 0.002, 0.008, 3600, N2), "p3")
    ps4 = analyze(run_strategy(data, 20, 55, 120, 0.002, 0.006, 1800, N2), "p4")
    ps5 = analyze(run_strategy(data, 8, 34, 200, 0.002, 0.005, 1800, N2), "p5")

    p_net = ps1['net']+ps2['net']+ps3['net']+ps4['net']+ps5['net']
    p_reb = ps1['reb']+ps2['reb']+ps3['reb']+ps4['reb']+ps5['reb']
    p_fee = ps1['fee']+ps2['fee']+ps3['fee']+ps4['fee']+ps5['fee']
    p_pnl = ps1['pnl']+ps2['pnl']+ps3['pnl']+ps4['pnl']+ps5['pnl']
    p_n = ps1['n']+ps2['n']+ps3['n']+ps4['n']+ps5['n']
    p_dd = max(ps1['dd'],ps2['dd'],ps3['dd'],ps4['dd'],ps5['dd'])*2

    p_monthly = {}
    for m in all_months:
        n_m=0; net_m=0
        for sr in [ps1,ps2,ps3,ps4,ps5]:
            if m in sr['monthly']:
                n_m+=sr['monthly'][m]['n']; net_m+=sr['monthly'][m]['net']
        p_monthly[m] = {'n': n_m, 'net': net_m}

    results.append({
        'label': "E2: 5策略并行 200U each",
        'n': p_n, 'net': p_net, 'pnl': p_pnl,
        'reb': p_reb, 'fee': p_fee, 'dd': p_dd,
        'wr': 0, 'monthly': p_monthly
    })
    print(f"  E2 done: {p_n} total trades (parallel 200U)", flush=True)

    # ============================
    # 打印对比
    # ============================
    print_comparison(results)

    # 保存
    csv = Path(__file__).parent.parent / 'multi_strategy_results.csv'
    with open(csv, 'w', encoding='utf-8-sig') as f:
        f.write("方案,交易数,年净利,月均,返佣,最大回撤\n")
        for r in results:
            f.write(f"{r['label']},{r['n']},{r['net']:.0f},{r['net']/12:.0f},{r['reb']:.0f},{r['dd']:.0f}\n")
    print(f"\nSaved: {csv}", flush=True)


if __name__ == '__main__':
    main()