#!/usr/bin/env python3
"""
ОПТИМИЗАЦИЯ дельта-нейтрального грида + walk-forward проверка.

Три рычага доходности сверх базовой модели:
  1. ПЛЕЧО НА ХЕДЖЕ — шорт-перп требует маржу, а не полную стоимость.
     5x → под хедж нужно в 5 раз меньше денег, весь капитал работает в сетке.
  2. МЕЙКЕР-ОРДЕРА на ребалансе хеджа: 0.02% вместо 0.045% тейкера.
  3. ВЫБОР СИМВОЛА: доход грида растёт с волатильностью, а капитал — нет.

Walk-forward: параметр подбирается на окне N, проверяется на N+1.
Итоговая цифра — ВНЕ-ВЫБОРОЧНАЯ, без знания будущего.

Запуск:
    python3 optimize.py            # все символы
    python3 optimize.py SOLUSDT
"""

import sys, os, statistics
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from grid_sim import load

SPOT_FEE   = 0.00075
HEDGE_FEE  = 0.00020    # мейкер на перпе
HEDGE_LEV  = 5.0        # плечо на хедже
FILL_RATIO = 0.80
UNIT       = 100.0
LEVELS     = 20

FUNDING_APR = {"SOLUSDT": -0.8, "BTCUSDT": 3.4, "ETHUSDT": 2.3,
               "AVAXUSDT": 0.0, "LINKUSDT": 0.0, "DOGEUSDT": 0.0}

def run(candles, step_pct, n_levels=LEVELS, unit=UNIT):
    step = step_pct / 100.0
    center = candles[0][4]
    levels = [center * (1 - step * (i + 1)) for i in range(n_levels)]
    pos, realized, hedge, fills, peak = {}, 0.0, 0.0, 0, 0.0
    for ts, o, h, l, c in candles:
        for i, lvl in enumerate(levels):
            if i not in pos and l <= lvl:
                pos[i] = lvl
                hedge += unit * HEDGE_FEE
        for i in list(pos):
            if h >= pos[i] * (1 + step):
                realized += unit * step - (unit * SPOT_FEE + unit * (1 + step) * SPOT_FEE)
                hedge += unit * HEDGE_FEE
                fills += 1
                del pos[i]
        peak = max(peak, len(pos) * unit)
    days = (candles[-1][0] - candles[0][0]) / 86400000
    realized *= FILL_RATIO; hedge *= FILL_RATIO
    capital = n_levels * unit + peak / HEDGE_LEV
    net = realized - hedge
    return {"apr": net / capital * 100 * (365 / days) if days else 0,
            "net": net, "capital": capital, "fills": int(fills * FILL_RATIO),
            "peak": peak, "days": days}

STEPS = [0.5, 0.8, 1.0, 1.2, 1.6, 2.0, 2.5, 3.0]

def walk_forward(sym, folds=5):
    c = load(sym)
    n = len(c) // folds
    chunks = [c[i*n:(i+1)*n] for i in range(folds)]
    fund = FUNDING_APR.get(sym, 0)
    oos, prev = [], None
    per_step = {s: [] for s in STEPS}
    for ch in chunks:
        sc = {}
        for s in STEPS:
            r = run(ch, s)
            total = r["apr"] + fund * (r["peak"] / r["capital"])
            sc[s] = total
            per_step[s].append(total)
        best = max(sc, key=sc.get)
        if prev is not None:
            oos.append(sc[prev])
        prev = best
    stable = sorted(((statistics.mean(v), min(v), s) for s, v in per_step.items()), reverse=True)
    robust = [x for x in stable if x[1] > 0]
    return {
        "oos_mean": statistics.mean(oos) if oos else 0,
        "oos_pos": sum(1 for x in oos if x > 0), "oos_n": len(oos),
        "best_step": stable[0][2], "best_mean": stable[0][0], "best_worst": stable[0][1],
        "robust_step": robust[0][2] if robust else None,
        "robust_mean": robust[0][0] if robust else 0,
        "robust_worst": robust[0][1] if robust else 0,
    }

def main():
    syms = [sys.argv[1]] if len(sys.argv) > 1 else \
           ["BTCUSDT", "ETHUSDT", "SOLUSDT", "AVAXUSDT", "LINKUSDT", "DOGEUSDT"]
    print("ОПТИМИЗИРОВАННЫЙ ДЕЛЬТА-НЕЙТРАЛЬНЫЙ ГРИД")
    print(f"плечо хеджа {HEDGE_LEV}x · мейкер {HEDGE_FEE*100}% · спот {SPOT_FEE*100}% · "
          f"исполнение {FILL_RATIO*100:.0f}% · {LEVELS} уровней × ${UNIT:.0f}\n")
    print(f"{'символ':>10} {'шаг':>6} {'OOS APR':>9} {'окон+':>7} {'средний':>9} {'худшее':>9} {'капитал':>9}")
    print("-" * 66)
    rows = []
    for s in syms:
        try:
            w = walk_forward(s)
        except FileNotFoundError:
            print(f"{s:>10}  нет данных"); continue
        cap = run(load(s), w["robust_step"] or w["best_step"])["capital"]
        rows.append((w["robust_mean"], s, w, cap))
        print(f"{s:>10} {str(w['robust_step'] or w['best_step']):>5}% {w['oos_mean']:>8.1f}% "
              f"{w['oos_pos']}/{w['oos_n']:>5} {w['robust_mean']:>8.1f}% {w['robust_worst']:>8.1f}% "
              f"${cap:>8,.0f}")
    if len(rows) > 1:
        rows.sort(reverse=True)
        print("\n" + "=" * 66)
        print("ПОРТФЕЛЬ ИЗ ТОП-3 (равные доли):")
        top = rows[:3]
        cap = sum(r[3] for r in top)
        apr = statistics.mean(r[0] for r in top)
        worst = min(r[2]["robust_worst"] for r in top)
        print(f"  символы : {', '.join(r[1] for r in top)}")
        print(f"  капитал : ${cap:,.0f}")
        print(f"  APR     : {apr:.1f}%  → ${cap*apr/100:,.0f} в год")
        print(f"  худшее окно любого из них: {worst:+.1f}%")
        print(f"\n  на $10 000 капитала: ~${10000*apr/100:,.0f} в год")
        print(f"  на $50 000 капитала: ~${50000*apr/100:,.0f} в год")

if __name__ == "__main__":
    main()