"""
Olympus 回合生成器核心 — 正向生成

流程: 生成 cascade → 自然累计 → 总分落桶
核心规则（与 olympus/engine.py 对齐）:
  1. 一旋转内多次消除，中间步只记基础分，末帧统一引爆炸弹
  2. 炸弹倍数跨旋转累计（accumulator 贯穿整个回合：基础旋转 + 免费旋转）
  3. 每步 accumulated_symbols 记录本旋转累计消除符号
  4. 落桶用理论总分（最高 1370），发放封顶 1000（末步截断 + win_capped）
"""
import json
import random
from collections import Counter

from olympus.config import (
    SYMBOL_RULES, SHORT_TO_SYMBOL, SCATTER_SHORT, BOMB_SHORT,
    SYMBOL_WEIGHTS, BOMB_CELL_PROBABILITY, BOMB_VALUES, BOMB_WEIGHT_POWER,
    GRID_ROWS, GRID_COLS, GRID_SIZE, MIN_WIN_COUNT,
    SCATTER_PAYOUTS, SCATTER_FREE_SPIN_TRIGGER, SCATTER_RETRIGGER_TRIGGER,
    FREE_SPINS_AWARDED, FREE_SPIN_RETRIGGER_COUNT, MAX_FREE_SPINS,
    BASE_FS_TRIGGER_PROB, BASE_NEARMISS_SCATTER, FS_TRIGGER_SCATTER, FREESPIN_SCATTER,
    FS_SPIN_WIN_PROB, FS_CASCADE_CONTINUE_PROB, FS_CASCADE_MAX, FS_GUARANTEE_COMBOS,
    FS_GUARANTEE_COST, FS_DRY_FORCE_PROB, FS_DRY_FORCE_HARD,
    FS_SMALL_BOMB_MAX, FS_BIG_BOMB_TARGET, FS_SCREEN_BOMB_PROB, FS_MAX_BOMBS_PER_SPIN,
    FS_ONLY_TARGET_MUL,
    ORNAMENTS, MAX_WIN_MULTIPLIER, bomb_quality, bigwin_level,
)

REGULAR_SHORTS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
MAX_WIN = float(MAX_WIN_MULTIPLIER)          # 发放封顶 1000
BUCKET_CEIL = max(o['range_high'] for o in ORNAMENTS)  # 落桶理论上限 1370

# 保底消除预算（1 倍底注口径）：最小档 0.25，连消后期望 1/(1-p) 波
FS_FLOOR_UNIT = min(c[2] for c in FS_GUARANTEE_COMBOS)
FS_FLOOR_SPEND = FS_FLOOR_UNIT / (1.0 - FS_CASCADE_CONTINUE_PROB)   # ≈0.45/旋
FS_FLOOR_BUDGET_CAP = FREE_SPINS_AWARDED * FS_FLOOR_SPEND           # ≈6.8/局


# ====================================================================
# 工具
# ====================================================================

def _payout(short, cnt):
    return float(SYMBOL_RULES[SHORT_TO_SYMBOL[short]].payout_for(cnt))


def _weighted_sym(exclude=()):
    syms = [s for s in REGULAR_SHORTS if s not in exclude]
    wts = [SYMBOL_WEIGHTS[s] for s in syms]
    r = random.uniform(0, sum(wts))
    a = 0.0
    for s, w in zip(syms, wts):
        a += w
        if r <= a:
            return s
    return syms[-1]


def _weighted_choice(dist):
    r = random.random()
    cum, last = 0.0, None
    for k, p in dist.items():
        last = k
        cum += p
        if r <= cum:
            return k
    return last


def _bucket(score):
    """理论总分落桶（score 可到 1370+，超出归顶桶）"""
    if score <= 0:
        return 1
    if score > BUCKET_CEIL:
        return ORNAMENTS[-1]['id']
    for o in ORNAMENTS:
        if o['range_low'] <= score <= o['range_high']:
            return o['id']
    for o in ORNAMENTS[1:]:
        if score <= o['range_high']:
            return o['id']
    return ORNAMENTS[-1]['id']


def _gen_bomb_value(max_val=None):
    opts = [v for v in BOMB_VALUES if max_val is None or v <= max_val]
    wts = [1.0 / (v ** BOMB_WEIGHT_POWER) for v in opts]
    r = random.uniform(0, sum(wts))
    a = 0.0
    for v, w in zip(opts, wts):
        a += w
        if r <= a:
            return v
    return opts[-1]


def _bomb_combos(target):
    """列出 ≤3 颗炸弹、和最接近 target 的所有组合：(误差, 组合)，按误差升序"""
    out = []
    vals = BOMB_VALUES
    for a in vals:
        out.append((abs(a - target), [a]))
        if a > target * 1.5:
            break
    for a in vals:
        if a > target:
            break
        for b in vals:
            s = a + b
            if s > target * 1.5:
                break
            out.append((abs(s - target), [a, b]))
    for a in vals:
        if a > target:
            break
        for b in vals:
            if a + b > target:
                break
            for c in vals:
                s = a + b + c
                if s > target * 1.5:
                    break
                out.append((abs(s - target), [a, b, c]))
    out.sort(key=lambda x: (x[0], len(x[1])))
    return out


def _best_bombs(target):
    """确定性最优（只用于评估方案误差）"""
    combos = _bomb_combos(target)
    return combos[0][1] if combos else [2]


def _decompose_best(target):
    """在"接近最优"的组合里随机挑一个，并强烈偏向单颗 —— 一屏一颗，
    玩家才看得出"消一次爆一颗、倍数一颗一颗涨"；改前每次都返回同一套
    （比如某些目标永远是 [3] 或 [3,6]），看起来"消除必定带 3 和 6 倍炸弹"。"""
    combos = _bomb_combos(target)
    if not combos:
        return [2]
    best_err = combos[0][0]
    pool = [c for e, c in combos if e <= best_err + max(0.5, best_err * 0.15)]
    weights = [1.0 / (len(c) ** 3) for c in pool]        # 1 颗 : 2 颗 : 3 颗 = 1 : 1/8 : 1/27
    return random.choices(pool, weights=weights)[0]


# ====================================================================
# 网格
# ====================================================================

def _empty_grid():
    return [[''] * GRID_COLS for _ in range(GRID_ROWS)]


def _count(grid):
    c = Counter()
    for row in grid:
        for cell in row:
            if cell:
                c[cell] += 1
    return c


def _winners(grid):
    w = {}
    for sym, cnt in _count(grid).items():
        if sym in (BOMB_SHORT, SCATTER_SHORT, ''):
            continue
        if cnt >= MIN_WIN_COUNT:
            pay = _payout(sym, cnt)
            if pay > 0:
                w[sym] = (cnt, pay)
    return w


def _no_extra(grid, allowed):
    """打散计划外的 ≥8 同符号组"""
    backup = [s for s in REGULAR_SHORTS if s not in allowed] or ['I']
    for _ in range(50):
        dirty = False
        for sym, cnt in _count(grid).items():
            if sym in (BOMB_SHORT, SCATTER_SHORT, '') or sym in allowed:
                continue
            if cnt >= MIN_WIN_COUNT:
                excess = cnt - (MIN_WIN_COUNT - 1)
                for r in range(GRID_ROWS):
                    for c in range(GRID_COLS):
                        if grid[r][c] == sym and excess > 0:
                            grid[r][c] = random.choice(backup)
                            excess -= 1
                dirty = True
        if not dirty:
            break


def _fill(grid, mul_map, allow_bomb, track=False, exclude_syms=(),
          bomb_prob=BOMB_CELL_PROBABILITY, bomb_max=None, max_bombs=None):
    """填充空格。allow_bomb 时按 bomb_prob 概率放炸弹（bomb_max 限制炸弹值、max_bombs 限制每屏颗数）。
    track 返回填充数据（仅普通符号）"""
    filled = [] if track else None
    placed = len(mul_map)
    for r in range(GRID_ROWS):
        for c in range(GRID_COLS):
            if grid[r][c] == '':
                pos = r * GRID_COLS + c
                if allow_bomb and random.random() < bomb_prob \
                        and (max_bombs is None or placed < max_bombs):
                    grid[r][c] = BOMB_SHORT
                    mul_map[pos] = _gen_bomb_value(bomb_max)
                    placed += 1
                else:
                    sym = _weighted_sym(exclude_syms)
                    grid[r][c] = sym
                    if track:
                        filled.append({"pos": pos + 1, "symbol": sym})
    return filled


def _collapse(grid, remove, mul_map):
    """消除指定位置(0-based)，重力下落。炸弹/散布随位置移动，mul_map 同步重映射"""
    rs = set(remove)
    drops = []
    ng = _empty_grid()
    pos_remap = {}
    for c in range(GRID_COLS):
        surviving = []
        for r in range(GRID_ROWS - 1, -1, -1):
            p = r * GRID_COLS + c
            if p not in rs:
                surviving.append((p, grid[r][c]))
        for i, (old_pos, sym) in enumerate(surviving):
            new_r = GRID_ROWS - 1 - i
            new_pos = new_r * GRID_COLS + c
            ng[new_r][c] = sym
            pos_remap[old_pos] = new_pos
            if new_pos != old_pos:
                drops.append({"from": old_pos + 1, "to": new_pos + 1, "symbol": sym})
    new_mul = {pos_remap[p]: v for p, v in mul_map.items() if p in pos_remap}
    return ng, drops, new_mul


def _place_scatter(grid, count, protect=()):
    cand = [(r, c) for r in range(GRID_ROWS) for c in range(GRID_COLS)
            if grid[r][c] not in ({SCATTER_SHORT, BOMB_SHORT} | set(protect))]
    for r, c in random.sample(cand, min(count, len(cand))):
        grid[r][c] = SCATTER_SHORT


def _count_scatter(grid):
    return sum(1 for row in grid for cell in row if cell == SCATTER_SHORT)


def _force_small_win(grid, prefer=()):
    """就地补一组最小档消除（默认 8 连低价值符号），不覆盖已有 S/M 格。

    prefer = 这一波"刚落下 / 刚补位"的格子（0 基）。保底消除优先种在这些格子上：
    它们本来就有 drop/fill 记录，前端按动画数据落地就能与 grid_state 完全一致；
    种在**没移动过**的格子上则没有任何动画记录，前端只能靠 grid_state 兜底。"""
    sym, cnt, _ = random.choice(FS_GUARANTEE_COMBOS)
    free = [p for p in range(GRID_SIZE)
            if grid[p // GRID_COLS][p % GRID_COLS] not in (SCATTER_SHORT, BOMB_SHORT)]
    if len(free) < cnt:
        return
    fresh = [p for p in prefer if p in set(free)]
    if len(fresh) >= cnt:
        picks = random.sample(fresh, cnt)
    else:
        rest = [p for p in free if p not in set(fresh)]
        picks = fresh + random.sample(rest, cnt - len(fresh))
    for p in picks:
        grid[p // GRID_COLS][p % GRID_COLS] = sym
    _no_extra(grid, {sym})


def _scatter_payout(count):
    if count >= SCATTER_FREE_SPIN_TRIGGER:
        return float(SCATTER_PAYOUTS.get(min(count, 6), 0))
    return 0.0


# ====================================================================
# 强制中奖（bias 补桶用）
# ====================================================================

# (基础分, 组合) 按基础分降序
_BASE_OPTIONS = [
    (60.0, [('A', 12), ('B', 10)]),
    (50.0, [('A', 12)]),
    (35.0, [('A', 10), ('B', 10)]),
    (25.0, [('A', 10)]),
    (12.5, [('A', 8), ('B', 8)]),
    (10.0, [('A', 8)]),
    (5.0,  [('C', 10)]),
    (3.5,  [('C', 8), ('D', 8)]),
    (2.5,  [('B', 8)]),
    (2.0,  [('C', 8)]),
    (1.5,  [('D', 8)]),
    (1.0,  [('E', 8)]),
    (0.8,  [('F', 8)]),
    (0.5,  [('G', 8)]),
    (0.4,  [('H', 8)]),
    (0.25, [('I', 8)]),
]


def _plan_for(target):
    """全局搜索 (基础组合, 炸弹列表)，使 base × max(1, Σ炸弹) 最接近 target。

    在"误差在最优 +5 个百分点以内"的若干方案里随机挑一个 —— 改前永远返回同一套最优解，
    所以同一档位的回合盘面/炸弹老是那几个（"某个符号消除必定带着 3 和 6 倍炸弹"）。"""
    if target <= 0:
        return [], []
    plans = []
    for base, combo in _BASE_OPTIONS:
        plans.append((abs(base - target) / target, combo, None))          # 方案A：无炸弹
        m = target / base
        if m >= 2:                                                        # 方案B：配炸弹
            achieved = base * sum(_best_bombs(m))
            plans.append((abs(achieved - target) / target, combo, m))
    plans.sort(key=lambda p: p[0])
    best_err = plans[0][0]
    pool = [p for p in plans if p[0] <= best_err + 0.05]
    _, combo, m = random.choice(pool)
    return combo, ([] if m is None else _decompose_best(m))


def _plan_base_only(target):
    """只挑基础组合（不植炸弹）：在接近最优的组合里随机。acc 已经提供倍数时用这个。"""
    if target <= 0:
        return [('I', 8)]
    cands = sorted((abs(base - target) / target, combo) for base, combo in _BASE_OPTIONS)
    best = cands[0][0]
    pool = [c for e, c in cands if e <= best + 0.05]
    return random.choice(pool)


def _force_win(grid, target, mul_map, acc=0.0, allow_bomb=True):
    """把 target 当"本旋最终赢额"来造奖：先按当前累计倍数 acc 折算需要的基础分。

    买单旋赢额 = 基础分 × max(1, acc + 本旋炸弹)，所以：
      · acc 已经 >1 时只挑基础分、**不再植炸弹**（否则 acc 和炸弹的倍数会被算两次，
        实测把 10 倍目标打成 40~50 倍）；
      · 该模式不允许炸弹（普通旋转/底注）时同理只挑基础分；
      · 其余情况（buy_fs 且 acc=0）按原逻辑植炸弹，大奖局（100 倍以上）靠这一步才能到。"""
    need_base = target / max(1.0, acc) if acc > 0 else target
    if need_base >= 0.25:
        if acc > 1 or not allow_bomb:
            combo, bombs = _plan_base_only(need_base), []
        else:
            combo, bombs = _plan_for(need_base)
    else:
        combo, bombs = [('I', 8)], []      # acc 本身已超过目标：只给最小档，不再加炸弹
    used = set()
    win_syms = set()
    for sym, cnt in combo:
        win_syms.add(sym)
        free = [p for p in range(GRID_SIZE) if p not in used]
        for p in random.sample(free, min(cnt, len(free))):
            r, c = divmod(p, GRID_COLS)
            grid[r][c] = sym
            used.add(p)
    free = [p for p in range(GRID_SIZE) if p not in used]
    for v in bombs:
        if not free:
            break
        p = free.pop(random.randrange(len(free)))
        r, c = divmod(p, GRID_COLS)
        grid[r][c] = BOMB_SHORT
        mul_map[p] = v
        used.add(p)
    for p in range(GRID_SIZE):
        r, c = divmod(p, GRID_COLS)
        if grid[r][c] == '':
            grid[r][c] = _weighted_sym(exclude=win_syms)
    _no_extra(grid, win_syms)
    return win_syms


# ====================================================================
# 核心：一次旋转的 cascade 链
# ====================================================================

def _spin(mode_code, bias=None, acc=0, is_free_spin=False, target_scatter=0,
          allow_bomb=True, win_prob=0.0, continue_prob=0.0, cascade_max=0,
          bomb_prob=None, bomb_max=None, max_bombs=None):
    """
    一次旋转（含多次 cascade）。
    炸弹跨 cascade 保留不消除；末帧统一结算: total = base_sum * max(1, acc+bomb_sum)
    acc 只在本旋转有消除时累加炸弹（与 engine.end_spin 一致）。
    allow_bomb=False 时初始盘也不出炸弹；级联补位一律不出。
    **炸弹只存在于免费旋转内**：普通旋转/底注的基础旋（含进 FS 的那张触发盘）一律不出炸弹；
    三个模式进 FS 后规则完全一致（炸弹 + 累计器 + 每旋保底消除）。
    win_prob/continue_prob：本盘凑不出消除时按概率补最小档消除（首盘/级联各自取一个），
    cascade_max 限制单旋最大波数 —— 让 FS 里"每旋都在消"。
    返回 (steps, spin_total, acc_out, scatter_count)
    """
    if not is_free_spin:
        allow_bomb = False
    steps = []
    seq = 0
    mul_map = {}                 # {pos0: bomb_val} 跨 cascade 累积
    if bomb_prob is None:
        bomb_prob = BOMB_CELL_PROBABILITY
    # 本旋是不是"大奖旋"（补桶植入目标额的那一旋）：只有它按累计倍数结算
    plant_spin = isinstance(bias, (int, float)) and bias > 0

    grid = None
    prev_win_pos = []
    sym_acc = Counter()          # 本旋转累计消除符号
    spin_winners = []            # 落库留档用（接口已不下发，面板由 symbol_links 汇总）
    spin_links = []              # 本旋累积连线上报：[{symbol,count,loc,base_score,tumble}]，新旋清空
    total_base = 0.0
    recorded = 0.0               # 已记入前置步骤的赢额
    removed, drops, fills = [], [], []
    acc_before_spin = acc

    while True:
        seq += 1
        if seq == 1:
            grid = _empty_grid()
            if isinstance(bias, (int, float)) and bias > 0:
                win_syms = _force_win(grid, float(bias), mul_map, acc, allow_bomb)
            else:
                _fill(grid, mul_map, allow_bomb, bomb_prob=bomb_prob, bomb_max=bomb_max,
                      max_bombs=max_bombs)
                if bias == 'zero':
                    _no_extra(grid, set())
            if target_scatter > 0:
                _place_scatter(grid, target_scatter, protect=set(_winners(grid)))
            removed, drops, fills = [], [], []
        else:
            removed = [p + 1 for p in prev_win_pos]
            grid, drops, mul_map = _collapse(grid, prev_win_pos, mul_map)
            fills = _fill(grid, mul_map, allow_bomb=False, track=True)

        # 保底消除：本盘自然凑不出 8 连时，按概率补一组最小档（首盘用 win_prob，级联用 continue_prob）
        prob = win_prob if seq == 1 else continue_prob
        if prob > 0 and (not cascade_max or seq < cascade_max) \
                and random.random() < prob and not _winners(grid):
            _force_small_win(grid, prefer=[f['pos'] - 1 for f in fills])

        # 保底消除 / 打散会覆盖"刚落下"或"刚补位"的格子 —— 这两份动画数据里的 symbol 按**最终盘面**
        # 回填，前端按"消→落→补"重建出来的盘面才与 grid_state 完全一致（否则会画出不对的符号）。
        if drops:
            drops = [dict(d, symbol=grid[(d['to'] - 1) // GRID_COLS][(d['to'] - 1) % GRID_COLS])
                     for d in drops]
        if fills:
            fills = [dict(f, symbol=grid[(f['pos'] - 1) // GRID_COLS][(f['pos'] - 1) % GRID_COLS])
                     for f in fills]

        w = _winners(grid)
        is_final = (len(w) == 0)

        base = 0.0
        win_pos = []
        mul_det = [{"pos": p + 1, "val": v, "quality": bomb_quality(v)}
                   for p, v in sorted(mul_map.items())]
        bomb_sum = sum(mul_map.values())

        # symbol_links = **本旋累积**的连线上报（每波消除往上追加，tumble 标明是旋内第几波）——
        # 它同时充当"获胜者面板"（前端按 symbol 汇总即可），所以 spin_winners 字段已删。
        for sym, (cnt, pay) in sorted(w.items()):
            pos_list = [r * GRID_COLS + c for r in range(GRID_ROWS)
                        for c in range(GRID_COLS) if grid[r][c] == sym][:cnt]
            base += pay
            win_pos.extend(pos_list)
            sym_acc[sym] += cnt
            spin_links.append({
                'symbol': sym, 'count': cnt,
                'loc': [p + 1 for p in pos_list],
                'base_score': round(pay, 4),
                'tumble': seq,                      # 本旋第几波消除（= 本步 tumbleNum）
            })
        total_base += base

        # 末帧：统一引爆（一旋转内不管几次消除，消完才爆）
        # 累计器仅免费旋转有效；基础旋转炸弹只乘本旋赢额、不留存
        scatter_win = 0.0
        scatter_count = 0
        acc_after = acc
        if is_final:
            scatter_count = _count_scatter(grid)
            scatter_win = _scatter_payout(scatter_count)
            if total_base > 0:
                if is_free_spin:
                    acc_after = acc + bomb_sum      # FS：炸弹并入累计器，跨旋传递
                    # 本旋赢额 = 基础分 × max(1, 累计 + 本旋炸弹) —— 累计倍数作用到每一次消除
                    # （玩家要的就是这个滚雪球：0.4×2 + 0.5×4 = 2.8）
                    effective = max(1, acc_after)
                else:
                    acc_after = acc                 # 基础旋：无累计器
                    effective = max(1, bomb_sum)
                win_amt = total_base * effective - recorded + scatter_win
            else:
                win_amt = scatter_win               # 无消除→炸弹作废、累计不变
        else:
            win_amt = base                          # 中间步只记基础分
        recorded += win_amt if not is_final else 0.0

        # scatter 触发/重触发（仅末帧）
        scatter_trigger, retrigger_info = None, None
        if is_final:
            if is_free_spin and scatter_count >= SCATTER_RETRIGGER_TRIGGER:
                retrigger_info = {'scatterCount': scatter_count,
                                  'extraSpins': FREE_SPIN_RETRIGGER_COUNT,
                                  'scatterWin': round(scatter_win, 2)}
            elif not is_free_spin and scatter_count >= SCATTER_FREE_SPIN_TRIGGER:
                scatter_trigger = {'scatterCount': scatter_count,
                                   'freeSpins': FREE_SPINS_AWARDED,
                                   'scatterWin': round(scatter_win, 2)}

        steps.append({
            'cascade_seq': seq, 'free_spin_id': 0,
            'grid_state': [row[:] for row in grid],
            'multiplier_detail': json.dumps(mul_det),
            'symbol_links': json.dumps(spin_links, ensure_ascii=False),   # 本旋累积（含 tumble）
            'accumulated_symbols': json.dumps(dict(sym_acc)),             # 仅落库留档，不下发
            'spin_winners': json.dumps(spin_winners, ensure_ascii=False),  # 仅落库留档，不下发
            'removed_positions': json.dumps(removed),                      # 仅落库留档，不下发
            'drop_data': json.dumps(drops),
            'fill_data': json.dumps(fills if fills else []),
            'scatter_trigger': json.dumps(scatter_trigger) if scatter_trigger else None,
            'retrigger_info': json.dumps(retrigger_info) if retrigger_info else None,
            'base_score': round(base, 2),                                  # 仅落库留档，不下发
            'win_amount': round(win_amt, 2),
            'accumulator_before': round(acc_before_spin, 2),
            'accumulator_after': round(acc_after if is_final else acc, 2),
            'spin_win': 0, 'win_capped': 0, 'bigwin_level': None,
            'is_final': 1 if is_final else 0,
        })

        if is_final:
            total = round(sum(s['win_amount'] for s in steps), 2)
            return steps, total, acc_after, scatter_count
        prev_win_pos = win_pos


# ====================================================================
# 免费旋转会话（15 次起，≥3S 重触发 +5，上限 30）
# ====================================================================


def _fs_next_target(spin_no, wins, total_spins, quota):
    """下一旋"该保底消除"的位置：间隔随机，但均值 = 剩余旋数 / 剩余配额。

    为什么要随机：等距铺（每 quota/总局数 旋必消一次）会让玩家几局就看穿"到第 4 旋肯定消"——
    实测等距版本有 87% 的局"最长连空正好 4 旋"。这里改成每次消除后重抽下一次的位置：
    间隔 = round(均值 + δ)，δ ∈ {-2..2} 权重 {1,2,3,2,1}（均值 0，所以整局的消除次数不变），
    玩家看到的空转长度在 1~5 旋之间跳，而不是恒定 4。剩余配额为 0 时返回 None（后面只靠自然消）。
    """
    left_spins = total_spins - spin_no
    left_quota = quota - wins
    if left_spins <= 0 or left_quota <= 0:
        return None
    delta = random.choices((-2, -1, 0, 1, 2), weights=(1, 2, 3, 2, 1))[0]
    return spin_no + max(1, int(round(left_spins / left_quota + delta)))


def _free_spin_session(mode_code, slot_target=None, acc=0, fs_budget=None):
    """免费旋转会话（15 次起，≥3S 重触发 +5，上限 30）。

    **三个模式同一套规则**（炸弹 + 累计器 + 每旋保底消除），区别只在"这一局值多少钱"：
      · buy_fs：价格换来桶目标，拆成「保底消除预算 fs_budget + 一旋大奖 slot_target」；
      · normal/ante 自然触发：没有价格可拆 → 只给一份同档保底预算、不植大奖旋，
        整局赔付落在哪由自然结果决定。
    fs_budget 按"配额 + 随机间隔"花：预算能买 k 次消除（k ≈ √(预算/FS_GUARANTEE_COST)），
    每次消除后重抽下一次的位置（间隔随机、均值 = 剩余旋数/剩余配额），自然消除也算一次进度；
    空转太久再按 FS_DRY_FORCE_PROB 软兜底 —— 旧写法按"剩余预算÷剩余旋数"算每旋概率，累计倍数
    一涨就把预算烧穿，后半局十几旋连空；等距铺法又会让玩家看穿"到第 4 旋肯定消"（见 _fs_next_target）。
    slot_target 只作用于其中随机一旋（它按累计倍数结算，不占保底配额）。
    """
    total_spins = FREE_SPINS_AWARDED
    fs_index = 0
    all_steps = []
    fs_total = 0.0
    sc_dist = FREESPIN_SCATTER.get(mode_code, FREESPIN_SCATTER['default'])
    budget = fs_budget
    # 炸弹大小按档位配：低倍局用小球（预算买得起多次"消除+爆"），高倍局用全量（2~1000 的大球）
    target_mul = float(slot_target) if isinstance(slot_target, (int, float)) else 0.0
    spin_bomb_max = None if target_mul >= FS_BIG_BOMB_TARGET else FS_SMALL_BOMB_MAX
    bias_slot = random.randrange(FREE_SPINS_AWARDED) if slot_target else -1
    # 保底配额：预算 ÷ 单次消除边际赔付再开方 = 这一局"买得起"几次消除
    quota = None if budget is None else max(1, int((max(0.0, budget) / FS_GUARANTEE_COST) ** 0.5))
    wins = 0                                       # 已消除的旋数（自然 + 保底）
    dry = 0                                        # 已经连续空转了几旋（兜底用）
    target = None if quota is None else _fs_next_target(0, 0, total_spins, quota)
    while fs_index < total_spins:
        fs_index += 1
        is_target_slot = (fs_index - 1) == bias_slot
        spin_bias = slot_target if is_target_slot else None
        forced = False
        if spin_bias is None and quota is not None:
            # 到点了 / 空转太久被软兜底抽中 → 本旋必补一次保底消除
            forced = target is not None and fs_index >= target
            if not forced and dry >= FS_DRY_FORCE_HARD:
                forced = True
            elif not forced and dry in FS_DRY_FORCE_PROB:
                forced = random.random() < FS_DRY_FORCE_PROB[dry]
            p = 1.0 if forced else 0.0
        else:
            p = FS_SPIN_WIN_PROB
        sc = _weighted_choice(sc_dist)
        # 已到 30 旋上限：这一旋不再落 3+ 个 S —— 否则会写出"extraSpins=5 但没有旋可加"的
        # retrigger_info（玩家白看一次 +5，前端还得自己夹 30）。上限之前的那一旋照常触发第 3 次 +5。
        if total_spins >= MAX_FREE_SPINS:
            sc = min(sc, SCATTER_RETRIGGER_TRIGGER - 1)
        spin_steps, spin_score, acc, sc_count = _spin(
            mode_code, spin_bias, acc, is_free_spin=True, target_scatter=sc,
            win_prob=p, continue_prob=FS_CASCADE_CONTINUE_PROB,
            cascade_max=FS_CASCADE_MAX,
            bomb_prob=FS_SCREEN_BOMB_PROB, bomb_max=spin_bomb_max,
            max_bombs=FS_MAX_BOMBS_PER_SPIN)
        if sc_count >= SCATTER_RETRIGGER_TRIGGER and total_spins < MAX_FREE_SPINS:
            total_spins += FREE_SPIN_RETRIGGER_COUNT
        # 目标大奖旋的花费由目标额单独控制，不占用保底预算
        if budget is not None and not is_target_slot:
            budget -= spin_score
        for s in spin_steps:
            s['free_spin_id'] = fs_index
        fs_total += spin_score
        all_steps.extend(spin_steps)
        # 进度：消了（不管自然还是保底）就重新抽下一次的位置 —— 整局消除次数仍由配额决定
        if spin_bias is None and quota is not None:
            if any(float(s['base_score']) > 0 for s in spin_steps):
                wins += 1
                dry = 0
                target = _fs_next_target(fs_index, wins, total_spins, quota)
            else:
                dry += 1
    return all_steps, fs_total


# ====================================================================
# 主入口
# ====================================================================

def generate_round(box, bias=None):
    """
    生成一个完整回合。box: {'box_id','box_type',...}  bias: None/'zero'/目标倍率(float)
    返回 (round_data, steps, orn_id)
    """
    mode_code = box['box_type']
    buy_fs = mode_code == 'buy_fs'
    # 目标高于"基础旋（无炸弹）能赔到的上限"时，只能生成自然触发 FS 的回合来装这个桶：
    # normal/ante 的 100x/150x/200x 桶没有别的来源（基础旋不出炸弹，最多 ~60x）。
    must_free_spins = isinstance(bias, (int, float)) and not buy_fs \
        and float(bias) >= FS_ONLY_TARGET_MUL
    is_fs = False
    if buy_fs:
        is_fs = True                        # 购买模式保证进 FS（互斥：无底注效果）
    elif must_free_spins:
        is_fs = True
    elif mode_code in BASE_FS_TRIGGER_PROB and bias is None:
        is_fs = random.random() < BASE_FS_TRIGGER_PROB[mode_code]

    if is_fs:
        # 触发盘：三模式都固定/摇出 SCATTER，且**不出炸弹**（炸弹只存在于免费旋转内）
        trigger_sc = 4 if buy_fs else _weighted_choice(FS_TRIGGER_SCATTER)
        base_steps, base_total, _, _ = _spin(
            mode_code, None, 0, is_free_spin=False, target_scatter=trigger_sc,
            allow_bomb=False)
        # FS 预算：买 FS / 高倍桶（bias=桶目标）拆成「保底消除预算 + 一旋大奖」；
        # normal/ante 自然摇出来的 FS（bias=None）没有价格可拆 → 只给同档保底预算、不植大奖旋，
        # 整局赔付由自然消除 + 炸弹累计决定（实测约 80x、5 旋有消除，落在模式自己的桶里）。
        fs_budget, slot_target = None, None
        if isinstance(bias, (int, float)) and bias > 0:
            budget = max(0.0, float(bias) - float(base_total))
            if budget <= FS_FLOOR_BUDGET_CAP:
                fs_budget = budget                       # 低倍局：全靠保底小消
            else:
                fs_budget = FS_FLOOR_BUDGET_CAP          # 保底小消是平价结算（×1），预算可以给足
                slot_target = budget - fs_budget         # 其余给"大奖旋"（它按累计倍数结算）
        elif not buy_fs:
            fs_budget = FS_FLOOR_BUDGET_CAP
        # 炸弹累计器仅免费旋转内生效：FS 会话从 0 起累，触发盘炸弹不带入
        fs_steps, fs_total = _free_spin_session(
            mode_code, slot_target=slot_target, acc=0, fs_budget=fs_budget)
        steps = base_steps + fs_steps
    else:
        nearmiss = _weighted_choice(BASE_NEARMISS_SCATTER.get(mode_code, {0: 1.0}))
        steps, _, _, _ = _spin(mode_code, bias, 0,
                               is_free_spin=False, target_scatter=nearmiss)

    # 理论总分（落桶用，可到 1370+）
    raw_total = round(sum(s['win_amount'] for s in steps), 2)
    orn_id = _bucket(raw_total)

    # 发放截断 + 口径重写：累计到 1000 即终止，动画=到账零偏差。
    #   win_amount = **本旋累计到本步的赢额**（该旋末步就是这一旋的总额）；
    #   spin_win   = **本局累计到本步的赢额**（最后一步 = 整局实付 = totalWin）
    # 前端因此不需要自己相加：本步增量 = 与上一步相减，本旋总额 = 本旋末步的 win_amount。
    raw_increments = [s['win_amount'] for s in steps]
    cumul, spin_cumul, capped_steps, hit = 0.0, {}, [], False
    for s, inc in zip(steps, raw_increments):
        if cumul + inc >= MAX_WIN:                  # 封顶：本步补足到 1000 并终止
            inc = round(MAX_WIN - cumul, 2)
            s['win_capped'] = 1
            s['is_final'] = 1
            hit = True
        key = s['free_spin_id']
        spin_cumul[key] = round(spin_cumul.get(key, 0.0) + inc, 2)
        cumul = round(cumul + inc, 2)
        s['win_amount'] = spin_cumul[key]           # 本旋累计（末步即该旋总额）
        s['spin_win'] = cumul                       # 本局累计
        capped_steps.append(s)
        if hit:
            break
    if hit:
        steps = capped_steps
    paid_total = round(cumul, 2)

    # 爆奖动画（小/中/大）：**只有免费旋转里才判档** —— normal/ante 靠自然触发 FS、
    # buy_fs 本身即 FS；基础旋（free_spin_id=0）一律 null，不播大奖动画。
    # 单旋赢额 = 该旋末帧的 win_amount；旋与旋互不影响，同档一局可多次播放。
    for s in steps:
        if s['is_final'] and s['free_spin_id'] > 0:
            s['bigwin_level'] = bigwin_level(mode_code, float(s['win_amount']))

    fs_cnt = len({s['free_spin_id'] for s in steps if s['free_spin_id'] > 0})
    rd = {
        'box_id': box['box_id'], 'ornament_id': orn_id,
        'actual_mul': round(paid_total, 4),     # 实付倍率 ≤1000
        'free_spin_count': fs_cnt,
        'total_cascades': len(steps),
    }
    return rd, steps, orn_id


# ====================================================================
# 分布补偿：两阶段填桶
# ====================================================================

def _bias_for(orn_id):
    if orn_id == 1:
        return 'zero'
    o = next(x for x in ORNAMENTS if x['id'] == orn_id)
    return float(o['expect_mul'])


def _calibrate_bias(box, orn_id, samples=8):
    """给某个桶在线找一个"更容易撞上"的 bias（只改传给生成器的目标值，不动任何规则）。

    为什么需要：`_bias_for` 用的是桶的名义 expect_mul，但 buy_fs 的整局赔付被 FS 会话抬高了 ——
    实测 bias=10（桶 7 名义 10x）时实际赔付 min 14 / 中位 58，**永远撞不进 8~12**，命中率仅 3%，
    stage2 只能白跑几万次（单箱 5~10 分钟）。这里拿几个候选值各试几局，挑命中率最高的那个。"""
    target = _bias_for(orn_id)
    best, best_hit = target, -1
    for mult in (1.0, 0.5, 0.3, 0.15, 0.08):
        b = target * mult
        hit = 0
        for _ in range(samples):
            _, _, oid = generate_round(box, b)
            hit += (oid == orn_id)
        if hit > best_hit:
            best, best_hit = b, hit
        if hit == samples:          # 已经全中，不用再试更小/更大的
            break
    return best


def fill_distribution(box, target_counts, max_rounds=None):
    """阶段1 自由生成积累常见桶；阶段2 按缺额 bias 补桶。返回 (rounds, 实际分布)

    阶段2 的尝试上限按 total×60：保底消除改成"随机间隔"之后，低倍桶（10x/16x）的命中率大约减半
    （同样的钱摊到整局、摊到累计倍数高的旋上更贵），尝试数不够会填不满池子（实测 ×30 时
    10x 桶只填到 178/297，×60 满池）。
    某个桶饿死时（试了 4 倍于它条数的次数还没填满）会重新校准它的 bias —— 只对慢桶生效，
    命中率本来就高的桶走原来的名义值，不额外花钱。"""
    gen = Counter()
    rounds = []
    total_target = sum(target_counts.values())
    bias_use = {}                       # orn_id -> 校准后的 bias
    tries = Counter()                   # orn_id -> 已尝试次数

    def _accept(oid):
        if oid in target_counts and gen[oid] < target_counts[oid]:
            gen[oid] += 1
            return True
        return False

    free_budget = min(total_target * 3, 12000)
    for _ in range(free_budget):
        if sum(gen.values()) >= total_target:
            break
        rd, steps, oid = generate_round(box, None)
        if _accept(oid):
            rounds.append((rd, steps))

    max_att = (max_rounds or total_target * 60)
    for _ in range(max_att):
        deficit = [(oid, target_counts[oid] - gen[oid])
                   for oid in target_counts if gen[oid] < target_counts[oid]]
        if not deficit:
            break
        # 按缺口加权随机选桶，避免“最难桶”饿死其他桶
        need = random.choices([d[0] for d in deficit],
                              weights=[d[1] for d in deficit])[0]
        tries[need] += 1
        if need not in bias_use and tries[need] > target_counts[need] * 4:
            bias_use[need] = _calibrate_bias(box, need)
        rd, steps, oid = generate_round(box, bias_use.get(need, _bias_for(need)))
        if _accept(oid):
            rounds.append((rd, steps))

    return rounds, dict(gen)