# -*- coding: utf-8 -*-
"""
单账户合并引擎：主池145 + A股行业基30，同一个账户里同时跑，各用各的参数
========================================================================
与「静态资金分仓」和「合并成一个池」都不同：

  静态分仓   = 两条独立曲线按固定比例相加（隐含每根bar免费再平衡，且各自独立熔断）
  合并成一个池 = 一张池子、一套参数、只挑 top-K（已实测 Calmar 1.85 → 1.02）
  ★本引擎   = 一张账户、两套参数、两个独立 sleeve 各自出目标，
              账户层面把两侧目标**相加**后统一下单：
                · 共用一份现金（谁先要钱谁先用，不足则按比例缩量）
                · 共用一份 T+1 账本（当日买入的份额两侧都不能卖）
                · 共用账户级熔断（按账户净值回撤判定，而不是各sleeve各自的回撤）
                · 两侧若选中同一标的，权重相加、只下一次单（省一次交易成本）

信号口径与 backtest_minute.run_grid_run 完全一致（截至上一根bar、当日 dedup/vol 预计算）：
  - sleeve M：池 145， eval/mom/K/minTR 由参数给定（默认与已部署 30 分钟版一致）
  - sleeve A：池 30（A股行业主题），参数独立（默认 = poolA 扫描出的最优）
  - 每侧维护自己的「参考目标 ref」（逐只滞回，|Δw| ≥ 该侧阈值才更新），
    这等价于「两个策略各自照常运行」，只是把钱放在同一个账户。

产出：replay_minute_out/mixacct_<label>.csv（日频净值曲线）
      replay_minute_out/mixacct_summary.csv（全部配置指标）

用法：
  PYTHONHASHSEED=0 python mix_engine.py               # 权重谱 + 若干参数对照
  PYTHONHASHSEED=0 python mix_engine.py --w 0.8       # 只跑某个主池权重
"""
import argparse
import csv
import io
import json
import math
import os
import sys
import time

import numpy as np
import pandas as pd

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)

import backtest_daily_1m as bt          # noqa: E402
import backtest_minute as bm            # noqa: E402
import precompute_cache as pcache       # noqa: E402

OUT = os.path.join(HERE, 'replay_minute_out')
DATA = os.path.join(HERE, 'data_daily1m')
START, END = '2020-01-02', '2026-09-29'
COMMISSION = 0.00005
CASH_RATE = 0.02

MAIN_STRAT = os.path.join(HERE, '云飞量化复刻_日频1分钟_QMT.py')
A_STRAT = os.path.join(HERE, '云飞量化复刻_日频1分钟_QMT_poolA.py')


# ---------------------------------------------------------------------------
# 预计算：两套池子各自算一份 dedup / vol
# ---------------------------------------------------------------------------
def load_group(strat_path, qfq, axis):
    bt.STRATEGY = strat_path
    pcache.STRATEGY_FILE = strat_path
    return bm.precompute_daily(qfq=qfq, axis=axis)


def _eval_ts(day_of_minute, em, t0, t1):
    """评估点：每日第 0, em, 2em ... 根 bar"""
    out = set()
    dser = pd.Series(day_of_minute)
    for _d, idxs in dser.groupby(dser.values).groups.items():
        idxs = np.asarray(idxs)
        rel = idxs - idxs[0]
        sel = idxs[rel % em == 0]
        out.update(int(x) for x in sel if t0 <= x < t1)
    return out


def run_combined(gM, dM, poolM, gA, dA, poolA, axis, codes, mat, cs,
                 em_M=30, mom_M=15, k_M=3, tr_M=0.01, ma_M=12,
                 em_A=5, mom_A=10, k_A=3, tr_A=0.02, ma_A=12,
                 w_main=0.8, start=START, end=END, commission=None,
                 t1_rule=True, verbose=False, label='comb', loose=False,
                 t1strict=False):
    cfg = gM['CFG']
    max_single = cfg['MAX_SINGLE']
    vt = cfg['VOL_TARGET']
    vfloor = cfg['VOL_FLOOR']
    dd_stop = cfg['DD_STOP']
    dd_cool = cfg['DD_COOLDOWN']

    cpos = {c: j for j, c in enumerate(codes)}
    codesA = set(bt._qmt(x[0]) for x in poolA)
    codesM = set(bt._qmt(x[0]) for x in poolM)

    t0 = int(np.searchsorted(axis.values, np.datetime64(start)))
    t1 = len(axis)
    if end:
        t1 = int(np.searchsorted(axis.values,
                                 np.datetime64(end) + np.timedelta64(1, 'D')))
    BPD = bm.BARS_PER_DAY
    day_of_minute = axis.normalize().values
    evM = _eval_ts(day_of_minute, em_M, t0, t1)
    evA = _eval_ts(day_of_minute, em_A, t0, t1)

    GROUPS = {
        'M': dict(ev=evM, daily=dM, mom=mom_M * BPD, ma=ma_M * BPD, k=k_M, tr=tr_M,
                  codes=codesM),
        'A': dict(ev=evA, daily=dA, mom=mom_A * BPD, ma=ma_A * BPD, k=k_A, tr=tr_A,
                  codes=codesA),
    }

    def group_target(t, G):
        """单侧目标权重（sleeve 内部口径，合计 ≤ 1）——与 run_grid_run 逐行一致"""
        j_t = t - 1
        j_b = j_t - G['mom']
        j_m0 = j_t - G['ma'] + 1
        info = G['info']
        sigs = {}
        if j_b < 0:
            return {}
        p_now = mat[:, j_t].astype(np.float64)
        p_base = mat[:, j_b].astype(np.float64)
        ma = (cs[:, j_t + 1] - cs[:, j_m0]) / G['ma'] if j_m0 >= 0 else None
        for code in info['dedup']:
            j = cpos.get(code)
            if j is None:
                continue
            v = info['vol'].get(code)
            if v is None or v <= 0:
                continue
            a = p_base[j]
            b = p_now[j]
            if a <= 0 or b <= 0 or np.isnan(a) or np.isnan(b):
                continue
            mom = b / a - 1.0
            if mom <= 0:
                continue
            if ma is not None and not (b > ma[j]):
                continue
            sigs[code] = (mom, max(v, vfloor))
        if not sigs:
            return {}
        cands = sorted(sigs.items(), key=lambda kv: -kv[1][0])[:G['k']]
        raw = [(c, 1.0 / iv[1]) for c, iv in cands]
        tot = sum(w for _, w in raw)
        target = {}
        if tot > 0:
            for c, w in raw:
                target[c] = min(w / tot, max_single)
        if vt:
            pv = math.sqrt(sum((w * sigs[c][1]) ** 2 for c, w in target.items()))
            if pv > vt and pv > 0:
                s = vt / pv
                target = {c: w * s for c, w in target.items()}
        tot2 = sum(target.values())
        if tot2 > 1.0:
            target = {c: w / tot2 for c, w in target.items()}
        return target

    nav = 1.0
    peak = 1.0
    hold = {}
    bought_today = {}
    cum_bought = {}              # ★当日累计买入（严格 T+1 的锁定口径）
    t1_viol = 0.0                # 诊断：默认口径下「实际卖出了当日买入份额」的量
    t1_viol_n = 0
    refM, refA = {}, {}
    halted, cooldown = False, 0
    n_trig = {'M': 0, 'A': 0}
    n_exec = 0
    t1_blocked = 0
    turn = {'M': 0.0, 'A': 0.0}
    curve_t, curve_v = [], []
    log = []
    n_hold_sum, n_days = 0, 0
    overlap_days = 0
    max_hold = 0
    prev_day = None
    cash_rate_min = CASH_RATE / 244.0 / BPD
    comm = COMMISSION if commission is None else commission

    for t in range(t0, t1):
        d = day_of_minute[t]
        if d != prev_day:
            # 上一交易日结束时的两侧目标与账户持仓 → 「互补性」统计
            if prev_day is not None:
                union = set(refM) | set(refA)
                inter = set(refM) & set(refA)
                n_days += 1
                n_hold_sum += len(union)
                max_hold = max(max_hold, len(union))
                if inter:
                    overlap_days += 1
            prev_day = d
            bought_today = {}
            cum_bought = {}
            if halted:
                if cooldown > 0:
                    cooldown -= 1
                if cooldown <= 0:
                    halted = False
                    peak = nav
                    log.append((str(pd.Timestamp(d).date()), 'RESUME', 0.0))

        # ---- 净值推进（按旧权重的固定权重组合） ----
        if hold:
            r = 0.0
            for code, w in hold.items():
                j = cpos.get(code)
                if j is None:
                    continue
                p0 = mat[j, t - 1]
                p1 = mat[j, t]
                if p0 > 0 and p1 > 0 and not np.isnan(p0) and not np.isnan(p1):
                    r += w * (p1 / p0 - 1.0)
            cash_w = 1.0 - sum(hold.values())
        else:
            r = 0.0
            cash_w = 1.0
        if cash_w > 1e-9:
            r += cash_w * cash_rate_min
        nav *= (1.0 + r)

        # ---- 两侧各自的评估（互不影响），合并后由账户统一下单 ----
        # ★滞回锚点必须锚在「该 sleeve 的实际持仓」而不是「上次目标」——
        #   离线引擎就是这么做的（eff = 当前实际权重 if 偏离 < 阈值 else 新目标）。
        #   若锚在"上次目标"，买入被缩量或 T+1 挡住后就不会补单/清仓，残仓会一直挂着。
        if t > t0 and not halted:
            ds = str(pd.Timestamp(d).date())
            evaluated = []
            for tag in ('M', 'A'):
                G = GROUPS[tag]
                wX = w_main if tag == 'M' else (1.0 - w_main)
                if wX <= 1e-9 or t not in G['ev']:
                    continue
                info = G['daily'].get(ds)
                if info is None:
                    continue
                G['info'] = info
                tgt = group_target(t, G)
                curX = {}
                for kk in G['codes']:
                    if kk in hold:
                        curX[kk] = hold[kk] / wX          # 该 sleeve 自己的账面
                eff = {}
                for kk in set(tgt) | set(curX):
                    tw = tgt.get(kk, 0.0)
                    cw = curX.get(kk, 0.0)
                    eff[kk] = tw if abs(tw - cw) >= G['tr'] else cw
                if tag == 'M':
                    refM = eff
                else:
                    refA = eff
                evaluated.append(tag)

            if evaluated:
                desired = {}
                for c, w in refM.items():
                    if w > 0:
                        desired[c] = desired.get(c, 0.0) + w_main * w
                for c, w in refA.items():
                    if w > 0:
                        desired[c] = desired.get(c, 0.0) + (1.0 - w_main) * w

                allk = set(desired) | set(hold)
                if loose:
                    # 松耦合：本次只交易「刚刚评估过的那一侧」的标的，
                    # 不去重排另一侧的仓位（消除互相触发产生的额外换手）
                    allow = set()
                    for tag in evaluated:
                        allow |= GROUPS[tag]['codes']
                    allk = set(kk for kk in allk if kk in allow)
                red, inc = {}, {}
                lock = cum_bought if t1strict else bought_today
                for kk in allk:
                    cur = hold.get(kk, 0.0)
                    e = desired.get(kk, 0.0)
                    if e < cur - 1e-12:
                        sellable = max(0.0, cur - lock.get(kk, 0.0))
                        # ★诊断：默认口径下「当日买入锁定」会被重建冲掉，
                        #   这里用「当日累计买入」的真实锁定口径统计违规量
                        true_sellable = max(0.0, cur - cum_bought.get(kk, 0.0))
                        if (cur - e) > true_sellable + 1e-9:
                            t1_viol += (cur - e) - true_sellable
                            t1_viol_n += 1
                        if t1_rule and sellable < (cur - e) - 1e-12:
                            t1_blocked += 1
                        red[kk] = min(cur - e, sellable) if t1_rule else (cur - e)
                    elif e > cur + 1e-12:
                        inc[kk] = e - cur
                freed = sum(red.values())
                des = sum(inc.values())
                avail = max(0.0, 1.0 - sum(hold.values())) + freed
                scale = min(1.0, avail / des) if des > 1e-12 else 0.0
                new_hold, to = {}, 0.0
                for kk in allk:
                    w = hold.get(kk, 0.0) - red.get(kk, 0.0) + inc.get(kk, 0.0) * scale
                    if w > 1e-9:
                        new_hold[kk] = w
                    d_ = red.get(kk, 0.0) + inc.get(kk, 0.0) * scale
                    to += d_
                    turn['A' if kk in codesA else 'M'] += d_
                # ★未被本次交易的持仓原样保留（松耦合时另一侧的仓位不能被丢掉）
                for kk, w in hold.items():
                    if kk not in allk and w > 1e-9:
                        new_hold[kk] = w
                for tag in evaluated:
                    G = GROUPS[tag]
                    wX = w_main if tag == 'M' else (1.0 - w_main)
                    ref = refM if tag == 'M' else refA
                    own = sum(abs(wX * ref.get(kk, 0.0) - hold.get(kk, 0.0))
                              for kk in set(ref) | set(hold) if kk in G['codes'])
                    if own > 1e-6:
                        n_trig[tag] += 1
                if to > 1e-9:
                    nav *= (1.0 - to * comm)
                    hold = new_hold
                    nb = {}
                    for kk, v in bought_today.items():
                        if kk not in allk and v > 1e-9:
                            nb[kk] = v          # 本次没动的标的：T+1 锁定保留
                    for kk in inc:
                        if inc[kk] * scale > 1e-9:
                            nb[kk] = inc[kk] * scale
                    bought_today = nb
                    # 严格口径：当日累计买入（卖出只能来自未锁定部分）
                    for kk in inc:
                        amt = inc[kk] * scale
                        if amt > 1e-9:
                            cum_bought[kk] = min(cum_bought.get(kk, 0.0) + amt,
                                                 hold.get(kk, 0.0))
                    n_exec += 1
                    if verbose:
                        print('  %s 账户调仓 -> %s' % (
                            axis[t], {c: round(w, 3) for c, w in hold.items()}))

        # ---- 账户级熔断 ----
        peak = max(peak, nav)
        dd = nav / peak - 1.0
        if not halted and dd < -dd_stop:
            halted = True
            cooldown = dd_cool
            if t1_rule:
                hold = {kk: w for kk, w in hold.items() if kk in bought_today}
            else:
                hold = {}
            log.append((str(pd.Timestamp(d).date()), 'HALT', dd))

        curve_t.append(t)
        curve_v.append(nav)

    dates = [str(pd.Timestamp(day_of_minute[t]).date()) for t in curve_t]
    daily_curve = []
    for dd_, vv in zip(dates, curve_v):
        if daily_curve and daily_curve[-1][0] == dd_:
            daily_curve[-1] = (dd_, vv)
        else:
            daily_curve.append((dd_, vv))
    return {'curve': daily_curve, 'log': log, 'n_exec': n_exec, 'n_trig': n_trig,
            't1_blocked': t1_blocked, 't1_viol': t1_viol, 't1_viol_n': t1_viol_n,
            'turn': turn,
            'turn_sum': turn['M'] + turn['A'], 'label': label,
            'n_hold_sum': n_hold_sum, 'n_days': n_days, 'overlap_days': overlap_days,
            'max_hold': max_hold}


def _load_curve(p):
    d = {}
    with io.open(p, encoding='utf-8-sig') as f:
        rd = csv.reader(f)
        next(rd)
        for r in rd:
            if len(r) >= 2:
                d[r[0]] = float(r[1])
    return d


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('--w', type=float, default=None, help='只跑某个主池权重')
    ap.add_argument('--t1strict', action='store_true',
                    help='严格 T+1：当日买入份额当日绝不可卖（默认口径会丢掉早期锁定）')
    ap.add_argument('--loose', action='store_true',
                    help='松耦合：只交易刚评估过的一侧，不重排另一侧')
    ap.add_argument('--aparam', default='best', choices=['best', 'cons', 'base'],
                    help='A 侧参数档：best=扫描最优 / cons=e10保守 / base=现有参数')
    ap.add_argument('--start', default=START)
    ap.add_argument('--end', default=END)
    args = ap.parse_args()

    t0 = time.time()
    axis, codes, mat = bm.load_minute('zip')
    qfq = json.load(io.open(os.path.join(DATA, 'qfq_daily_local.json'), encoding='utf-8'))
    print('分钟数据：%d 只 × %d 根' % (len(codes), len(axis)))

    print('\n[1/2] 主池 145 的 dedup/vol ...')
    gM, dM, poolM = load_group(MAIN_STRAT, qfq, axis)
    print('      池 %d 只，%.1fs' % (len(poolM), time.time() - t0))
    t1 = time.time()
    print('\n[2/2] A股行业基 30 的 dedup/vol ...')
    gA, dA, poolA = load_group(A_STRAT, qfq, axis)
    print('      池 %d 只，%.1fs' % (len(poolA), time.time() - t1))

    m = mat.astype(np.float64).copy()
    m[m != m] = 0.0
    cs = np.cumsum(m, axis=1)
    cs = np.hstack([np.zeros((cs.shape[0], 1)), cs[:, :-1]])

    # 参数档位
    P_MAIN = dict(em_M=30, mom_M=15, k_M=3, tr_M=0.01, ma_M=12)
    A_BEST = dict(em_A=5, mom_A=10, k_A=3, tr_A=0.02, ma_A=12)   # poolA 扫描最优
    A_CONS = dict(em_A=10, mom_A=10, k_A=3, tr_A=0.02, ma_A=12)  # 保守档
    A_BASE = dict(em_A=30, mom_A=15, k_A=3, tr_A=0.01, ma_A=12)  # A 用现有参数（对照）

    todos = []
    if args.w is not None:
        tag = '松耦合同账户' if args.loose else '合并同账户'
        PA0 = {'best': A_BEST, 'cons': A_CONS, 'base': A_BASE}[args.aparam]
        extra = {'best': '', 'cons': '（A保守e10）', 'base': '（A用现有参数）'}[args.aparam]
        todos.append(('%s 主%.0f/A%.0f%s' % (tag, args.w * 100, (1 - args.w) * 100, extra),
                      P_MAIN, PA0, args.w, args.loose))
    else:
        for w in (1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.0):
            todos.append(('合并同账户 主%.0f/A%.0f' % (w * 100, (100 - w * 100)),
                          P_MAIN, A_BEST, w, False))
            if 0.0 < w < 1.0:
                todos.append(('松耦合同账户 主%.0f/A%.0f' % (w * 100, (100 - w * 100)),
                              P_MAIN, A_BEST, w, True))
        todos.append(('合并同账户 主80/A20（A用现有参数）', P_MAIN, A_BASE, 0.8, False))
        todos.append(('松耦合同账户 主80/A20（A用现有参数）', P_MAIN, A_BASE, 0.8, True))
        todos.append(('同账户 主80/A20（A保守 e10）', P_MAIN, A_CONS, 0.8, False))
        todos.append(('松耦合同账户 主80/A20（A保守 e10）', P_MAIN, A_CONS, 0.8, True))

    rows = []
    for label, PM, PA, w, loose in todos:
        kw = {}
        kw.update(PM)
        kw.update(PA)
        t2 = time.time()
        res = run_combined(gM, dM, poolM, gA, dA, poolA, axis, codes, mat, cs,
                           w_main=w, start=args.start, end=args.end,
                           commission=COMMISSION, label=label, loose=loose,
                           t1strict=args.t1strict, **kw)
        mtr = bt.metrics({'curve': res['curve'], 'turn_sum': res['turn_sum'],
                          'n_rebal': res['n_exec'], 'no_fill': 0})
        rows.append(dict(label=label, w=w, mtr=mtr, res=res))
        print('%-34s 净值 %7.3f 年化 %6.2f%% 波动 %6.2f%% 回撤 %7.2f%% Calmar %5.2f | '
              '账户调仓 %5d 换手 %7.1f (主 %.0f/A %.0f) 熔断 %d | T+1拦截 %d 违规 %d笔/%.1f | %.0fs' % (
                  label, mtr['nav'], mtr['ann'] * 100, mtr['vol'] * 100,
                  mtr['mdd'] * 100, mtr['calmar'], res['n_exec'], res['turn_sum'],
                  res['turn']['M'], res['turn']['A'],
                  sum(1 for x in res['log'] if x[1] == 'HALT'),
                  res['t1_blocked'], res['t1_viol_n'], res['t1_viol'], time.time() - t2))

        fn = 'mixacct_%sw%02d%s%s.csv' % ('loose_' if loose else '', int(w * 100),
                                          '_Abase' if PA is A_BASE else
                                          ('_Acons' if PA is A_CONS else ''),
                                          '_t1strict' if args.t1strict else '')
        with io.open(os.path.join(OUT, fn), 'w', encoding='utf-8-sig') as f:
            f.write('date,nav\n')
            for d, v in res['curve']:
                f.write('%s,%.8f\n' % (d, v))

    smy_name = 'mixacct_summary.csv' if args.w is None else 'mixacct_single.csv'
    with io.open(os.path.join(OUT, smy_name), 'w',
                 encoding='utf-8-sig', newline='') as f:
        w = csv.writer(f)
        w.writerow(['label', 'w_main', 'nav', 'ann', 'vol', 'sharpe', 'mdd',
                    'calmar', 'n_exec', 'turn', 'turn_M', 'turn_A', 'n_halt',
                    't1_blocked', 't1_viol_n', 't1_viol', 'n_trig_M', 'n_trig_A',
                    'union_avg', 'overlap_days', 'n_days'])
        for r in rows:
            mt = r['mtr']
            rs = r['res']
            w.writerow([r['label'], r['w'], '%.4f' % mt['nav'], '%.4f' % mt['ann'],
                        '%.4f' % mt['vol'], '%.3f' % mt['sharpe'], '%.4f' % mt['mdd'],
                        '%.3f' % mt['calmar'], rs['n_exec'], '%.2f' % rs['turn_sum'],
                        '%.2f' % rs['turn']['M'], '%.2f' % rs['turn']['A'],
                        sum(1 for x in rs['log'] if x[1] == 'HALT'),
                        rs['t1_blocked'], rs['t1_viol_n'], '%.4f' % rs['t1_viol'],
                        rs['n_trig']['M'], rs['n_trig']['A'],
                        '%.2f' % (rs['n_hold_sum'] / max(1, rs['n_days'])),
                        rs['overlap_days'], rs['n_days']])
    print('\n汇总 → %s（总耗时 %.1f 分钟）' % (
        os.path.join(OUT, 'mixacct_summary.csv'), (time.time() - t0) / 60))


if __name__ == '__main__':
    main()