import Service from "../../Script/module/Config/PyramidService";
import PyramidDigits from "./PyramidDigits";
import PyramidAnimationDebug from "./PyramidAnimationDebug";
import { remainingProbabilities, probabilityText } from "./PyramidProbability";
const { ccclass, property } = cc._decorator;
const GOODS = { 1001: "coin", 2001: "freeze", 2002: "hammer", 2003: "magic", 2005: "infinite" };
const GOODS_IDS = [1001, 2001, 2002, 2003, 2005];
// Temporary test entry: remove this flag, the debug branch/session and PyramidAnimationDebug.ts before release.
const PYRAMID_ANIMATION_DEBUG = false;
const DRAW_ANIMATION_SPEED = 1.2;

@ccclass
export default class PyramidPanel extends cc.Component {
    @property([cc.SpriteFrame]) goodsFrames: cc.SpriteFrame[] = [];
    @property([cc.SpriteFrame]) movingGoodsFrames: cc.SpriteFrame[] = [];
    @property(cc.SpriteFrame) hourFrame: cc.SpriteFrame = null;
    @property(cc.SpriteFrame) minuteFrame: cc.SpriteFrame = null;
    @property(cc.SpriteFrame) countPrefixFrame: cc.SpriteFrame = null;
    @property(cc.SpriteFrame) probabilityCloseFrame: cc.SpriteFrame = null;
    @property([cc.SpriteFrame]) countdownFrames: cc.SpriteFrame[] = [];
    @property(cc.SpriteFrame) countdownBackgroundFrame: cc.SpriteFrame = null;
    private frames: { [name: string]: cc.SpriteFrame } = {};
    private digits: { [key: string]: cc.SpriteFrame } = {};
    private price: { [key: string]: cc.SpriteFrame } = {};
    private probabilityDigits: { [key: string]: cc.SpriteFrame } = {};
    private continueFrame: cc.SpriteFrame = null;
    private continueMaterial: cc.Material = null;
    private bundle: cc.AssetManager.Bundle = null;
    private priceTask: Promise<void> = null;
    private priceError = false;
    private probabilityTask: Promise<void> = null;
    private probabilityModal: cc.Node = null;
    private design: cc.Node;
    private rewardRoot: cc.Node;
    private tip: cc.Node;
    private ready = false;
    private signature = "";
    private unsubscribe: () => void;
    private closing: () => void;
    private clock = 0;
    private clockText: cc.Node = null;
    private clockSignature = "";
    private shimmer: cc.Node = null;
    private animation: Promise<void> = null;
    private drawing = false;
    private finishAnimation: () => void = null;
    private renderedDraw = "";
    private rewardAnimation: cc.Node = null;
    private summitGlow: cc.Node = null;
    private claimPulseNode: cc.Node = null;
    private claimPulseTime = 0;
    private currentArrows: cc.Node[] = [];
    private arrowTime = 0;
    private debugSession: PyramidAnimationDebug = null;
    private animationDebug(): boolean {
        return PYRAMID_ANIMATION_DEBUG && ((typeof CC_PREVIEW !== "undefined" && CC_PREVIEW)
            || ["开发版", "体验版", "网页版"].includes(cc.fx.GameTool.getWechatGameVersion()));
    }
    private state(): any {
        const source = Service.data();
        if (!this.animationDebug()) return source;
        if (!source) { this.debugSession = null; return null; }
        const identity = String(cc.fx.GameConfig.GM_INFO.uid) + ":" + source.periodId;
        if (!this.debugSession || this.debugSession.identity !== identity)
            this.debugSession = new PyramidAnimationDebug(source, identity);
        return this.debugSession.state;
    }
    private isAlive(): boolean {
        return cc.isValid(this, true) && cc.isValid(this.node, true);
    }
    async initialize(close: () => void): Promise<void> {
        if (!this.isAlive()) return;
        this.closing = close; this.design = this.node.getChildByName("Design");
        this.summitGlow = this.design.getChildByName("SummitGlow");
        this.rewardRoot = this.design.getChildByName("Rewards"); this.tip = this.design.getChildByName("Tooltip");
        const size = cc.view.getVisibleSize(); this.design.setScale(Math.min(size.width / 1080, size.height / 2000));
        this.node.setContentSize(size);
        const shield = new cc.Node("Backdrop"); this.node.insertChild(shield, 0); shield.setContentSize(size);
        const graphics = shield.addComponent(cc.Graphics); graphics.fillColor = new cc.Color(0, 0, 0, 165);
        graphics.rect(-size.width / 2, -size.height / 2, size.width, size.height); graphics.fill();
        shield.addComponent(cc.BlockInputEvents); this.node.addComponent(cc.BlockInputEvents);
        const bundle = await Service.bundle().catch(error => { if (this.isAlive()) throw error; return null; });
        if (!this.isAlive()) return;
        this.bundle = bundle;
        if (this.goodsFrames.length !== GOODS_IDS.length || this.movingGoodsFrames.length !== GOODS_IDS.length || !this.hourFrame || !this.minuteFrame)
            throw new Error("金字塔新版奖励素材配置不完整");
        if (this.countdownFrames.length !== 10 || !this.countdownBackgroundFrame)
            throw new Error("金字塔缺少黄金矿工倒计时素材");
        GOODS_IDS.forEach((id, index) => { this.frames[GOODS[id]] = this.goodsFrames[index]; });
        this.frames.hours = this.hourFrame;
        this.frames.minutes = this.minuteFrame;
        const paths = ["check", "selection", "arrow", "arrow-dim", "draw", "yuan", "free", "claim", "tooltip", "question", "pointer", "chest-1", "chest-2", "chest-3", "chest-4"];
        for (let i = 1; i <= 5; i++) paths.push("row-" + i);
        for (let i = 0; i < 10; i++) paths.push("digits/" + i);
        await Promise.all(paths.map(path => new Promise<void>((resolve, reject) => this.bundle.load("art/" + path, cc.SpriteFrame, (err, frame: cc.SpriteFrame) => {
            if (!this.isAlive()) { resolve(); return; }
            if (err) { reject(err); return; } this.frames[path] = frame; resolve();
        })))).catch(error => { if (this.isAlive()) throw error; });
        if (!this.isAlive()) return;
        for (let i = 0; i < 10; i++) this.digits[i] = this.frames["digits/" + i];
        if (!this.countPrefixFrame) throw new Error("金字塔缺少数量前缀 x 图片");
        this.digits.x = this.countPrefixFrame;
        if (this.state() && this.state().canPay) await this.ensurePriceAssets();
        if (!this.isAlive()) return;
        this.design.getChildByName("Free").getComponent(cc.Sprite).spriteFrame = this.frames.free;
        this.button("Close", () => { if (!Service.deliveryBusy && !this.animation && !this.drawing) this.closing(); });
        this.button("Help", () => { void this.help(); });
        this.button("Free", () => { if (this.state() && this.state().canClaimFinal) void this.action(); });
        this.button("Action", () => { void this.action(); });
        // Capture before the backdrop's BlockInputEvents stops bubbling.
        this.node.on(cc.Node.EventType.TOUCH_START, () => { this.tip.active = false; }, this, true);
        this.unsubscribe = Service.subscribe(() => this.render()); this.ready = true; this.tip.active = false; this.render();
        if (!this.animationDebug()) {
            void Service.recordPriceView();
            if (this.state() && this.state().pendingGrants.length) await Service.deliver();
        }
    }
    private button(name: string, callback: () => void): void {
        const node = this.design.getChildByName(name); const button = node.addComponent(cc.Button);
        button.transition = cc.Button.Transition.SCALE; button.zoomScale = 1.04; node.on("click", callback);
    }
    private sprite(parent: cc.Node, name: string, frame: string, x: number, y: number, w: number, h: number): cc.Node {
        const n = new cc.Node(name); parent.addChild(n); n.setPosition(x, y);
        const s = n.addComponent(cc.Sprite);
        const isGood = GOODS_IDS.some(id => GOODS[id] === frame);
        s.sizeMode = isGood
            ? cc.Sprite.SizeMode.TRIMMED
            : cc.Sprite.SizeMode.CUSTOM;
        s.spriteFrame = this.frames[frame];
        if (isGood) {
            const rect = s.spriteFrame.getRect();
            n.setScale(Math.min(w / rect.width, h / rect.height));
        } else {
            n.setContentSize(w, h);
        }
        return n;
    }
    private words(parent: cc.Node, text: string, x: number, y: number, size: number, width = 800): cc.Node {
        // Counts and prices use number(); the countdown has its own Label.
        if (/\d/.test(text)) throw new Error("金字塔数值禁止使用 Label");
        const n = new cc.Node("Text"); parent.addChild(n); n.setPosition(x, y); n.setContentSize(width, size * 2.5);
        const label = n.addComponent(cc.Label); label.string = text; label.fontSize = size; label.lineHeight = size + 7;
        label.horizontalAlign = cc.Label.HorizontalAlign.CENTER; label.verticalAlign = cc.Label.VerticalAlign.CENTER;
        label.overflow = cc.Label.Overflow.SHRINK; n.setContentSize(width, size * 2.5); n.color = new cc.Color(105, 53, 31);
        return n;
    }
    private number(parent: cc.Node, value: number | string, x: number, y: number, height: number, width: number, price = false): cc.Node {
        const n = new cc.Node("SpriteNumber"); parent.addChild(n); n.setPosition(x, y);
        n.addComponent(PyramidDigits).set(value, price ? this.price : this.digits, height, width); return n;
    }
    private quantity(parent: cc.Node, good: { id: number; count: number }, x: number, y: number, height: number, width: number): void {
        const n = new cc.Node("Quantity"); parent.addChild(n); n.setPosition(x, y);
        const value = good.count;
        n.addComponent(PyramidDigits).set(good.id === 1001 ? value : "x" + value, this.digits, height, width, true);
    }
    private duration(parent: cc.Node, seconds: number, x: number, y: number, width: number, numberHeight: number, unitWidth: number, unitHeight: number, scale = 1): void {
        const useHours = seconds >= 3600;
        const value = Math.ceil(seconds / (useHours ? 3600 : 60));
        const unitFrame = useHours ? "hours" : "minutes", gap = 2;
        const container = new cc.Node("Duration"); parent.addChild(container); container.setPosition(x, y); container.setScale(scale);
        // Allow two-digit durations at the same height as single-digit hours.
        const numberNode = this.number(container, value, 0, 0, numberHeight, width);
        const numberWidth = numberNode.width * numberNode.scaleX;
        const unit = this.sprite(container, useHours ? "Hours" : "Minutes", unitFrame, 0, 0, unitWidth, unitHeight);
        const contentWidth = numberWidth + gap + unitWidth;
        numberNode.x = -contentWidth / 2 + numberWidth / 2;
        unit.x = -contentWidth / 2 + numberWidth + gap + unitWidth / 2;
    }
    private continueHint(parent: cc.Node, x: number, y: number): cc.Node {
        const node = new cc.Node("ClickToContinue"); parent.addChild(node); node.setPosition(x, y); node.setContentSize(228, 47);
        const sprite = node.addComponent(cc.Sprite); sprite.sizeMode = cc.Sprite.SizeMode.TRIMMED; sprite.spriteFrame = this.continueFrame;
        sprite.setMaterial(0, this.continueMaterial);
        return node;
    }
    private ensurePriceAssets(): Promise<void> {
        if (!this.isAlive()) return Promise.resolve();
        if (this.price["0"]) return Promise.resolve();
        if (!this.priceTask) {
            this.priceError = false;
            this.priceTask = Promise.all(Array.from({ length: 10 }, (_, i) => new Promise<void>((resolve, reject) => {
                this.bundle.load("art/price/" + i, cc.SpriteFrame, (error, frame: cc.SpriteFrame) => {
                    if (!this.isAlive()) { resolve(); return; }
                    if (error) { reject(error); return; } this.price[i] = frame; resolve();
                });
            }))).then(() => { }).catch(error => {
                if (!this.isAlive()) return;
                this.priceTask = null; this.priceError = true; throw error;
            });
        }
        return this.priceTask;
    }
    private ensureProbabilityAssets(): Promise<void> {
        if (!this.isAlive()) return Promise.resolve();
        if (this.probabilityDigits["0"] && this.continueFrame && this.continueMaterial) return Promise.resolve();
        if (!this.probabilityTask) {
            const paths = ["probability/background", "probability/title", "probability/point", "probability/percent"];
            for (let i = 0; i < 10; i++) paths.push("probability/" + i);
            const pyramidAssets = Promise.all(paths.map(path => new Promise<void>((resolve, reject) => {
                this.bundle.load("art/" + path, cc.SpriteFrame, (error, frame: cc.SpriteFrame) => {
                    if (!this.isAlive()) { resolve(); return; }
                    if (error) { reject(error); return; } this.frames[path] = frame; resolve();
                });
            })));
            const sharedAssets = new Promise<cc.AssetManager.Bundle>((resolve, reject) => {
                cc.assetManager.loadBundle("cloud_rise_home", (error, bundle) => {
                    if (!this.isAlive()) { resolve(null); return; }
                    error ? reject(error) : resolve(bundle);
                });
            }).then(bundle => {
                if (!this.isAlive()) return;
                return Promise.all([
                    new Promise<void>((resolve, reject) => bundle.load("images/continue", cc.SpriteFrame, (error, frame: cc.SpriteFrame) => {
                        if (!this.isAlive()) { resolve(); return; }
                        if (error) { reject(error); return; } this.continueFrame = frame; resolve();
                    })),
                    new Promise<void>((resolve, reject) => bundle.load("images/continue_outline", cc.Material, (error, material: cc.Material) => {
                        if (!this.isAlive()) { resolve(); return; }
                        if (error) { reject(error); return; } this.continueMaterial = material; resolve();
                    }))
                ]);
            });
            this.probabilityTask = Promise.all([pyramidAssets, sharedAssets]).then(() => {
                if (!this.isAlive()) return;
                for (let i = 0; i < 10; i++) this.probabilityDigits[i] = this.frames["probability/" + i];
                this.probabilityDigits["."] = this.frames["probability/point"]; this.probabilityDigits["%"] = this.frames["probability/percent"];
            }).catch(error => {
                if (!this.isAlive()) return;
                this.probabilityTask = null; throw error;
            });
        }
        return this.probabilityTask;
    }
    private rewardIcon(reward: any, level: any): string {
        const base = reward.icon && this.frames[reward.icon] ? reward.icon : reward.goods.length > 1 ? "chest-1" : GOODS[reward.goods[0].id];
        if (level.level !== 5 || !/^chest-[1-4]$/.test(base)) return base;
        // Same coin-equivalent values as the activity policy; infinite-health counts are seconds.
        const values = { 1001: 1, 2001: 200, 2002: 600, 2003: 300, 2005: 40 / 60 };
        const value = (r: any) => r.goods.reduce((sum, g) => sum + g.count * (values[g.id] || 0), 0);
        const chests = level.rewards.filter(r => /^chest-[1-4]$/.test(r.icon) || r.goods.length > 1);
        if (chests.length < 2) return base;
        const highest = chests.reduce((best, r) => value(r) > value(best) ? r : best);
        return reward.rewardId === highest.rewardId ? "chest-4" : "chest-2";
    }
    private rewardRow(level: number): cc.Node {
        const row = this.rewardRoot.getChildByName("Level_" + level);
        if (!row) throw new Error(`金字塔 prefab 缺少 Level_${level} 奖励层节点`);
        return row;
    }
    private rewardSlots(row: cc.Node): cc.Node[] {
        return row.children.filter(node => /^Slot_\d+$/.test(node.name)).sort((left, right) => {
            return Number(left.name.slice(5)) - Number(right.name.slice(5));
        });
    }
    private fillRewardRows(state: any): void {
        this.currentArrows = []; this.arrowTime = 0;
        state.levels.filter(level => level.level < 6).forEach(level => {
            const row = this.rewardRow(level.level);
            const background = row.getChildByName("CurrentLevelBackground");
            if (!background) throw new Error(`金字塔 prefab 缺少 Level_${level.level}/CurrentLevelBackground 节点`);
            background.active = level.level === state.currentLevel;
            if (background.active) {
                // Supplied strips run from the narrow top (row-1) to the wide bottom (row-5).
                const frame = this.frames["row-" + (6 - level.level)];
                const sprite = background.getComponent(cc.Sprite) || background.addComponent(cc.Sprite);
                // Keep the prefab's layer bounds; loading a frame must not resize into adjacent layers.
                sprite.sizeMode = cc.Sprite.SizeMode.CUSTOM; sprite.spriteFrame = frame;
            }
            const slots = this.rewardSlots(row);
            let arrows = row.getChildByName("Arrows");
            if (!arrows) { arrows = new cc.Node("Arrows"); row.addChild(arrows); }
            this.clear(arrows);
            if (level.rewards.length > slots.length)
                throw new Error(`金字塔 Level_${level.level} 奖励数 ${level.rewards.length} 超出 prefab 槽位数 ${slots.length}`);
            slots.forEach((slot, index) => {
                slot.targetOff(this); this.clear(slot);
                const reward = level.rewards[index]; slot.active = !!reward;
                (slot as any).pyramidRewardId = reward ? reward.rewardId : null;
                if (!reward) return;
                const base = this.rewardIcon(reward, level);
                const chest = /^chest-[1-4]$/.test(base);
                this.sprite(slot, "Prize", base || "chest-1", 0, 6, 105, 100);
                if (!chest && reward.goods.length === 1) {
                    const good = reward.goods[0];
                    if (good.id === 2005) {
                        this.duration(slot, good.count, 0, -43, 100, 34, 62, 33);
                    } else {
                        this.quantity(slot, good, 0, -43, 34, 125);
                    }
                } else if (chest) this.sprite(slot, "Details", "question", 45, 45, 38, 40);
                if (reward.up === true) {
                    // Keep the slot transform while drawing arrows above the full-row mask.
                    const anchor = new cc.Node(slot.name); arrows.addChild(anchor);
                    anchor.setPosition(slot.x, slot.y); anchor.scaleX = slot.scaleX; anchor.scaleY = slot.scaleY;
                    const arrow = this.sprite(anchor, "Up", level.level === state.currentLevel ? "arrow-dim" : "arrow", 0, 90, 54, 52);
                    if (level.level === state.currentLevel) this.currentArrows.push(arrow);
                }
                if (reward.deliveryStatus === "delivered") this.sprite(slot, "Check", "check", 0, 4, 78, 78);
                else if (reward.deliveryStatus === "pending") {
                    const glow = this.sprite(slot, "Selected", "selection", 0, 4, 134, 127); glow.setSiblingIndex(0);
                }
                if (chest) slot.on(cc.Node.EventType.TOUCH_END, (event: cc.Event.EventTouch) => {
                    event.stopPropagation(); this.details(reward, slot);
                }, this);
            });
            let cover = row.getChildByName("PassedLevelMask");
            if (!cover) {
                cover = new cc.Node("PassedLevelMask"); row.addChild(cover); cover.addComponent(cc.Graphics);
            }
            cover.setPosition(background.x, background.y);
            cover.setContentSize(background.width, background.height);
            cover.scaleX = background.scaleX; cover.scaleY = background.scaleY;
            const gray = cover.getComponent(cc.Graphics); gray.clear(); gray.fillColor = new cc.Color(100, 100, 100, 100);
            gray.rect(-cover.width / 2, -cover.height / 2, cover.width, cover.height); gray.fill();
            cover.active = level.level < state.currentLevel;
            cover.setSiblingIndex(row.childrenCount - 1);
            arrows.setSiblingIndex(row.childrenCount - 1);
        });
    }
    private render(): void {
        if (!this.ready || !this.isAlive()) return;
        const s = this.state(); if (!s) return;
        const signature = JSON.stringify([s.revision, s.periodId, s.currentLevel]);
        if (signature !== this.signature && !this.drawing) {
            this.signature = signature; this.tip.active = false;
            if (this.shimmer) { cc.Tween.stopAllByTarget(this.shimmer); this.shimmer.destroy(); this.shimmer = null; }
            this.fillRewardRows(s);
            if (this.probabilityModal) void this.help();
        }
        const action = this.design.getChildByName("Action");
        const actionButton = action.getComponent(cc.Button);
        const enabled = !Service.busy && !this.animation && !this.drawing && (this.animationDebug() || Service.now() < s.endAt);
        const claim = this.design.getChildByName("Free"); claim.active = true;
        claim.getComponent(cc.Sprite).spriteFrame = s.currentLevel === 6 ? this.frames.claim : this.frames.free;
        claim.getComponent(cc.Button).interactable = enabled && s.currentLevel === 6 && s.canClaimFinal && !s.completed;
        claim.opacity = 255;
        this.syncClaimPulse(claim, s.currentLevel === 6 && s.canClaimFinal && !s.completed && Service.now() < s.endAt);
        const showsPrice = !s.canDraw && s.currentLevel < 6, pricePending = showsPrice && !this.price["0"];
        if (pricePending && !this.priceTask && !this.priceError) void this.ensurePriceAssets().then(() => this.render(), error => {
            cc.warn("[Pyramid] 价格资源加载失败", error); if (cc.isValid(this.node, true)) this.render();
        });
        if (this.drawing || pricePending) {
            // Keep the previous draw artwork while throttling taps or preparing the configured price.
            actionButton.interactable = !this.drawing && this.priceError && enabled; this.renderClock(); return;
        }
        action.active = s.currentLevel < 6;
        action.children.slice().forEach(n => n.destroy());
        actionButton.interactable = enabled && (!s.completed || (!this.animationDebug() && !!Service.error));
        if (!action.active) { this.renderClock(); return; }
        if (s.canDraw) this.sprite(action, "Draw", "draw", 0, 0, 160, 79);
        else {
            const fen = s.levels[s.currentLevel - 1].itemPrice;
            if (fen % 100 === 0) { const n = this.number(action, fen / 100, -43, 0, 65, 325, true); this.sprite(action, "Yuan", "yuan", (n.width * n.scaleX + 18) / 2, 0, 67, 65); }
            else { this.number(action, fen, -35, 0, 65, 325, true); this.words(action, "分", 110, 0, 50, 70); }
        }
        this.renderClock();
    }
    private syncClaimPulse(node: cc.Node, active: boolean): void {
        if (active && !this.claimPulseNode) {
            this.claimPulseNode = node; this.claimPulseTime = 0; node.setScale(1);
            node.getComponent(cc.Button).transition = cc.Button.Transition.NONE;
        } else if (!active && this.claimPulseNode) {
            this.claimPulseNode.setScale(1); this.claimPulseNode = null;
            node.getComponent(cc.Button).transition = cc.Button.Transition.SCALE;
        }
    }
    private renderClock(): void {
        const n = this.design.getChildByName("Countdown"), s = this.state(); if (!s) return;
        if (!this.clockText) {
            const pill = new cc.Node("ClockBackground"); n.addChild(pill); pill.setContentSize(283, 56);
            const background = pill.addComponent(cc.Sprite); background.sizeMode = cc.Sprite.SizeMode.CUSTOM;
            background.spriteFrame = this.countdownBackgroundFrame;
            this.clockText = new cc.Node("ClockText"); n.addChild(this.clockText); this.clockText.setPosition(25, 0);
        }
        const remaining = Math.max(0, s.endAt - Service.now()), secs = Math.ceil(remaining / 1000);
        const pad = (value: number) => value < 10 ? "0" + value : String(value);
        const text = secs >= 86400
            ? `${Math.floor(secs / 86400)}天${Math.floor(secs % 86400 / 3600)}时`
            : `${pad(Math.floor(secs / 3600))}:${pad(Math.floor(secs % 3600 / 60))}:${pad(secs % 60)}`;
        if (this.clockSignature === text) return;
        this.clockSignature = text; this.clear(this.clockText);
        const height = 31, gap = 1.5;
        const widths = text.split("").map(char => {
            if (!/\d/.test(char)) return height * (char === ":" ? .36 : 1);
            const rect = this.countdownFrames[Number(char)].getRect(); return height * rect.width / rect.height;
        });
        const total = widths.reduce((sum, width) => sum + width, 0) + gap * (text.length - 1);
        let left = -total / 2;
        text.split("").forEach((char, index) => {
            const glyph = new cc.Node("Clock_" + index); this.clockText.addChild(glyph);
            glyph.setPosition(left + widths[index] / 2, 0); glyph.setContentSize(widths[index], height);
            if (/\d/.test(char)) {
                const sprite = glyph.addComponent(cc.Sprite); sprite.sizeMode = cc.Sprite.SizeMode.CUSTOM;
                sprite.spriteFrame = this.countdownFrames[Number(char)];
            } else {
                // Match the miner countdown: separators/units use text; all digits use artwork.
                const label = glyph.addComponent(cc.Label); label.string = char;
                label.fontSize = char === ":" ? height * 1.4 : height; label.lineHeight = height * 1.6;
                label.horizontalAlign = cc.Label.HorizontalAlign.CENTER; label.verticalAlign = cc.Label.VerticalAlign.CENTER;
                label.overflow = cc.Label.Overflow.NONE;
            }
            left += widths[index] + gap;
        });
        this.clockText.setContentSize(total, height); this.clockText.setScale(Math.min(1, 218 / total));
    }
    private details(reward: any, slot: cc.Node): void {
        this.clear(this.tip); this.tip.active = true;
        const columns = Math.min(4, reward.goods.length), rows = Math.ceil(reward.goods.length / columns);
        const width = columns * 120 + 34, height = rows * 128 + 18;
        const anchor = this.design.convertToNodeSpaceAR(slot.convertToWorldSpaceAR(cc.v2(0, 56)));
        const x = Math.max(-470 + width / 2, Math.min(470 - width / 2, anchor.x));
        this.tip.setPosition(x, anchor.y + height / 2 + 20);
        const bg = this.sprite(this.tip, "Box", "tooltip", 0, 0, width, height);
        const background = bg.getComponent(cc.Sprite), frame = background.spriteFrame;
        frame.insetLeft = frame.insetRight = frame.insetTop = frame.insetBottom = 28;
        background.type = cc.Sprite.Type.SLICED;
        this.sprite(this.tip, "Pointer", "pointer", anchor.x - x, -height / 2 - 7, 28, 20);
        bg.on(cc.Node.EventType.TOUCH_END, () => { this.tip.active = false; });
        reward.goods.forEach((g, i) => {
            const x = ((i % columns) - (columns - 1) / 2) * 120;
            const y = (rows - 1) * 64 - Math.floor(i / columns) * 128;
            this.sprite(this.tip, "Good", GOODS[g.id] || "chest-1", x, y + 15, 95, 95);
            if (g.id === 2005) this.duration(this.tip, g.count, x, y - 36, 100, 34, 62, 33, Math.abs(slot.scaleX));
            else this.quantity(this.tip, g, x, y - 36, 34, 105);
        });
        this.tip.setSiblingIndex(this.design.childrenCount - 1);
    }
    private async help(): Promise<void> {
        if (!this.isAlive()) return;
        const help = this.design.getChildByName("Help"), button = help && help.getComponent(cc.Button);
        if (button) button.interactable = false;
        try { await this.ensureProbabilityAssets(); }
        catch (error) { cc.warn("[Pyramid] 概率资源加载失败", error); return; }
        finally { if (this.isAlive() && cc.isValid(button, true) && cc.isValid(button.node, true)) button.interactable = true; }
        if (!this.isAlive()) return;
        const state = this.state(), level = state && state.levels.find(l => l.level === state.currentLevel);
        if (!level) return;
        this.tip.active = false; this.closeHelp();
        const modal = new cc.Node("ProbabilityModal"); this.design.addChild(modal); this.probabilityModal = modal;
        const size = cc.view.getVisibleSize(), shade = new cc.Node("Shade"); modal.addChild(shade);
        shade.setContentSize(size.width / this.design.scaleX, size.height / this.design.scaleY);
        const dim = shade.addComponent(cc.Graphics); dim.fillColor = new cc.Color(0, 0, 0, 190);
        dim.rect(-shade.width / 2, -shade.height / 2, shade.width, shade.height); dim.fill();
        shade.addComponent(cc.BlockInputEvents); shade.on(cc.Node.EventType.TOUCH_END, () => this.closeHelp());
        const box = this.sprite(modal, "ProbabilityBox", "probability/background", 0, 0, 902, 1378);
        const sprite = box.getComponent(cc.Sprite), frame = sprite.spriteFrame;
        frame.insetTop = 200; frame.insetBottom = 125; frame.insetLeft = frame.insetRight = 60;
        sprite.type = cc.Sprite.Type.SLICED; box.addComponent(cc.BlockInputEvents);
        this.sprite(box, "Title", "probability/title", 0, 557, 314, 86);
        const close = new cc.Node("CloseProbability"); box.addChild(close); close.setPosition(366, 558); close.setContentSize(100, 100);
        const closeIcon = new cc.Node("Icon"); close.addChild(closeIcon);
        const closeSprite = closeIcon.addComponent(cc.Sprite);
        closeSprite.sizeMode = cc.Sprite.SizeMode.TRIMMED; closeSprite.spriteFrame = this.probabilityCloseFrame;
        close.addComponent(cc.Button).transition = cc.Button.Transition.SCALE; close.on("click", () => this.closeHelp());
        const probabilities = remainingProbabilities(level.level, level.rewards);
        level.rewards.forEach((reward, i) => {
            const row = new cc.Node("Probability_" + reward.rewardId); box.addChild(row); row.setPosition(0, 375 - i * 164);
            const g = row.addComponent(cc.Graphics);
            g.fillColor = new cc.Color(255, 242, 192); g.roundRect(-394, -72, 788, 144, 34); g.fill();
            g.fillColor = new cc.Color(255, 250, 227); g.roundRect(-394, -72, 334, 144, 72); g.fill();
            g.rect(-260, -72, 200, 144); g.fill();
            g.strokeColor = new cc.Color(234, 202, 141); g.lineWidth = 6; g.roundRect(-394, -72, 788, 144, 68); g.stroke();
            g.strokeColor = cc.Color.WHITE; g.lineWidth = 2; g.roundRect(-389, -67, 778, 134, 65); g.stroke();
            const base = this.rewardIcon(reward, level);
            const chest = /^chest-[1-4]$/.test(base);
            const lowerTool = ["freeze", "hammer", "magic"].includes(base);
            this.sprite(row, "Prize", base || "chest-1", -216, chest || lowerTool ? 0 : 15, chest ? 122 : 104, 104);
            if (!chest && reward.goods.length === 1) {
                const good = reward.goods[0], infinite = good.id === 2005;
                if (infinite) this.duration(row, good.count, -216, -38, 180, 34, 62, 33);
                else this.quantity(row, good, -216, -38, 34, 180);
            }
            if (reward.gain && level.level < 6 || reward.deliveryStatus === "delivered") this.sprite(row, "Check", "check", 243, 0, 100, 82);
            else if (level.level === 6) this.sprite(row, "Free", "free", 180, 0, 178, 64);
            else {
                const value = new cc.Node("ProbabilityValue"); row.addChild(value); value.setPosition(180, 0);
                value.addComponent(PyramidDigits).set(probabilityText(probabilities[i], level.level), this.probabilityDigits, 44, 310, true);
            }
        });
        this.continueHint(modal, 0, -835);
    }
    private closeHelp(): void {
        if (this.probabilityModal) { this.probabilityModal.removeFromParent(); this.probabilityModal.destroy(); this.probabilityModal = null; }
    }
    private async action(): Promise<void> {
        if (Service.busy || this.animation || this.drawing) return;
        const state = this.state();
        if (state && !state.canDraw && state.currentLevel < 6 && !this.price["0"]) {
            try { if (!this.priceTask) await this.ensurePriceAssets(); }
            catch (error) { cc.warn("[Pyramid] 价格资源加载失败", error); }
            if (cc.isValid(this.node, true)) this.render();
            return;
        }
        this.tip.active = false;
        if (this.animationDebug()) await this.actionDebug();
        else await this.actionLive();
    }
    /** Temporary test flow; remove together with PyramidAnimationDebug before release. */
    private async actionDebug(): Promise<void> {
        const s = this.state(); if (!s || s.completed) return;
        this.drawing = true;
        try {
            if (s.canDraw) {
                const result = this.debugSession.draw(); if (!result) return;
                this.animation = this.animateResult(result, result.available); this.render(); await this.animation;
                if (cc.isValid(this.node, true)) await this.animateRewards(result.goods);
            } else if (s.canClaimFinal) {
                const goods = this.debugSession.claim(); this.render();
                await this.animateRewards(goods);
            }
        } finally { this.animation = null; this.drawing = false; if (cc.isValid(this.node, true)) this.render(); }
    }
    private async actionLive(): Promise<void> {
        const s = Service.data(); if (!s) { await Service.sync(); return; }
        if (s.pendingGrants.length) { await Service.deliver(); return; }
        if (s.canDraw) {
            const available = s.levels[s.currentLevel - 1].rewards.filter(r => !r.gain).map(r => r.rewardId);
            this.drawing = true;
            try {
                const ok = await Service.act("draw");
                if (ok && cc.isValid(this.node, true) && Service.lastDraw && Service.lastDraw.requestId !== this.renderedDraw) {
                    const goods = Service.lastDraw.goods;
                    this.renderedDraw = Service.lastDraw.requestId;
                    this.animation = this.animateResult(Service.lastDraw, available); this.render(); await this.animation;
                    if (cc.isValid(this.node, true) && await Service.deliver() && cc.isValid(this.node, true)) await this.animateRewards(goods);
                }
            } finally { this.animation = null; this.drawing = false; if (cc.isValid(this.node, true)) this.render(); }
        } else if (s.canClaimFinal) {
            const goods = s.levels.reduce((all, level) => all.concat(...level.rewards.filter(r => r.deliveryStatus !== "delivered").map(r => r.goods)), []);
            this.drawing = true;
            try {
                if (await Service.act("claim") && await Service.deliver() && cc.isValid(this.node, true)) await this.animateRewards(goods);
            } finally { this.drawing = false; if (cc.isValid(this.node, true)) this.render(); }
        }
        else if (s.canPay && !Service.error) await Service.buy();
        else { if (await Service.sync(true) && Service.data() && Service.data().pendingGrants.length) await Service.deliver(); }
    }
    async recoverDelivery(): Promise<void> {
        if (this.animationDebug()) return;
        if (this.ready && !this.animation && !this.drawing && !Service.busy && Service.data() && Service.data().pendingGrants.length) await Service.deliver();
    }
    private animateResult(result: any, available: string[]): Promise<void> {
        const row = this.rewardRow(result.previousLevel);
        // Row children follow the visual left-to-right slot order. The list is captured BEFORE the draw response.
        const slots = this.rewardSlots(row).filter(slot => available.includes((slot as any).pyramidRewardId));
        const target = slots.findIndex(slot => (slot as any).pyramidRewardId === result.rewardId);
        if (target < 0) return Promise.resolve();
        if (this.shimmer) { cc.Tween.stopAllByTarget(this.shimmer); this.shimmer.destroy(); }
        this.shimmer = this.sprite(row, "DrawSelection", "selection", 0, 0, 134, 127);
        this.shimmer.setSiblingIndex(row.getChildByName("CurrentLevelBackground") ? 1 : 0);
        const moveTo = (index: number) => {
            const slot = slots[index]; this.shimmer.setPosition(slot.x, slot.y + 4 * slot.scaleY);
            this.shimmer.setScale(slot.scaleX, slot.scaleY);
        };
        moveTo(0);
        return new Promise(resolve => {
            this.finishAnimation = resolve;
            let tween = cc.tween(this.shimmer);
            const steps = slots.length > 1 ? slots.length * 3 + target : 0;
            for (let step = 1; step <= steps; step++) {
                const delay = (0.055 + 0.245 * Math.pow(step / steps, 2)) / DRAW_ANIMATION_SPEED;
                tween = tween.delay(delay).call(() => moveTo(step % slots.length));
            }
            tween.delay(0.45 / DRAW_ANIMATION_SPEED).call(() => { this.finishAnimation = null; resolve(); }).start();
        });
    }
    /** Presentation only: tuning the reward reveal must never change the player's inventory. */
    private async animateRewards(goods: Array<{ id: number; count: number }>): Promise<void> {
        if (!this.isAlive() || !goods.length) return;
        const types = { 1001: "coin", 2001: "freeze", 2002: "hammer", 2003: "magic", 2005: "infinite_health" };
        const rewards: Array<{ type: string; count: number; spriteFrame: cc.SpriteFrame }> = [];
        goods.forEach(good => {
            const type = types[good.id], existing = rewards.find(r => r.type === type);
            if (existing) existing.count += good.count;
            else rewards.push({ type, count: good.count, spriteFrame: this.movingGoodsFrames[GOODS_IDS.indexOf(good.id)] });
        });
        const bundle = cc.assetManager.getBundle("publicUI") || await new Promise<cc.AssetManager.Bundle>((resolve, reject) => {
            cc.assetManager.loadBundle("publicUI", (error, loaded) => {
                if (!this.isAlive()) { resolve(null); return; }
                error ? reject(error) : resolve(loaded);
            });
        }).catch(error => { if (this.isAlive()) throw error; return null; });
        if (!this.isAlive()) return;
        const prefab = await new Promise<cc.Prefab>((resolve, reject) => {
            bundle.load("prefab/RewardWindow", cc.Prefab, (error, loaded: cc.Prefab) => {
                if (!this.isAlive()) { resolve(null); return; }
                error ? reject(error) : resolve(loaded);
            });
        }).catch(error => { if (this.isAlive()) throw error; return null; });
        if (!this.isAlive()) return;
        // Use the battle-pass reward prefab and its own reveal/click-to-close animation.
        const overlay = cc.instantiate(prefab); this.node.addChild(overlay); overlay.setPosition(0, 0);
        overlay.zIndex = 1001; this.rewardAnimation = overlay;
        const widget = overlay.getComponent(cc.Widget); if (widget) widget.updateAlignment();
        return new Promise(resolve => {
            this.finishAnimation = resolve;
            overlay.getComponent("Reward").init(rewards, () => {
                this.finishAnimation = null; this.rewardAnimation = null; resolve();
            }, true);
        });
    }
    private clear(node: cc.Node): void { node.children.slice().forEach(child => child.destroy()); node.removeAllChildren(); }
    update(dt: number): void {
        if (!this.ready) return;
        this.arrowTime += dt;
        const offset = Math.sin(this.arrowTime * Math.PI * 2 / 1.2) * 5;
        this.currentArrows.forEach(arrow => { if (cc.isValid(arrow, true)) arrow.y = 90 + offset; });
        if (this.summitGlow) this.summitGlow.angle = (this.summitGlow.angle - 60 * dt) % 360;
        if (this.claimPulseNode) {
            this.claimPulseTime = (this.claimPulseTime + dt) % 2;
            const t = this.claimPulseTime;
            const scale = t < .2 ? 1 - .1 * t / .2
                : t < .4 ? .9 + .2 * (t - .2) / .2
                : t < .6 ? 1.1 - .1 * (t - .4) / .2 : 1;
            this.claimPulseNode.setScale(scale);
        }
        this.clock += dt; if (this.clock >= 1) { this.clock = 0; this.renderClock(); }
    }
    onDestroy(): void {
        if (this.unsubscribe) this.unsubscribe();
        if (this.shimmer) cc.Tween.stopAllByTarget(this.shimmer);
        if (this.rewardAnimation) {
            cc.Tween.stopAllByTarget(this.rewardAnimation);
            this.rewardAnimation.children.forEach(child => cc.Tween.stopAllByTarget(child));
            this.rewardAnimation.destroy(); this.rewardAnimation = null;
        }
        if (this.finishAnimation) this.finishAnimation();
    }
}