import {
    MapCellKind,
    MergeEventFactory,
    MergeEventType,
    MergeSession,
    PlaceRejectReason,
    rejectReasonToMessage,
    Weapon2TileType,
    type BagSlotRecord,
    type ComposedUnit,
    type DragSource,
    type DropTarget,
    type MergeEvent,
    type MergeEventListener,
    type MergeEventSubscription,
} from 'db://assets/mx/module/merge';
import { GEvent } from 'db://assets/mx/module/event/GEvent';
import { Director, director } from 'cc';
import { createMembershipSet, membershipAdd } from '../../../mx/tools/MembershipSet';
import type { MapManager } from '../map/legacy/MapManager';
import type { MapGrid } from '../map/legacy/MapGrid';
import {
    formatBagRollEntries,
    formatIdList,
    logBagRefreshDebug,
    logBagRefreshSection,
} from '../debug/BagRefreshDebugLog';
import {
    SHOVEL_WEAPON2_ID,
    getDiscountedBagNormalRefreshCost,
} from './BagPrepConfig';
import { MapPlaceValidator } from './MapPlaceValidator';
import { MapDragGuideHelper } from '../view/MapDragGuideHelper';
import { WeaponComposeConfigProvider } from './WeaponComposeConfigProvider';
import { isAttackGlyph } from '../config/BattleHeroTable';
import { ComboLosePity, FirstBattleHeroPity } from './BagHeroRefreshAlgorithm';
import { PlayerBagTextPool } from './PlayerBagTextPool';
import type { PlayerBagTextPoolState } from './PlayerBagTextPool';
import type { BagRollEntry } from './BagWeaponPool';
import { buildGmWeaponPresetQueue } from '../debug/GmBattlePreset';
import { preloadGmHeroActorPrefabs } from '../heros/HeroActorRes';
import type { ProjectBattleHandle } from '../runtime/BattleRuntime';
import { RankDataManager } from '../../manager/RankDataManager';
import { DailyShopDataManager } from '../../manager/DailyShopDataManager';
import { resolveCarriedHeroSummonRatePoolAdjust, resolveCarriedSummonCostReduceWan } from '../../manager/battleBuff/BattleBuffPassiveSkillUtil';
import { BattleBuffCarryStore } from '../../manager/battleBuff/BattleBuffCarryStore';
import { getTowerLevelDownHost } from '../combat/TowerLevelDownHost';
import { getTowerRuinHost } from '../combat/TowerRuinHost';
import { getTowerExpHost } from '../combat/TowerExpHost';
import { findEntityIdByGridIndex } from '../runtime/DeployEntityQuery';
/** 项目层背包会话：桥接 MergeSession 与 MapManager */
export class BattleBagSession {
    readonly merge: MergeSession;
    readonly validator: MapPlaceValidator;

    private readonly _map: MapManager;
    private readonly _textPool = new PlayerBagTextPool();
    /** 玩家连败组合字保底（AI 不使用） */
    private readonly _comboPity = new ComboLosePity();
    /** 新号第一局神将字保底（AI 不使用） */
    private readonly _firstHeroPity: FirstBattleHeroPity;
    /** 刷新扣桃所属 playerId */
    private readonly _ownerPlayerId: number;
    /** 本局已成功普通刷新次数（用于刷新消耗递增） */
    private _normalRefreshUsed = 0;
    /** PopGM 预设 Weapon1 → Weapon2 顺序队列（每次刷新从队首取，取完走正常逻辑） */
    private _gmWeaponPresetQueue: number[] = [];
    /** 视图层将自行播放 openSpine 的地图格（null=无） */
    private _deferOpenFxGridIndex: number | null = null;
    /** dropLogical（AI）跳过开挖 openSpine，只切格态 */
    private _skipOpenEffect = false;
    /** 本局携带被动：召唤消耗降低万分比（functiontype=26，开局快照） */
    private readonly _summonCostReduceWan: number;

    constructor(map: MapManager, chapterId: number, session?: import('db://assets/mx/module/battle').BattleSession, bagSlotCount = 5, opts?: {
        /** 字池所用段位 id；缺省玩家当前段位 */
        rankId?: number;
        /** 扣桃所属玩家槽；缺省 0（本机） */
        ownerPlayerId?: number;
    }) {
        this._map = map;
        this._ownerPlayerId = Math.max(0, Math.floor(Number(opts?.ownerPlayerId) || 0));
        this._firstHeroPity = new FirstBattleHeroPity(
            this._ownerPlayerId === 0 && RankDataManager.hasNoBattleHistory(),
        );
        this.validator = new MapPlaceValidator(map, session, this._ownerPlayerId);
        WeaponComposeConfigProvider.instance.load();
        this._gmWeaponPresetQueue = buildGmWeaponPresetQueue();
        preloadGmHeroActorPrefabs();
        const rankId = opts?.rankId != null
            ? Math.floor(Number(opts.rankId) || 0)
            : RankDataManager.getPlayerRankId();
        // 携带被动按 ownerPlayerId：本机 DailyShop，AI 读 CarryStore
        if (this._ownerPlayerId === 0) {
            const heroSummonAdjust = resolveCarriedHeroSummonRatePoolAdjust(DailyShopDataManager.getOwnedPassive());
            this._summonCostReduceWan = resolveCarriedSummonCostReduceWan(DailyShopDataManager.getOwnedPassive()).reduceWan;
            this._textPool.beginBattle(rankId, {
                heroSummonRateActive: heroSummonAdjust.active,
                heroSummonRateOffset: heroSummonAdjust.offset,
            });
        } else {
            const passives = BattleBuffCarryStore.getPassives(this._ownerPlayerId);
            const heroSummonAdjust = resolveCarriedHeroSummonRatePoolAdjust(passives);
            this._summonCostReduceWan = resolveCarriedSummonCostReduceWan(passives).reduceWan;
            this._textPool.beginBattle(rankId, {
                heroSummonRateActive: heroSummonAdjust.active,
                heroSummonRateOffset: heroSummonAdjust.offset,
            });
        }

        this.merge = new MergeSession({
            config: WeaponComposeConfigProvider.instance,
            pathChecker: this.validator,
            bagSlotCount,
            coordOf: (gridIndex) => {
                const g = map.getMapGridByIndex(gridIndex);
                if (!g) return null;
                return { gridIndex, row: g.Row, col: g.Col };
            },
        });
        this.merge.setMergeBlocker(this);
        this.merge.on(MergeEventType.MapUpgraded, this._onRuinMapUpgraded);
        this.merge.on(MergeEventType.BagMerged, this._onRuinBagMerged);

        this._initMapCells();
        // 开局不自动 roll，玩家手动点刷新
        this.merge.beginPrepRound();
    }

    /** 刷新扣桃所属 playerId */
    get ownerPlayerId(): number {
        return this._ownerPlayerId;
    }

    /**
     * 合成升级解除牛魔王损毁。
     * @param event 合成事件
     */
    private readonly _onRuinMapUpgraded = (event: MergeEvent): void => {
        if (event.type !== MergeEventType.MapUpgraded) return;
        const tile = this.merge.map.getTile(event.gridIndex);
        if (tile) tile.ruined = false;
        getTowerRuinHost().releaseByUpgrade(this._ownerPlayerId, event.gridIndex);
    };

    /**
     * 背包合成升级解除牛魔王损毁。
     * @param event 合成事件
     */
    private readonly _onRuinBagMerged = (event: MergeEvent): void => {
        if (event.type !== MergeEventType.BagMerged) return;
        const slot = this.merge.bag.getSlot(event.slotIndex);
        if (slot) slot.ruined = false;
        getTowerRuinHost().releaseBagUpgrade(this._ownerPlayerId, event.slotIndex);
    };

    /**
     * 该格是否处于龟丞相降级禁合成。
     * @param gridIndex 地图格
     */
    isMergeUpgradeBlocked(gridIndex: number): boolean {
        return getTowerLevelDownHost().isGridBlocked(this._ownerPlayerId, gridIndex);
    }

    get compositions(): readonly ComposedUnit[] {
        return this.merge.compositions;
    }

    get normalRefreshCost(): number {
        return getDiscountedBagNormalRefreshCost(this._normalRefreshUsed, this._summonCostReduceWan);
    }

    /** 字池是否还能再填满一次背包 */
    canNormalRefreshFill(): boolean {
        return this._textPool.canRollSlots(this.merge.bag.slotCount);
    }

    /** 广告刷新已下线 */
    getAdRefreshMax(_chapterId: number): number {
        return 0;
    }

    /** 广告刷新已下线 */
    getAdRefreshRemaining(_chapterId: number): number {
        return 0;
    }

    on(event: MergeEventSubscription, listener: MergeEventListener): void {
        this.merge.on(event, listener);
    }

    off(event: MergeEventSubscription, listener: MergeEventListener): void {
        this.merge.off(event, listener);
    }

    beginPrepRound(): void {
        this.merge.beginPrepRound();
    }

    endPrepRound(): void {
        this.merge.endPrepRound();
    }

    /**
     * 普通刷新重 roll 背包。
     * @param _levelId 保留签名兼容调用方
     * @param _unused 保留签名兼容调用方
     */
    refreshBag(_levelId: number, _unused = false): void {
        const gmIds = (gg.game as { gmBagWeapon2Ids?: number[] | null }).gmBagWeapon2Ids;
        const refreshIndex = this._normalRefreshUsed + 1;
        const slotCount = this.merge.bag.slotCount;
        const config = WeaponComposeConfigProvider.instance;

        const gmPresetAttempt = !gmIds?.length
            ? this._peekGmWeaponPresetQueue(slotCount)
            : [];
        const hasGmPreset = gmPresetAttempt.length > 0;

        logBagRefreshSection(`背包普通刷新 第${refreshIndex}次`);
        logBagRefreshDebug(
            '刷新参数',
            gmIds?.length ? `GM=${formatIdList(gmIds)}` : 'GM=关',
            hasGmPreset ? `预设队列=${formatIdList(gmPresetAttempt)}` : '',
            `N=${this._textPool.numberN}`,
        );

        let slots: { weapon2Id: number; weapon1Id?: number; level?: number }[] = [];
        const firstRefresh = this._normalRefreshUsed === 0;

        if (gmIds?.length) {
            for (let i = 0; i < slotCount; i++) {
                const id = gmIds[i % gmIds.length];
                slots.push({ weapon2Id: id });
                this._textPool.tryConsumeWeapon2Id(id);
            }
            logBagRefreshDebug('GM固定池', formatBagRollEntries(slots, config));
        } else if (hasGmPreset) {
            for (let i = 0; i < gmPresetAttempt.length && slots.length < slotCount; i++) {
                const id = gmPresetAttempt[i];
                slots.push({ weapon2Id: id });
                this._textPool.tryConsumeWeapon2Id(id);
            }
            const need = slotCount - slots.length;
            if (need > 0) {
                const needAtk = firstRefresh && !this._slotsHaveAttacker(slots);
                const rolled = this._textPool.rollSlots(need, needAtk);
                if (!rolled) {
                    throw new Error('[BattleBagSession] 字池耗尽，无法完成 GM 预设补齐');
                }
                for (let i = 0; i < rolled.length; i++) slots.push(rolled[i]);
            }
            this._commitGmWeaponPresetConsumption(gmPresetAttempt, slots);
            logBagRefreshDebug('GM预设+字池', formatBagRollEntries(slots, config));
        } else {
            if (!this._textPool.ready) {
                throw new Error('[BattleBagSession] 字池未就绪');
            }
            const rolled = this._textPool.rollSlots(slotCount, firstRefresh, false);
            if (!rolled) {
                throw new Error('[BattleBagSession] 字池耗尽，刷新失败');
            }
            slots = rolled;
            if (this._ownerPlayerId === 0) {
                this._firstHeroPity.applyToSlots(slots, this._normalRefreshUsed, this._textPool);
                this._comboPity.applyToSlots(slots, this._collectOwnerMapComboIds(), this._textPool);
            }
            if (firstRefresh) this._textPool.shuffleEntries(slots);
        }

        logBagRefreshDebug('最终背包', formatBagRollEntries(slots, config));
        logBagRefreshSection('背包普通刷新结束');
        this.merge.refreshBag(slots);
    }

    /** 本批是否已有可攻击单字 */
    private _slotsHaveAttacker(slots: readonly { weapon2Id: number }[]): boolean {
        for (let i = 0; i < slots.length; i++) {
            if (isAttackGlyph(slots[i].weapon2Id)) return true;
        }
        return false;
    }

    /** 己方地图上的组合碎字 Text.id（即将刷掉的旧背包不算） */
    private _collectOwnerMapComboIds(): number[] {
        const ids: number[] = [];
        const camp = this._ownerPlayerId + 1;
        const provider = WeaponComposeConfigProvider.instance;
        const indices = this.merge.map.gridIndices;
        for (let i = 0; i < indices.length; i++) {
            const gridIndex = indices[i];
            const tile = this.merge.map.getTile(gridIndex);
            if (!tile) continue;
            const grid = this._map.getMapGridByIndex(gridIndex);
            if (!grid?.node?.isValid || !grid.node.active) continue;
            if ((grid.CampAreaID | 0) !== camp) continue;
            if (provider.getWeapon2Type(tile.weapon2Id) !== Weapon2TileType.Combo) continue;
            ids.push(tile.weapon2Id);
        }
        return ids;
    }

    /** 预览 PopGM 预设队列队首（不消耗） */
    private _peekGmWeaponPresetQueue(maxCount: number): number[] {
        if (maxCount <= 0 || this._gmWeaponPresetQueue.length === 0) return [];
        return this._gmWeaponPresetQueue.slice(0, maxCount);
    }

    /**
     * 仅当本次刷新结果的前缀与预设一致时才 dequeue。
     * 未成功刷入背包的预设字保留在队首，下次刷新重试。
     */
    private _commitGmWeaponPresetConsumption(attempted: readonly number[], slots: readonly { weapon2Id: number }[]): void {
        if (!attempted.length || !this._gmWeaponPresetQueue.length) return;

        let consumed = 0;
        for (let i = 0; i < attempted.length; i++) {
            const slot = slots[i];
            if (!slot || slot.weapon2Id !== attempted[i]) break;
            consumed++;
        }

        if (consumed <= 0) {
            logBagRefreshDebug('GM预设队列: 本次未消耗', formatIdList(this._gmWeaponPresetQueue));
            return;
        }

        this._gmWeaponPresetQueue.splice(0, consumed);
        logBagRefreshDebug(
            'GM预设队列: 已消耗',
            `${consumed}个`,
            `剩余=${this._gmWeaponPresetQueue.length}`,
            this._gmWeaponPresetQueue.length ? formatIdList(this._gmWeaponPresetQueue) : '',
        );
    }

    /** 普通刷新：按 Const 扣桃子后重 roll 背包 */
    tryNormalRefresh(chapterId: number, battle: ProjectBattleHandle): 'ok' | 'not_enough' | 'failed' | 'pool_empty' {
        const slot = battle.session.players[this._ownerPlayerId] ?? (this._ownerPlayerId === 0 ? battle.localSlot : undefined);
        if (!slot) {
            console.log('[BattleBagSession] tryNormalRefresh: player slot missing', this._ownerPlayerId);
            return 'failed';
        }
        if (!this.canNormalRefreshFill()) {
            return 'pool_empty';
        }
        const cost = this.normalRefreshCost;
        if (slot.gold < cost) return 'not_enough';
        if (!slot.spendGold(cost)) return 'not_enough';
        if (this._ownerPlayerId === 0) {
            battle.CurentCoinNum = slot.gold;
        }
        try {
            this.refreshBag(chapterId);
            this._normalRefreshUsed++;
            return 'ok';
        } catch (e) {
            slot.addGold(cost);
            if (this._ownerPlayerId === 0) {
                battle.CurentCoinNum = slot.gold;
            }
            console.error('[BattleBagSession] refreshBag failed', String(e));
            return 'failed';
        }
    }

    /**
     * AI 逻辑落子：只改无头 Merge，不走底栏拖拽表现 / GEvent。
     * 仍须同步 MapGrid 格语义（铲 Dig→Put 等），否则引导/落子探测与逻辑层脱节。
     * @param source 拖拽源
     * @param target 目标
     */
    dropLogical(source: DragSource, target: DropTarget): PlaceRejectReason | null {
        if (target.kind === 'map' && !this.validator.isAllowedCampForPlace(target.gridIndex)) {
            return PlaceRejectReason.WrongCampArea;
        }
        this._snapshotHeroBindIfMapSource(source);
        const before = this._snapshotWalkKinds(source, target);
        this._skipOpenEffect = true;
        let reason: PlaceRejectReason | null = null;
        try {
            reason = this.merge.drop(source, target, { silent: true });
            if (reason) return reason;
            this._syncChangedCellVisuals(source, target);
            this._notifyWalkabilityIfNeeded(source, target, before);
        } finally {
            this._skipOpenEffect = false;
        }
        return null;
    }

    /**
     * 文昌笔：按局内字池单抽 1 个字（与刷新召唤规则一致）。
     * @param excludeWeapon2Id 尽量排除当前字
     */
    rollRewriteGlyph(excludeWeapon2Id: number): BagRollEntry | null {
        const rolled = this._textPool.rollSingleGlyph(excludeWeapon2Id);
        if (!rolled) {
            console.log('[BattleBagSession] 改字 roll 失败 exclude=', excludeWeapon2Id);
        }
        return rolled;
    }

    /** 是否还能改字 roll 出与当前不同的字 */
    canRollRewriteGlyph(excludeWeapon2Id: number): boolean {
        return this._textPool.canRollSingleGlyph(excludeWeapon2Id);
    }

    /** 广告刷新已下线 */
    tryAdRefresh(_chapterId: number): boolean {
        console.log('[BattleBagSession] 广告刷新已下线');
        return false;
    }

    /** 免费格子已下线 */
    grantFreeGrid(_chapterId: number): PlaceRejectReason | null {
        console.log('[BattleBagSession] 新产品不支持放置格子');
        return PlaceRejectReason.WrongCellKind;
    }

    /** 发放铲：优先背包空位，否则从下往上对第一个可开挖格直接使用 */
    grantShovel(_chapterId: number): PlaceRejectReason | null {
        if (!this.merge.prepActive) return PlaceRejectReason.NotPrepPhase;

        if (this.merge.grantGridInBag(SHOVEL_WEAPON2_ID)) {
            return null;
        }

        const gridIndex = this._findBottomUpDigGrid();
        if (gridIndex == null) {
            return PlaceRejectReason.BagFull;
        }

        const reason = this.merge.placeShovelOnMap(gridIndex, SHOVEL_WEAPON2_ID);
        if (reason) return reason;

        // Dig→Put 不改可走性：只同步格表现，禁止 notifyWalk 重寻路
        this._syncGridVisual(gridIndex);
        return null;
    }

    /**
     * 蟠桃树被动落点：优先空 Dig，没有再选空 Put（自下而上）。
     * @returns 地图格索引；无空 Dig/Put 时 null
     */
    findPassiveDigSpawnGrid(excludeGridIndices?: readonly number[]): number | null {
        const digs = this._collectPassiveDigSpawnCandidates(excludeGridIndices);
        if (digs.length > 0) return digs[0]?.Index ?? null;
        const puts = this._collectEmptyPutSpawnCandidates(excludeGridIndices);
        return puts[0]?.Index ?? null;
    }

    /** 查找背包首个空槽 */
    findEmptyBagSlot(excludeSlotIndices?: readonly number[]): number | null {
        if (!this.merge.prepActive) return null;
        const slotCount = this.merge.bag.slotCount;
        for (let i = 0; i < slotCount; i++) {
            if (excludeSlotIndices && excludeSlotIndices.indexOf(i) >= 0) continue;
            if (this.merge.bag.getSlot(i)) continue;
            return i;
        }
        return null;
    }

    /**
     * 查找己方首个空 Put 格（妙手神偷落点；优先于背包）。
     * 始终按 ownerPlayerId 对应 CampArea（0→1、1→2）过滤，不依赖 placeValidation 开关。
     * @returns 地图格索引；无空 Put 时 null
     */
    findStealReceiveMapGrid(): number | null {
        const camp = this._ownerPlayerId + 1;
        for (const grid of this._map.mapGrids) {
            if (!grid?.node?.isValid || !grid.node.active) continue;
            if ((grid.CampAreaID | 0) !== camp) continue;
            if (this.merge.map.getCellKind(grid.Index) !== MapCellKind.Put) continue;
            if (this.merge.map.hasTile(grid.Index)) continue;
            return grid.Index;
        }
        return null;
    }

    /** 己方是否存在可放置文字的空 Put 格（与 MapDragGuideHelper / 拖拽 + 一致） */
    hasLocalPlaceablePutGrid(): boolean {
        return this.countLocalPlaceablePutGrids() > 0;
    }

    /** 己方阵营可放置文字的空 Put 格数量 */
    countLocalPlaceablePutGrids(): number {
        const camp = this._ownerPlayerId + 1;
        return MapDragGuideHelper.countLocalEmptyPutGrids(this, this._map, camp);
    }

    /** 己方背包是否仍有字块可落到地图（空 Put / 升级 / 交换，与拉线落子一致） */
    hasLocalBagMapPlacement(): boolean {
        const camp = this._ownerPlayerId + 1;
        return MapDragGuideHelper.hasLocalCampBagPlacement(this, this._map, camp);
    }

    /** 己方阵营地图无单字/组合字可落空格（含无可放格场景） */
    isLocalCampMapPutSlotsFullForText(): boolean {
        return !this.hasLocalPlaceablePutGrid();
    }

    /** @deprecated 使用 countLocalPlaceablePutGrids */
    countLocalEmptyPutGrids(): number {
        return this.countLocalPlaceablePutGrids();
    }

    /** 己方背包 + 地图上的铲子数量 */
    countLocalShovelTiles(): number {
        let n = 0;
        const slots = this.getBagSlots();
        for (let i = 0; i < slots.length; i++) {
            const slot = slots[i];
            if (slot?.weapon2Id === SHOVEL_WEAPON2_ID) n++;
        }
        const camp = this._ownerPlayerId + 1;
        this.merge.map.forEachTile((gridIndex, tile) => {
            const grid = this._map.getMapGridByIndex(gridIndex);
            if (!grid?.node?.isValid || !grid.node.active) return;
            if ((grid.CampAreaID | 0) !== camp) return;
            if (tile.weapon2Id === SHOVEL_WEAPON2_ID) n++;
        });
        return n;
    }

    /** 是否可接收偷取字块（地图空 Put 或背包空槽） */
    canReceiveStolenTile(): boolean {
        return this.findStealReceiveMapGrid() != null || this.findEmptyBagSlot() != null;
    }

    /**
     * 妙手神偷落点：优先地图空 Put，否则背包空槽。
     * @returns 落点描述；无空位时 null
     */
    resolveStealReceivePlacement(): { kind: 'map'; gridIndex: number } | { kind: 'bag'; slotIndex: number } | null {
        const mapGrid = this.findStealReceiveMapGrid();
        if (mapGrid != null) return { kind: 'map', gridIndex: mapGrid };
        const slot = this.findEmptyBagSlot();
        if (slot != null) return { kind: 'bag', slotIndex: slot };
        return null;
    }

    /**
     * 随机查找己方空的可开挖格。
     * @param excludeGridIndices 飞行中已预留的挖格（同帧多铲互不抢同一格）
     * @returns 地图格索引；无候选时 null
     */
    findRandomPassiveDigGrid(excludeGridIndices?: readonly number[]): number | null {
        const candidates = this._collectPassiveDigSpawnCandidates(excludeGridIndices);
        if (candidates.length <= 0) return null;
        const pick = Math.floor(Math.random() * candidates.length);
        return candidates[pick]?.Index ?? null;
    }

    /** 被动铲：放入指定背包空槽 */
    grantShovelInBag(slotIndex: number): PlaceRejectReason | null {
        return this.merge.grantWeaponInBagSlot(slotIndex, SHOVEL_WEAPON2_ID);
    }

    /** 被动铲：对指定可开挖格使用（Dig→Put） */
    grantPassiveShovelOnDigGrid(gridIndex: number): PlaceRejectReason | null {
        if (!this.merge.prepActive) return PlaceRejectReason.NotPrepPhase;
        const reason = this.merge.placeShovelOnMap(gridIndex, SHOVEL_WEAPON2_ID);
        if (reason) return reason;
        // Dig→Put：只同步表现，不重寻路
        this._syncGridVisual(gridIndex);
        GEvent.Ins.emit(GEvent.UpdateBestPlace);
        return null;
    }

    /** 视图层将自行播放开挖链（铲 animaction）或被动产字直落时标记，跳过 playOpenEffect */
    deferOpenEffectForGrid(gridIndex: number): void {
        this._deferOpenFxGridIndex = Math.floor(Number(gridIndex) || 0);
    }

    /** 取消 deferOpenEffectForGrid（drop 失败时） */
    clearDeferredOpenEffect(): void {
        this._deferOpenFxGridIndex = null;
    }

    /** 己方空 Put 格候选（自下而上，蟠桃树 Dig 用尽后的落点） */
    private _collectEmptyPutSpawnCandidates(excludeGridIndices?: readonly number[]): MapGrid[] {
        const candidates: MapGrid[] = [];
        for (const grid of this._map.mapGrids) {
            if (!grid?.node?.isValid) continue;
            if (!this.validator.isOwnerCampCell(grid.Index)) continue;
            if (excludeGridIndices && excludeGridIndices.indexOf(grid.Index) >= 0) continue;
            if (this.merge.map.getCellKind(grid.Index) !== MapCellKind.Put) continue;
            if (this.merge.map.hasTile(grid.Index)) continue;
            candidates.push(grid);
        }
        candidates.sort((a, b) => {
            if (b.Row !== a.Row) return b.Row - a.Row;
            return a.Col - b.Col;
        });
        return candidates;
    }

    /** 己方空的可开挖格候选（自下而上排序，供首格/随机选取） */
    private _collectPassiveDigSpawnCandidates(excludeGridIndices?: readonly number[]): MapGrid[] {
        const candidates: MapGrid[] = [];
        for (const grid of this._map.mapGrids) {
            if (!grid?.node?.isValid) continue;
            if (!this.validator.isOwnerCampCell(grid.Index)) continue;
            if (excludeGridIndices && excludeGridIndices.indexOf(grid.Index) >= 0) continue;
            const kind = this.merge.map.getCellKind(grid.Index);
            if (kind !== MapCellKind.Dig) continue;
            if (this.merge.map.hasTile(grid.Index)) continue;
            candidates.push(grid);
        }
        candidates.sort((a, b) => {
            if (b.Row !== a.Row) return b.Row - a.Row;
            return a.Col - b.Col;
        });
        return candidates;
    }

    /**
     * 被动 buff：在空 Dig/Put 生成字块。
     * 蟠桃树（102）落到 Put 则 Put→Dig；其余字块 Dig→Put（defer 跳过 fillRange）。
     * @param gridIndex 目标格
     * @param weapon2Id Weapon2 文字 id
     */
    grantPassiveTileOnDigGrid(gridIndex: number, weapon2Id: number): PlaceRejectReason | null {
        if (!this.validator.isOwnerCampCell(gridIndex)) {
            return PlaceRejectReason.WrongCampArea;
        }
        WeaponComposeConfigProvider.instance.load();
        const keepDigCell = WeaponComposeConfigProvider.instance.passiveSpawnKeepsDigCell(weapon2Id);
        if (!keepDigCell) {
            this.deferOpenEffectForGrid(gridIndex);
        }
        const reason = this.merge.grantPassiveTileOnDigGrid(gridIndex, weapon2Id);
        if (reason) {
            if (!keepDigCell) {
                this.clearDeferredOpenEffect();
            }
            return reason;
        }
        // Dig→Put：_syncGridVisual 内 seal；Dig 本不可走，勿再走 _onWalkability 重寻路
        this._syncGridVisual(gridIndex);
        GEvent.Ins.emit(GEvent.UpdateBestPlace);
        return null;
    }

    pickupFromMap(gridIndex: number) {
        const result = this.merge.pickupFromMap(gridIndex);
        if (!('error' in result) && result.wasType3) {
            // type3 拖起：格恢复可行走，只重寻路，不驱逐
            this._onWalkabilityCellChanged(gridIndex, false);
        }
        return result;
    }

    revertType3Pickup(gridIndex: number, tile: Parameters<MergeSession['revertType3Pickup']>[1]): void {
        this.merge.revertType3Pickup(gridIndex, tile);
        this._onWalkabilityCellChanged(gridIndex, true);
    }

    drop(source: DragSource, target: DropTarget): PlaceRejectReason | null {
        if (target.kind === 'map' && !this.validator.isAllowedCampForPlace(target.gridIndex)) {
            this.merge.reject(PlaceRejectReason.WrongCampArea);
            return PlaceRejectReason.WrongCampArea;
        }
        this._snapshotHeroBindIfMapSource(source);
        const before = this._snapshotWalkKinds(source, target);
        const reason = this.merge.drop(source, target);
        if (reason) {
            this.merge.reject(reason);
            return reason;
        }
        this._syncChangedCellVisuals(source, target);
        this._notifyWalkabilityIfNeeded(source, target, before);
        GEvent.Ins.emit(GEvent.UpdateBestPlace);
        return null;
    }

    /**
     * 字块离开地图前，把当前英雄状态写到字上（进背包后仍能恢复）。
     * @param source 拖拽源
     */
    private _snapshotHeroBindIfMapSource(source: DragSource): void {
        if (source.kind !== 'map') return;
        const battle = gg.game.CurentBattle;
        if (!battle) return;
        const player = battle.getPlayer(this._ownerPlayerId);
        if (!player) return;
        const entityId = findEntityIdByGridIndex(source.gridIndex, battle.session, this._map, player);
        if (entityId == null) return;
        getTowerExpHost().syncBindToGlyphs(battle.session, player, this._map, entityId);
    }

    /**
     * 仅同步 MapGrid ↔ MX 可走性（不重寻路）。
     * 普通放字/合成不调用；开战/雷劈等需要全量对齐时用。
     */
    resyncWalkabilityFromMap(): boolean {
        return this.validator.resyncWalkabilityFromMap();
    }

    /**
     * 可走性真变时：同步 + 重建寻路场 + 只刷新路线。
     * @deprecated 外部请改用具体场景 API；保留给开战/雷劈兼容
     */
    resyncWalkabilityAndRefreshPaths(force = false): void {
        const changed = this.resyncWalkabilityFromMap();
        if (force || changed) {
            this.validator.notifyWalkStateChanged(true);
        }
    }

    private _snapshotWalkKinds(source: DragSource, target: DropTarget): Map<number, MapCellKind | null> {
        const out = new Map<number, MapCellKind | null>();
        const add = (idx: number) => out.set(idx, this.merge.map.getCellKind(idx));
        if (source.kind === 'map') add(source.gridIndex);
        if (target.kind === 'map') add(target.gridIndex);
        return out;
    }

    private _syncChangedCellVisuals(source: DragSource, target: DropTarget): void {
        const indices = createMembershipSet<number>();
        if (source.kind === 'map') membershipAdd(indices, source.gridIndex);
        if (target.kind === 'map') membershipAdd(indices, target.gridIndex);
        for (const idx of indices.keys()) this._syncGridVisual(idx);
    }

    /**
     * 仅当格语义导致可走性变化时（type3 / 铲）才同步 MX 并重寻路。
     * 往可放置格放字：可走性不变 → 完全不碰怪物。
     */
    private _notifyWalkabilityIfNeeded(
        source: DragSource,
        target: DropTarget,
        before: Map<number, MapCellKind | null>,
    ): void {
        const indices = createMembershipSet<number>();
        if (source.kind === 'map') membershipAdd(indices, source.gridIndex);
        if (target.kind === 'map') membershipAdd(indices, target.gridIndex);

        for (const idx of indices.keys()) {
            const prev = before.get(idx) ?? null;
            const next = this.merge.map.getCellKind(idx);
            if (!this._walkabilityChanged(prev, next)) continue;

            // 可行走 → 不可走：先赶走该格怪物，再改寻路
            const becameBlocked = prev === MapCellKind.Walkable && next !== MapCellKind.Walkable;
            this._onWalkabilityCellChanged(idx, becameBlocked);
        }
    }

    private _walkabilityChanged(prev: MapCellKind | null, next: MapCellKind | null): boolean {
        const walk = (k: MapCellKind | null) => k === MapCellKind.Walkable;
        return walk(prev) !== walk(next);
    }

    /**
     * @param evictHere type3 落子把格堵死时，只驱逐该格上的怪
     */
    private _onWalkabilityCellChanged(gridIndex: number, evictHere: boolean): void {
        this._syncGridVisual(gridIndex);
        const grid = this.validator.getGridByIndex(gridIndex);
        if (!grid) return;

        // 单格同步到 MX（不靠 hasTile 挡路）
        this.validator.resyncWalkabilityFromMap();
        if (evictHere) {
            this.validator.session?.movement.evictEnemiesAtCell(grid.Row, grid.Col);
        }
        this.validator.notifyWalkStateChanged(true);
    }

    private _findBottomUpDigGrid(): number | null {
        const candidates: MapGrid[] = [];
        for (const grid of this._map.mapGrids) {
            if (!grid?.node?.isValid) continue;
            const kind = this.merge.map.getCellKind(grid.Index);
            if (kind !== MapCellKind.Dig) continue;
            if (this.merge.map.hasTile(grid.Index)) continue;
            candidates.push(grid);
        }

        candidates.sort((a, b) => {
            if (b.Row !== a.Row) return b.Row - a.Row;
            return a.Col - b.Col;
        });

        return candidates[0]?.Index ?? null;
    }

    private _findBottomUpWalkableGrid(): number | null {
        const candidates: MapGrid[] = [];
        for (const grid of this._map.mapGrids) {
            if (!grid?.node?.isValid) continue;
            const kind = this.merge.map.getCellKind(grid.Index);
            if (kind !== MapCellKind.Walkable) continue;
            if (!grid.isCanPutGrid) continue;
            if (this.merge.map.hasTile(grid.Index)) continue;
            candidates.push(grid);
        }

        candidates.sort((a, b) => {
            if (b.Row !== a.Row) return b.Row - a.Row;
            return a.Col - b.Col;
        });

        for (const grid of candidates) {
            if (this.validator.canPlaceType3Grid(grid.Index)) {
                return grid.Index;
            }
        }
        return null;
    }

    private _initMapCells(): void {
        for (const grid of this._map.mapGrids) {
            if (!grid) continue;
            const snap = this.validator.snapshotCell(grid);
            this.merge.map.initCell(grid.Index, snap);
        }
    }

    /**
     * 将对端 merge 的己方阵营空格 kind 对齐到本格（蟠桃/铲）。
     * 对端有字或非己方阵营则跳过，避免把已放置字刷成开挖皮。
     * @param peer 对端 bag
     * @param gridIndex 格
     * @param kind 落子后 kind
     */
    alignPeerCellKind(peer: BattleBagSession, gridIndex: number, kind: MapCellKind | null): void {
        if (!peer || peer === this || !kind) return;
        if (!this.validator.isOwnerCampCell(gridIndex)) {
            console.warn('[BattleBagSession] 跳过对端格同步：非己方阵营', this._ownerPlayerId, gridIndex, kind);
            return;
        }
        if (peer.merge.map.hasTile(gridIndex)) {
            console.warn('[BattleBagSession] 跳过对端格同步：对端有字', this._ownerPlayerId, gridIndex, kind);
            return;
        }
        if (kind === MapCellKind.Put) {
            peer.merge.map.markCellAsPut(gridIndex);
            return;
        }
        if (kind === MapCellKind.Dig) {
            peer.merge.map.markCellAsDig(gridIndex);
        }
    }

    private _syncGridVisual(gridIndex: number): void {
        const grid = this.validator.getGridByIndex(gridIndex);
        if (!grid) return;
        if (!this.validator.isOwnerCampCell(gridIndex)) return;
        const kind = this.merge.map.getCellKind(gridIndex);
        if (!kind) return;

        // Dig→Put：默认播 openSpine+fill；铲链/被动产字已 defer 则只切可放置态
        if (kind === MapCellKind.Put && grid.isCanBeDig) {
            this.validator.applyCellKind(grid, kind);
            this._sealDigPutNotWalkable(gridIndex);
            if (this._deferOpenFxGridIndex === gridIndex) {
                this._deferOpenFxGridIndex = null;
                return;
            }
            // AI dropLogical：无飞铲动画，只切格态并清挖遮罩，避免 dig/FILLED 残留成黑叉
            if (this._skipOpenEffect) {
                grid.clearDigOpenFx();
                return;
            }
            grid.playOpenEffect();
            return;
        }

        this.validator.applyCellKind(grid, kind);
    }

    /**
     * Dig→Put 后强制不可走。
     * 可走性未变时不动寻路（第二次铲再 rebuild 易把怪路径打乱成「猴」柱）。
     * 仅 MX 仍可走时强制关闭并延后 refreshEnemyPaths。
     * @param gridIndex 目标格
     */
    private _sealDigPutNotWalkable(gridIndex: number): void {
        const grid = this.validator.getGridByIndex(gridIndex);
        const session = this.validator.session;
        if (!grid || !session) return;

        if (grid.isCanWalk) {
            console.log('[BattleBagSession] Dig→Put 后 MapGrid 仍可走，强制关闭', gridIndex);
            grid.isCanWalk = false;
            grid.updateGrid();
        }

        const cell = { row: grid.Row, col: grid.Col };
        if (!session.grid.inBounds(cell)) return;
        if (!session.grid.isWalkable(cell)) {
            // Dig→Put 本就不可走：禁止 rebuild/refresh，避免第二次铲叠乱怪路径
            return;
        }

        console.log(`[BattleBagSession] Dig→Put 后 MX 仍可走，强制关闭并延后重寻路 grid=${gridIndex} row=${cell.row} col=${cell.col}`);
        session.grid.setWalkable(cell, false);
        session.movement.evictEnemiesAtCell(cell.row, cell.col);
        this._deferNotifyWalkStateChanged();
    }

    /** 延后到本帧物理之后再 notifyWalk，避免与 Box2D UpdatePairs 同帧冲突 */
    private _deferNotifyWalkStateChanged(): void {
        director.once(Director.EVENT_AFTER_UPDATE, this._onDeferredNotifyWalk, this);
    }

    private _onDeferredNotifyWalk(): void {
        if (!this.validator.session) return;
        this.validator.notifyWalkStateChanged(true);
    }

    /** 将逻辑层背包槽同步为表现层可读数据 */
    getBagSlots(): readonly (BagSlotRecord | null)[] {
        return this.merge.bag.slots;
    }

    /**
     * 地图可放字格是否已满：存在可放字格，且每一格都已有字块。
     * 以逻辑层 Put 为准（含刚落下的 type3 空格 / 铲）；排除障碍误标 Put。
     * 注意：TilePlaced 可能早于 MapGrid.isCanPutText 同步，故不能只看 isCanPutText。
     */
    isMapPutSlotsFull(): boolean {
        let putCount = 0;
        for (const idx of this.merge.map.gridIndices) {
            if (this.merge.map.getCellKind(idx) !== MapCellKind.Put) continue;
            const grid = this.validator.getGridByIndex(idx);
            if (!grid?.node?.isValid || !grid.node.active) continue;

            const hasTile = this.merge.map.hasTile(idx);
            // 现场可放字，或逻辑已 Put 但视觉尚未 sync（type3 / 铲）
            const isPlaceableTextCell =
                !!grid.isCanPutText
                || hasTile
                || this.merge.map.isPrepType3(idx)
                || grid.isCanWalk
                || grid.isCanBeDig;
            if (!isPlaceableTextCell) continue;

            putCount++;
            if (!hasTile) return false;
        }
        return putCount > 0;
    }

    exportCounters(): {
        adRefreshUsed: number;
        normalRefreshUsed: number;
        heroRefreshAlgorithmUsed: boolean;
        firstBattlePending: number;
        textPool: PlayerBagTextPoolState;
    } {
        return {
            adRefreshUsed: 0,
            normalRefreshUsed: this._normalRefreshUsed,
            heroRefreshAlgorithmUsed: this._comboPity.stopped,
            firstBattlePending: this._firstHeroPity.pendingPartner,
            textPool: this._textPool.exportState(),
        };
    }

    importCounters(counters: {
        adRefreshUsed: number;
        normalRefreshUsed: number;
        heroRefreshAlgorithmUsed: boolean;
        firstBattlePending?: number;
        textPool?: PlayerBagTextPoolState;
    }): void {
        this._normalRefreshUsed = counters.normalRefreshUsed;
        this._comboPity.setStopped(!!counters.heroRefreshAlgorithmUsed);
        this._firstHeroPity.setPendingPartner(counters.firstBattlePending ?? 0);
        if (counters.textPool) {
            this._textPool.importState(counters.textPool);
        }
    }

    /** 本局普通刷新已用次数（快照恢复后用于引导续接） */
    get normalRefreshUsed(): number {
        return this._normalRefreshUsed;
    }

    /** 战斗快照：将己方阵营 merge 逻辑格（Put/Walkable/type3/铲）同步到 MapGrid 表现 */
    syncMapCellVisualsFromLogic(): void {
        for (const idx of this.merge.map.gridIndices) {
            this._syncGridVisual(idx);
        }
    }

    /** Skill.atk_buff type9：可放置格改为可开挖并吞单字 */
    skillSwallowDeployTile(gridIndex: number): boolean {
        return this.skillSealPutToDig(gridIndex);
    }

    /**
     * 千里眼：可放置格改为可开挖并同步 MapGrid。
     * @param gridIndex 地图格
     */
    skillSealPutToDig(gridIndex: number): boolean {
        const ok = this.merge.skillSealPutToDig(gridIndex);
        if (!ok) return false;
        this._syncGridVisual(gridIndex);
        return true;
    }
}

/** 免费格子失败提示（已下线） */
export function freeGridFailMessage(_reason: PlaceRejectReason | null): string {
    return '新产品不支持放置格子';
}

/** 铲发放失败提示 */
export function shovelFailMessage(reason: PlaceRejectReason | null): string {
    if (reason === PlaceRejectReason.BagFull) {
        return '背包已满且没有可开挖格子';
    }
    if (reason) {
        return rejectReasonToMessage(reason) ?? '无法获得铲';
    }
    return '无法获得铲';
}

/** @deprecated 使用 shovelFailMessage */
export function goldenFingerFailMessage(reason: PlaceRejectReason | null): string {
    return shovelFailMessage(reason);
}