import { sharedCards, sharedByName } from "./data.js";
import { cardDefinitions } from "../../card-definitions.js";
import { witherDamage } from "../../wither-card.js";
import { hasCardAffix } from "../../intrinsic-affixes.js";
import { createCardData } from "../../card-data.js";
import { cardUpgradeLevel, cardUpgradeRule, canUpgradeCard } from "../../upgrades.js";
import { generationPool } from "../../card-pools.js";
import { cardPackCosts } from "../data.js";
import { ironcladStrengthPenalty } from "../../ironclad-hooks.js";
import { installSharedHookResolver } from "../../shared-hooks.js";
import { isAttackCard } from "../../../monsters/vine-tangled.js";
import { applyMengsanDebuff, consumeArtifact } from "../../../monsters/artifact-status.js";
import { isStunned } from "../../../battle/stun-intent.js";
import { canPayCard, isActiveCardUse, authorizeFreeCardUse, takeXCardUse, cardCost } from "../../../battle/combat-rules.js";

const BRIDGE="mengsan_shared_bridge_shuying", RULES="mengsan_shared_rules_shuying", END="mengsan_shared_end_shuying", LIMIT="mengsan_shared_limit_shuying", AFTER="mengsan_shared_after_shuying";
const safe=n=>Number.isSafeInteger(n) && n>=0;
function belongs(event,root) {
    const seen=new Set();
    for(let e=event;e&&!seen.has(e);e=e.parent){if(e===root)return true;seen.add(e);}
    return false;
}
function nearestUse(event) {
    const seen=new Set();
    for(let e=event;e&&!seen.has(e);e=e.parent){if(e.name==="useCard")return e;seen.add(e);}
    return null;
}
const physical=card=>card?.cards?.length===1 && card.cards[0]?.name===card.name ? card.cards[0] : card;
const rule=card=>{const c=sharedByName[card?.name];return c ? cardUpgradeLevel(card) && c.upgraded ? c.upgraded : c.base : null;};

export function createSharedCardRuntime({game,get,lib,status,getBattle,battleEnergy,temporaryStrength,random}) {
    const states=new WeakMap(), uses=new WeakMap(), replays=new WeakMap(), costCaps=new WeakMap(), ballBonuses=new WeakMap();
    const seenUses=new WeakSet(), seenDraws=new WeakSet(), seenEnds=new WeakSet(), kills=new WeakMap();
    const tokenOf=player=>{
        const b=getBattle();
        return b?.session?.active && b.root && b.players?.has(player) && player?.isAlive?.()
            ? {battle:b,session:b.session,root:b.root,run:status.mengsanRun_shuying} : null;
    };
    const valid=(player,t)=>Boolean(t && getBattle()===t.battle && t.session.active &&
        t.battle.session===t.session && t.battle.root===t.root && t.battle.players.has(player) && player?.isAlive?.());
    const pileOf=s=>s.player===game.me ? s.token.battle.personalPiles : s.token.battle.monsterPiles?.get(s.player);
    const stateOf=player=>{const s=states.get(player);return s&&valid(player,s.token)?s:null;};
    const add=(o,k,n)=>{const next=(o[k]||0)+n;if(!safe(next))throw new RangeError("通用牌数值越界");o[k]=next;};
    const friends=s=>[...s.token.battle.players].filter(p=>valid(p,s.token) && (p===s.player || s.player.isFriendOf(p)));
    const enemies=s=>[...s.token.battle.players].filter(p=>valid(p,s.token) && p!==s.player && s.player.isEnemyOf(p));
    const refresh=s=>{if(valid(s.player,s.token)){s.token.battle.handUI?.refresh();s.token.battle.pilesUI?.refresh();}};
    function ensure(player) {
        const token=tokenOf(player);if(!token)return null;
        let s=stateOf(player);if(s)return s;
        s={player,token,powers:Object.create(null),turn:Object.create(null),freeTurn:new WeakSet(),freeBattle:new WeakSet(),
            nextTurn:[],bombs:[],negativeStrength:0,autoCount:0,drawCount:0,returns:[],maulBonus:0,vigor:0,queuedAllyEnergy:0};
        states.set(player,s);player.addSkill(RULES);
        token.session.ownResource(s,()=>{if(states.get(player)===s){states.delete(player);player.removeSkill(RULES);s.nextTurn.length=0;s.returns.length=0;}});
        return s;
    }
    const rand=(s,list)=>{
        if(!list.length)return null;
        const v=random(s.token.run);if(!Number.isFinite(v)||v<0||v>=1)throw new RangeError("通用牌随机数无效");
        return list[Math.floor(v*list.length)];
    };
    function sample(s,list,n) {
        const bag=list.slice(),out=[];
        while(bag.length && out.length<n){const item=rand(s,bag);out.push(item);bag.splice(bag.indexOf(item),1);}
        return out;
    }
    function pool(s,type=null,onlyColorless=false) {
        const ownDecks=Object.values(cardDefinitions).filter(c=>c.owner===s.token.run?.player?.character).map(c=>c.deck);
        const names=generationPool(cardDefinitions,onlyColorless?["colorless"]:[...new Set(ownDecks),"colorless"]);
        return names.filter(name=>(!type || cardDefinitions[name].cardType===type) && lib.card[name]);
    }
    function generated(s,name,upgrade=0) {
        const b=s.token.battle,n=(b.generatedCardSerial||0)+1;if(!safe(n))throw new RangeError("生成牌序号越界");b.generatedCardSerial=n;
        return createCardData({id:`mengsan_generated_${s.token.session.id}_${n}`,name,suit:"spade",number:1,nature:null,affixes:[],
            upgrade:Math.min(upgrade,cardUpgradeRule(name)?.maxLevel||0)},{enemy:true});
    }
    async function generateHand(s,name,{upgrade=0,free=false}={}) {
        if(!valid(s.player,s.token)||!name)return null;
        const c=await pileOf(s)?.addToHand(generated(s,name,upgrade));
        if(c && valid(s.player,s.token) && free)s.freeTurn.add(c);
        refresh(s);return c;
    }
    async function choose(s,list,prompt,{max=1,optional=false}={}) {
        if(!valid(s.player,s.token)||!list.length)return [];
        const count=Math.min(max,list.length);
        const answer=await s.player.chooseButton({createDialog:[prompt,list],forced:!optional,selectButton:optional?[0,count]:[1,count],
            ai:button=>typeof button.link==="string" ? 1 : get.value(button.link,s.player)}).forResult();
        if(!valid(s.player,s.token))return [];
        return [...new Set(answer.links||[])].filter(c=>list.includes(c)).slice(0,count);
    }
    async function chooseGenerated(s,{type=null,upgrade=0}={}) {
        const names=sample(s,pool(s,type),3);
        // Native virtual-card buttons preserve Chinese title and the registered card image.
        const buttons=names.map(name=>["", "", name]);
        if(!buttons.length)return;
        const result=await s.player.chooseButton({createDialog:["选择一张牌加入手牌",[buttons,"vcard"]],forced:true,selectButton:1,
            ai:button=>get.value({name:button.link[2]},s.player)}).forResult();
        if(!valid(s.player,s.token))return;
        const name=result.links?.[0]?.[2];if(names.includes(name))await generateHand(s,name,{upgrade,free:true});
    }
    function strength(s,player,n) {
        if(!valid(player,s.token)||!safe(n))return;
        const next=(player.storage.mengsanStrength_shuying||0)+n;if(!safe(next))throw new RangeError("力量数值越界");
        player.storage.mengsanStrength_shuying=next;player.addSkill("mengsan_raider_strength_shuying");player.markSkill("mengsan_raider_strength_shuying");
    }
    async function hit(s,target,n,card=null,attack=false) {
        if(!safe(n))throw new RangeError("通用牌伤害无效");
        if(!n||!valid(s.player,s.token)||!valid(target,s.token)||!s.player.isEnemyOf(target))return 0;
        const e=target.damage(n,s.player);if(card)e.card=card;if(attack)e.mengsanAttack_shuying=true;
        const gold=rule(card)?.killGold;if(gold)kills.set(e,{s,target,gold,claimed:false});
        // Fisticuffs' detail page explicitly includes damage absorbed by the target's block.
        await e;return e._cancelled?0:Math.max(0,e.num||0);
    }
    async function hitAll(s,n) {for(const t of enemies(s)){if(!valid(s.player,s.token))break;await hit(s,t,n);}}
    function origin(event) {const use=nearestUse(event);return use?.mengsanSharedOriginal_shuying || use?.mengsanIcRepeatOriginal_shuying || use?.cards?.find(c=>c.name===use.card?.name) || physical(event.card);}
    function ballBonus(s,card) {
        const c=physical(card),entry=ballBonuses.get(c),data=c?.storage?.mengsanCard_shuying||c;
        return entry?.session===s.token.session ? entry.amount : data?.ballSession===s.token.session.id&&safe(data.ballBonus) ? data.ballBonus : 0;
    }
    function snapshot(use) {
        const original=origin(use),data=original?.storage?.mengsanCard_shuying || {};
        return {original,card:{name:use.card.name,suit:use.card.suit,number:use.card.number,nature:use.card.nature},
            data:{...data,name:use.card.name,upgrade:cardUpgradeLevel(use.card),affixes:[...(data.affixes||[])]},targets:[...(use.targets||[])]};
    }
    async function autoPlay(s,card,{echo=null,targets=null}={}) {
        if(!valid(s.player,s.token))return false;
        if(++s.autoCount>1024)throw new Error("通用牌自动结算超过安全上限");
        const pile=pileOf(s),info=lib.card[card?.name];
        const movable=!echo && (pile?.drawCards().includes(card)||pile?.discardCards().includes(card));
        const skip=()=>{if(movable&&pile.beginAutoPlay(card))pile.finishAutoPlay(card);return false;};
        if(!info || info.enable===false || hasCardAffix(card,"unplayable"))return skip();
        let selected=info.notarget?[]:targets?.filter(t=>valid(t,s.token) &&
            (typeof info.filterTarget!=="function" || info.filterTarget(card,s.player,t)));
        if(!selected){
            const candidates=[...s.token.battle.players].filter(t=>valid(t,s.token) &&
                (typeof info.filterTarget!=="function" || info.filterTarget(card,s.player,t)));
            selected=info.toself?[s.player]:info.selectTarget===-1?candidates:[rand(s,candidates)].filter(Boolean);
        }
        if(!selected.length&&!info.notarget)return skip();
        if(movable&&!pile.beginAutoPlay(card))return false;
        let release=()=>{};
        try {
            const played=echo?{...echo.card,storage:{mengsanCard_shuying:{...echo.data,affixes:echo.data.affixes.slice()}}}:card;
            const use=s.player.useCard({card:played,cards:echo?[]:[card],targets:selected,addCount:false});
            use.mengsanSharedAuto_shuying=true;use.addCount=false;
            if(echo){use.mengsanSharedEcho_shuying=true;use.mengsanSharedOriginal_shuying=echo.original;}
            release=authorizeFreeCardUse(s.player,use.card,use,()=>valid(s.player,s.token));
            use.oncard=()=>{if(!valid(s.player,s.token)||!lib.filter.cardEnabled(use.card,s.player)||selected.some(t=>!s.player.canUse(use.card,t,false)))use.cancel();};
            await use;return !use._cancelled;
        } finally {release();if(movable)pile.finishAutoPlay(card);}
    }
    function debitGold(s,n) {
        if(s.player!==game.me || !safe(s.token.run?.player?.gold))return;
        s.token.run.player.gold=Math.max(0,s.token.run.player.gold-n);
    }
    async function afterDraw(s,cards) {
        if(!valid(s.player,s.token))return;
        for(const c of cards||[])if(sharedByName[c.name]?.id==="void"){
            s.player.storage.mengsanEnergy_shuying=Math.max(0,(s.player.storage.mengsanEnergy_shuying||0)-1);
        }
        if(s.powers.automation){
            const n=s.drawCount+(cards?.length||0),gained=Math.floor(n/10);s.drawCount=n%10;
            if(gained)battleEnergy.grant(s.player,gained*s.powers.automation,s.token.battle);
        }
        refresh(s);
    }
    function cost(s,card,amount) {
        const c=physical(card),cap=costCaps.get(c);
        if(cap?.session===s.token.session && (cap.permanent || cap.turn===s.turn))amount=Math.min(amount,1);
        if(cardDefinitions[card?.name]?.cardType==="power")amount=Math.max(0,amount-(s.powers.powerDiscount||0));
        return amount;
    }
    function cardBlock(s,n,event) {
        if(!(n>0))return n;
        // Stop at an explicit skill boundary so powers/relics cannot borrow an outer card's source.
        const seen=new Set();
        for(let e=event;e&&!seen.has(e);e=e.parent){
            seen.add(e);if(e.skill || lib.skill[e.name])return n;
            if(e.name==="useCard" && e.player===s.player){
                if(s.powers.noCardBlock>0)return 0;
                const title=lib.translate[e.card?.name]||"";
                return n+(s.powers.dexterity||0)+(title.includes("防御")?(s.powers.defendBonus||0):0);
            }
        }
        return n;
    }
    installSharedHookResolver(player=>{
        const s=ensure(player);if(!s)return null;
        return {isFree:card=>s.freeTurn.has(physical(card))||s.freeBattle.has(physical(card)),cost:(card,n)=>cost(s,card,n),
            strengthPenalty:()=>s.negativeStrength,blockAmount:(n,e)=>cardBlock(s,n,e),afterDraw:cards=>afterDraw(s,cards),
            snapshotCard:card=>sharedByName[card.name]?.id==="the_ball"?{ballBonus:ballBonus(s,card),ballSession:s.token.session.id}:{},
            copyCard(source,target){
                if(sharedByName[source.name]?.id==="the_ball"&&target.name===source.name)ballBonuses.set(target,{session:s.token.session,amount:ballBonus(s,source)});
                if(s.freeBattle.has(source))s.freeBattle.add(target);
                const cap=costCaps.get(source);if(cap?.session===s.token.session&&cap.permanent)costCaps.set(target,{...cap});
            }};
    });

    async function play(spec,event,player) {
        const s=ensure(player);if(!s || !belongs(event,s.token.root))return;
        const r=rule(event.card),id=spec.id,target=event.target,pile=pileOf(s),original=origin(event);
        if(!r)return;
        if(r.damage!==undefined || ["mind_blast","gold_axe","volley"].includes(id)){
            let amount=r.damage||0;
            if(id==="mind_blast")amount=pile?.drawCards().length||0;
            if(id==="gold_axe")amount=s.token.battle.sharedCardUses||0;
            if(id==="gang_up")amount+=r.perAllyAttack*(s.token.battle.sharedAttackRecords||[]).filter(x=>x.turn===status.currentPhase&&x.source!==player&&player.isFriendOf(x.source)&&x.targets.includes(target)).length;
            if(id==="rend"){
                const bad=["mengsanVulnerable_shuying","mengsanWeak_shuying","mengsanFrail_shuying","mengsanTangled_shuying","mengsanShrink_shuying","mengsanConstrict_shuying"];
                let kinds=bad.filter(k=>target?.storage?.[k]>0).length+(ironcladStrengthPenalty(target)>0?1:0)+(isStunned(target)?1:0);
                if(s.token.battle.sharedKnockdowns?.some(mark=>mark.target===target&&valid(mark.owner,s.token)))kinds++;
                if([...s.token.battle.players].some(p=>stateOf(p)?.turn.choking?.has(target)))kinds++;
                amount+=r.perDebuff*kinds;
            }
            if(id==="maul")amount+=s.maulBonus;
            if(id==="the_ball")amount+=ballBonus(s,original);
            let count=r.hits||1;if(id==="volley")count=takeXCardUse(player,event,s.token.battle)??0;
            let actual=0;
            for(let i=0;i<count && valid(player,s.token);i++){
                const selected=id==="volley"?[rand(s,enemies(s))].filter(Boolean):r.all?enemies(s):[target];
                for(const t of selected){actual+=await hit(s,t,amount,event.card,true);if(!valid(player,s.token))return;}
            }
            // Detail page: the equal splash directly deals non-attack damage; no strength/weak/vulnerable reapplication.
            if(id==="omnislice")for(const t of enemies(s).filter(t=>t!==target))await hit(s,t,actual);
            if(id==="fisticuffs"&&actual>0&&valid(player,s.token))await player.changeHujia(actual);
            if(id==="maul")add(s,"maulBonus",r.maulGrowth);
            if(id==="the_ball"&&valid(player,s.token)){
                const next=ballBonus(s,original)+r.ballGrowth;if(!safe(next))throw new RangeError("魔球伤害数值越界");
                ballBonuses.set(original,{session:s.token.session,amount:next});
                const use=nearestUse(event),entry=uses.get(use);
                if(entry&&!use.mengsanSharedEcho_shuying&&!use.mengsanIcEcho_shuying)entry.ballHandoff=true;
            }
        }
        if(!valid(player,s.token))return;
        if(r.block)await player.changeHujia(r.block);
        if(!valid(player,s.token))return;
        if(r.energy)battleEnergy.grant(player,r.energy,s.token.battle);
        if(r.draw)await player.draw(r.draw);
        if(!valid(player,s.token))return;
        for(const t of r.all?enemies(s):[target])if(valid(t,s.token)){
            if(r.weak)applyMengsanDebuff(t,"weak",r.weak,player);
            if(r.vulnerable)applyMengsanDebuff(t,"vulnerable",r.vulnerable,player);
        }
        if(r.strength)strength(s,player,r.strength);
        if(r.dexterity)add(s.powers,"dexterity",r.dexterity);
        if(r.temporaryStrength)temporaryStrength.grant(player,r.temporaryStrength,event,s.token.battle);
        if(r.negativeStrength && valid(target,s.token) && !consumeArtifact(target))add(ensure(target),"negativeStrength",r.negativeStrength);
        if(r.allyBlock && valid(target,s.token))await target.changeHujia(r.allyBlock);
        if(r.allyEnergy && valid(target,s.token)){
            // Each actor restores energy on its own turn; keep an off-turn gift until that restoration finishes.
            if(status.currentPhase===target)battleEnergy.grant(target,r.allyEnergy,s.token.battle);
            else add(ensure(target),"queuedAllyEnergy",r.allyEnergy);
        }
        if(r.teamStrength)for(const p of friends(s).filter(p=>p!==player))temporaryStrength.grant(p,r.teamStrength,event,s.token.battle,{ownTurn:true});
        if(r.teamDraw)for(const p of friends(s)){if(!valid(player,s.token))return;await p.draw(r.teamDraw);}
        if(r.teamBlock)for(const p of friends(s)){if(!valid(player,s.token))return;await p.changeHujia(r.teamBlock);}
        if(id==="impatience" && !player.getCards("h").some(isAttackCard))await player.draw(r.conditionalDraw);
        if(id==="restlessness" && !player.getCards("h").length){await player.draw(r.emptyDraw);if(valid(player,s.token))battleEnergy.grant(player,r.emptyEnergy,s.token.battle);}
        if(r.chooseExhaust){
            const selected=await choose(s,player.getCards("h"),"净化：选择要消耗的手牌",{max:r.chooseExhaust,optional:true});
            for(const c of selected){if(!valid(player,s.token))return;await pile?.exhaustFromHand(c);}
        }
        if(id==="thinking_ahead"){
            const [c]=await choose(s,player.getCards("h"),"深谋远虑：将一张手牌放回堆顶");
            if(c)await pile?.moveHandToTop(c);
        }
        if(id==="seeker_strike" || ["secret_technique","secret_weapon","wish"].includes(id)){
            let list=pile?.drawCards()||[];
            if(id==="seeker_strike")list=sample(s,list,3);
            if(id==="secret_technique")list=list.filter(c=>cardDefinitions[c.name]?.cardType==="skill");
            if(id==="secret_weapon")list=list.filter(isAttackCard);
            const [c]=await choose(s,list,"选择抽牌堆中的一张牌加入手牌");if(c)await pile?.gainFromDraw(c);
        }
        if(r.chooseDiscard){
            const selected=await choose(s,pile?.discardCards()||[],"涅奥之怒：取回至多指定数量的牌",{max:r.chooseDiscard,optional:true});
            for(const c of selected){if(!valid(player,s.token))return;await pile?.gainToHand(c);}
        }
        if(id==="anointed")for(const c of pile?.drawCards().filter(c=>cardDefinitions[c.name]?.rarity==="rare")||[]){if(!valid(player,s.token))return;await pile.gainFromDraw(c);}
        if(id==="scrawl"){
            const limit=player.getHandcardLimit(),count=Math.max(0,limit-player.countCards("h"));
            if(safe(count)&&count)await player.draw(count);
        }
        if(id==="mimic"&&valid(target,s.token)&&target.hujia>0)await player.changeHujia(target.hujia);
        if(r.generate)for(let i=0;i<r.generate&&valid(player,s.token);i++)await generateHand(s,rand(s,pool(s,null,true)));
        if(id==="discovery")await chooseGenerated(s);
        if(id==="abundance")await chooseGenerated(s,{type:"power",upgrade:r.generatedUpgrade||0});
        if(id==="mad_science-chaos")await generateHand(s,rand(s,pool(s)),{free:true});
        if(r.generateZero){
            const names=pool(s).filter(name=>{
                // Jackpot+ upgrades the result, but its pool still requires a zero-cost base card.
                return cardPackCosts[name]===0;
            });
            for(let i=0;i<r.generateZero&&valid(player,s.token);i++)await generateHand(s,rand(s,names),{upgrade:r.generatedUpgrade||0});
        }
        if(r.generateDrawAttacks)for(let i=0;i<r.generateDrawAttacks&&valid(player,s.token);i++){
            const name=rand(s,pool(s,"attack"));if(!name)break;
            const c=pile?.addToDraw(generated(s,name),Math.floor(random(s.token.run)*((pile?.drawCards().length||0)+1)));
            if(c)s.freeBattle.add(c);
        }
        if(r.autoDraw)for(let i=0;i<r.autoDraw&&valid(player,s.token);i++){const c=rand(s,pile?.drawCards()||[]);if(!c)break;await autoPlay(s,c);}
        if(r.autoDiscard)for(const c of sample(s,(pile?.discardCards()||[]).filter(isAttackCard),r.autoDiscard)){if(!valid(player,s.token))return;await autoPlay(s,c);}
        if(r.replay){const c=rand(s,(pile?.drawCards()||[]).filter(c=>!replays.has(c)));if(c)replays.set(c,{session:s.token.session,count:r.replay});}
        if(id==="thrumming_hatchet"||id==="bolas")s.returns.push(original);
        if(id==="prolong")s.nextTurn.push({block:Math.max(0,player.hujia||0)});
        if(r.futureBlock)s.nextTurn.push({block:r.futureBlock,remaining:r.futureTurns});
        if(r.nextDraw||r.nextEnergy)s.nextTurn.push({draw:r.nextDraw,energy:r.nextEnergy});
        if(id==="panic_button"&&!consumeArtifact(player))s.powers.noCardBlock=2;
        if(id==="equilibrium"||id==="salvo")s.turn.retain=true;
        if(r.bombDamage)s.bombs.push({turns:3,damage:r.bombDamage});
        if(r.intangible)add(s.powers,"intangible",r.intangible);
        if(id==="the_gambit")s.powers.gambit=true;
        if(id==="enlightenment")for(const c of player.getCards("h"))costCaps.set(c,{session:s.token.session,permanent:cardUpgradeLevel(event.card)>0,turn:s.turn});
        if(id==="brightest_flame"){
            // The detail page applies full-health HP loss before reducing the maximum.
            if(player.hp===player.maxHp)await player.loseHp(1);
            if(!valid(player,s.token))return;
            await player.loseMaxHp(1);
            if(player===game.me && safe(player.maxHp))s.token.run.player.maxHp=player.maxHp;
        }
        if(id==="apotheosis"){
            for(const c of pile?.battleCards(event.cards||[])||[]){
                const d=c.storage?.mengsanCard_shuying;if(d&&canUpgradeCard(d))d.upgrade=(d.upgrade||0)+1;
            }
            // Exhausted cards keep real nodes; refresh their serialized viewer data after upgrading them.
            pile?.syncExhaustSnapshots();
        }
        if(id==="deprecated_card"&&player===game.me){const cid=original?.storage?.mengsanCard_shuying?.id;s.token.run.player.deck=s.token.run.player.deck.filter(c=>c.id!==cid);}
        if(id==="whistle"&&valid(target,s.token))game.mengsanStunEnemy_shuying(target);
        if(id==="tag_team"&&valid(target,s.token)){s.token.battle.sharedTags||=[];s.token.battle.sharedTags.push({owner:player,target});}
        if(r.allyDamageMultiplier&&valid(target,s.token)&&!consumeArtifact(target)){s.token.battle.sharedKnockdowns||=[];s.token.battle.sharedKnockdowns.push({owner:player,target,multiplier:r.allyDamageMultiplier});}
        if(id==="intercept"&&valid(target,s.token))s.turn.intercept=target;
        if(r.choking&&valid(target,s.token)&&!consumeArtifact(target)){s.turn.choking||=new Map();s.turn.choking.set(target,(s.turn.choking.get(target)||0)+r.choking);}
        if(spec.cardType==="power"){
            for(const k of ["panache","defendBonus","turnVigor","automation","powerDiscount","plating"])if(r[k])add(s.powers,k,r[k]);
            if(r.boulder)add(s.powers,"boulder",r.boulder);
            for(const k of ["nostalgia","entropy","beacon_of_hope","mayhem","calamity"])if(id===k)add(s.powers,k,1);
            if(r.battleUpgrade && player===game.me){const run=s.token.run;run.sharedBattleCardEffects||={upgrades:0};add(run.sharedBattleCardEffects,"upgrades",r.battleUpgrade);}
        }
        refresh(s);
    }

    async function onUse(use) {
        const s=ensure(use.player);if(!s || seenUses.has(use))return;seenUses.add(use);
        const b=s.token.battle,entry={s,snapshot:snapshot(use),vigor:0,echoes:[]};uses.set(use,entry);
        b.sharedPendingUses||=new Set();b.sharedPendingUses.add(use);
        // Death can omit useCardAfter/Cancelled while the native use event still
        // drains its after queue. Release only this use's entry after that unwind;
        // onUseAfter is idempotent and ignores effects owned by a dead player.
        use.insertAfter(async () => {
            await onUseAfter(use);
        }, { forceDie: true });
        if(game.me.isFriendOf(s.player))b.sharedCardUses=(b.sharedCardUses||0)+1;
        if(isAttackCard(use.card)){
            b.sharedAttackRecords||=[];entry.attackRecord={turn:status.currentPhase,source:s.player,targets:(use.targets||[]).filter(t=>valid(t,s.token)&&s.player.isEnemyOf(t))};b.sharedAttackRecords.push(entry.attackRecord);
            entry.vigor=s.vigor;s.vigor=0;
            if(s.powers.calamity)for(let i=0;i<s.powers.calamity && valid(s.player,s.token);i++)await generateHand(s,rand(s,pool(s,"attack")));
        }
        if(isActiveCardUse(use,s.player))add(s.turn,"plays",1);
        if(s.powers.panache){
            add(s.turn,"panachePlays",1);
            if(s.turn.panachePlays%5===0)await hitAll(s,s.powers.panache);
        }
        if(s.turn.choking)for(const [target,n] of s.turn.choking){if(valid(s.player,s.token)&&valid(target,s.token))await target.loseHp(n);}
        if(!use.mengsanSharedEcho_shuying){
            const replay=replays.get(entry.snapshot.original);
            if(replay?.session===s.token.session)for(let i=0;i<replay.count;i++)entry.echoes.push(entry.snapshot.targets);
            if(isAttackCard(use.card)){
                const consumed=[];
                for(const tag of b.sharedTags||[])if(tag.owner!==s.player && s.player.isFriendOf(tag.owner) && valid(tag.target,s.token)){
                    entry.echoes.push([tag.target]);consumed.push(tag);
                }
                b.sharedTags=(b.sharedTags||[]).filter(t=>!consumed.includes(t));
            }
        }
        if(s.powers.nostalgia && (s.turn.nostalgia||0)<s.powers.nostalgia && !use.mengsanSharedEcho_shuying &&
            ["attack","skill"].includes(cardDefinitions[use.card?.name]?.cardType)){
            add(s.turn,"nostalgia",1);entry.returnTop=true;
        }
    }
    async function onUseAfter(use) {
        const entry=uses.get(use);if(!entry)return;
        uses.delete(use);const {s}=entry,b=s.token.battle;
        try {
            if(valid(s.player,s.token) && !use._cancelled){
                for(const targets of entry.echoes){if(!valid(s.player,s.token))break;await autoPlay(s,entry.snapshot.original,{echo:entry.snapshot,targets});}
                if(entry.returnTop && valid(s.player,s.token))pileOf(s)?.moveDiscardToTop(entry.snapshot.original);
                if(entry.ballHandoff && valid(s.player,s.token)){
                    const card=entry.snapshot.original,source=pileOf(s),recipients=friends(s).filter(p=>p!==s.player).map(ensure)
                        .filter(other=>pileOf(other)?.canReceiveTransfer(card,s.token.session));
                    const recipient=rand(s,recipients);
                    if(recipient){
                        const turnFree=s.freeTurn.has(card),battleFree=s.freeBattle.has(card);
                        if(await source?.transferTo(card,pileOf(recipient))){
                            if(turnFree)recipient.freeTurn.add(card);if(battleFree)recipient.freeBattle.add(card);
                            refresh(recipient);
                        }
                    }
                }
            }
        } finally {
            b.sharedPendingUses?.delete(use);
            if(getBattle()===b && b.session.active && !b.sharedPendingUses?.size){
                if(b.sharedDeferredVictory && game.me?.isAlive()){b.sharedDeferredVictory=false;game.mengsanFinishBattle_shuying();}
                else game.checkResult();
            }
        }
    }
    async function turnStart(player) {
        const s=ensure(player);if(!s)return;
        s.turn=Object.create(null);s.freeTurn=new WeakSet();s.autoCount=0;
        if(s.queuedAllyEnergy){battleEnergy.grant(player,s.queuedAllyEnergy,s.token.battle);s.queuedAllyEnergy=0;}
        if(s.powers.plating)s.powers.plating=Math.max(0,s.powers.plating-1);
        if(s.powers.intangible)s.powers.intangible=Math.max(0,s.powers.intangible-1);
        add(s,"vigor",s.powers.turnVigor||0);
        s.token.battle.sharedKnockdowns=(s.token.battle.sharedKnockdowns||[]).filter(e=>e.owner!==player);
        const next=s.nextTurn.splice(0);
        for(const e of next){
            if(!valid(player,s.token))return;
            if(e.block)await player.changeHujia(e.block);
            if(!valid(player,s.token))return;
            if(e.draw)await player.draw(e.draw);
            if(!valid(player,s.token))return;
            if(e.energy)battleEnergy.grant(player,e.energy,s.token.battle);
            if(e.remaining>1)s.nextTurn.push({...e,remaining:e.remaining-1});
        }
        for(const c of s.returns.splice(0)){if(!valid(player,s.token))return;await pileOf(s)?.returnToHand(c);}
        if(s.powers.boulder){
            if(!valid(player,s.token))return;
            await hitAll(s,s.powers.boulder);add(s.powers,"boulder",5);
        }
        if(s.powers.entropy && pileOf(s))for(let i=0;i<s.powers.entropy && valid(player,s.token);i++){
            const [c]=await choose(s,player.getCards("h").filter(c=>!hasCardAffix(c,"eternal")),"熵：选择变化一张手牌");
            if(c && player.getCards("h").includes(c)){
                const name=rand(s,pool(s).filter(name=>name!==c.name));
                if(name)pileOf(s).transformHand(c,generated(s,name));
            }
        }
        refresh(s);
    }
    async function afterDrawPhase(player) {
        const s=stateOf(player);if(!s?.powers.mayhem)return;
        for(let i=0;i<s.powers.mayhem&&valid(player,s.token);i++){
            const c=pileOf(s)?.drawTop();if(!c)break;await autoPlay(s,c);
        }
    }
    async function handEnd(phase) {
        if(seenEnds.has(phase))return;seenEnds.add(phase);
        const s=ensure(phase.player);if(!s)return;
        // Snapshot before ethereal removal and ordinary discards; resolve each held copy separately.
        const hand=s.player.getCards("h").slice(),count=hand.length;
        for(const c of hand){
            if(!valid(s.player,s.token))return;
            if(!s.player.getCards("h").includes(c))continue;
            const spec=sharedByName[c.name],r=rule(c);if(!spec||!r||spec.id==="infection")continue;
            const damage=spec.id==="wither"?witherDamage(c):r.endDamage;
            if(damage){const e=s.player.damage(damage,"nosource");e.mengsanSharedHandDamage_shuying=true;await e;}
            if(!valid(s.player,s.token))return;
            if(r.endLoseHp)await s.player.loseHp(r.endLoseHp);
            if(!valid(s.player,s.token))return;
            if(spec.id==="regret"&&count)await s.player.loseHp(count);
            if(!valid(s.player,s.token))return;
            if(spec.id==="debt")debitGold(s,10);
            if(spec.id==="shame"){s.pendingDebuffs||={};add(s.pendingDebuffs,"frail",1);}
            if(spec.id==="doubt"){s.pendingDebuffs||={};add(s.pendingDebuffs,"weak",1);}
        }
        for(const c of hand){if(!valid(s.player,s.token))return;if(rule(c)?.ethereal)await pileOf(s)?.exhaustFromHand(c);}
        refresh(s);
    }
    async function turnEnd(player) {
        const s=stateOf(player);if(!s)return;
        if(s.powers.plating)await player.changeHujia(s.powers.plating);
        for(const bomb of s.bombs.slice()){
            if(!valid(player,s.token))return;
            bomb.turns--;if(bomb.turns<=0){s.bombs.splice(s.bombs.indexOf(bomb),1);await hitAll(s,bomb.damage);}
        }
    }
    function clearTurn(player) {
        const b=getBattle();if(!b?.session.active)return;
        for(const p of b.players){const s=stateOf(p);if(!s)continue;if(p===player)s.negativeStrength=0;s.turn.choking=null;s.freeTurn=new WeakSet();}
        const s=stateOf(player);if(s?.powers.noCardBlock)s.powers.noCardBlock--;
        b.sharedAttackRecords=[];
    }
    function limited(player,card,event) {
        const s=ensure(player);if(!s || !isActiveCardUse(event,player))return false;
        const use=nearestUse(event);if(use?.mengsanSharedEcho_shuying||use?.mengsanIcEcho_shuying)return false;
        const held=player.getCards("h"),id=sharedByName[card?.name]?.id;
        if(id!=="enthralled"&&held.some(c=>sharedByName[c.name]?.id==="enthralled"))return true;
        return held.some(c=>sharedByName[c.name]?.id==="normality") && (s.turn.plays||0)>=3;
    }
    const cards={},translate={};
    for(const spec of sharedCards){
        const ally=["believe_in_you","lift","mimic","intercept"].includes(spec.id);
        const enemy=spec.cardType==="attack"&&!spec.base.all&&spec.id!=="volley" || spec.id==="dark_shackles";
        cards[spec.name]={type:spec.cardType==="status"?"status":"basic",fullimage:true,
            mengsanShared_shuying:true,
            image:`ext:术樱包/mengsan/assets/cards/${spec.name}.png`,usable:Infinity,
            mengsanCost_shuying:spec.cost,mengsanXCost_shuying:spec.cost==="X",
            mengsanInnate_shuying:card=>Boolean(rule(card)?.innate),mengsanExhaust_shuying:card=>Boolean(rule(card)?.exhaust),
            mengsanPower_shuying:spec.cardType==="power",selectTarget:enemy||ally?1:-1,toself:!enemy&&!ally,
            enable:spec.base.unplayable ? false : function(card,player,event){return Boolean(tokenOf(player)&&!hasCardAffix(card,"unplayable")&&!limited(player,card,event||status.event)&&
                (!isActiveCardUse(event||status.event,player)||canPayCard(player,card)));},
            filterTarget(card,player,target){return Boolean(target?.isAlive?.() && (enemy?target!==player&&player.isEnemyOf(target):ally?target!==player&&player.isFriendOf(target):target===player));},
            content:async(event,trigger,player)=>play(spec,event,player),
            cardPrompt(card){const r=rule(card||{name:spec.name});let description=r?.description||spec.description;
                if(spec.id==="the_ball"){const s=stateOf(game.me);if(s)description=description.replace("造成10点伤害",`造成${10+ballBonus(s,card)}点伤害`);}
                if(spec.id==="wither")description=description.replace("受到3点伤害",`受到${witherDamage(card)}点伤害`);
                return `梦三：${spec.cost==null?"不能被打出":`${spec.cost==="X"?"X":cardCost(card||{name:spec.name})}费`}。${description}`;},
            ai:{order:spec.cardType==="power"?7:6,value:spec.cardType==="curse"?0:5,useful:spec.cardType==="curse"?0:5,
                result:{target:enemy?-1:1},tag:spec.cardType==="attack"?{damage:1}:{}},
        };
        translate[spec.name]=spec.title;translate[`${spec.name}_info`]=cards[spec.name].cardPrompt({name:spec.name});
    }
    const skills={
        [RULES]:{charlotte:true,popup:false,
            mod:{
                cardEnabled(card,player){if(limited(player,card,status.event))return false;},
                cardEnabled2(card,player){if(limited(player,card,status.event))return false;},
                ignoredHandcard(card,player){if(stateOf(player)?.turn.retain)return true;},
            },
        },
        [END]:{trigger:{global:"phaseAfter"},forced:true,silent:true,popup:false,priority:-300,
            filter(event){return Boolean(stateOf(event.player)?.pendingDebuffs);},
            async content(event,trigger){const s=stateOf(trigger.player);if(!s)return;const pending=s.pendingDebuffs;delete s.pendingDebuffs;
                for(const kind of ["frail","weak"])if(pending[kind])applyMengsanDebuff(s.player,kind,pending[kind]);refresh(s);},
        },
        [LIMIT]:{trigger:{global:"useCard0"},forced:true,silent:true,popup:false,firstDo:true,priority:12000,
            filter(event){const b=getBattle();return Boolean(b?.session.active && belongs(event,b.root) && limited(event.player,event.card,event));},
            async content(event,trigger){trigger.cancel();},
        },
        [AFTER]:{trigger:{global:["useCardAfter","useCardCancelled"]},forced:true,silent:true,popup:false,priority:-500,
            filter(event){return uses.has(event);},async content(event,trigger){await onUseAfter(trigger);},
        },
        [BRIDGE]:{group:[END,LIMIT,AFTER],trigger:{global:["useCard1","phaseBefore","phaseDrawAfter","phaseDiscardBegin","phaseJieshuBegin","phaseAfter","drawAfter","damageBegin1","damageBegin2","damageBegin4","loseHpBegin","damage","changeHujiaAfter"]},
            forced:true,silent:true,popup:false,priority:300,
            filter(event){const b=getBattle();return Boolean(b?.session.active&&belongs(event,b.root));},
            async content(event,trigger){
                const name=event.triggername,b=getBattle();if(!b?.session.active)return;
                if(name==="useCard0"){if(limited(trigger.player,trigger.card,trigger))trigger.cancel();return;}
                if(name==="useCard1"){await onUse(trigger);return;}
                if(name==="phaseBefore"){await turnStart(trigger.player);return;}
                if(name==="phaseDrawAfter"){await afterDrawPhase(trigger.player);return;}
                if(name==="phaseDiscardBegin"){await handEnd(trigger);return;}
                if(name==="phaseJieshuBegin"){await turnEnd(trigger.player);return;}
                if(name==="phaseAfter"){clearTurn(trigger.player);return;}
                if(name==="drawAfter"){
                    if(!trigger.mengsanIcDrawHandled_shuying&&!seenDraws.has(trigger)){seenDraws.add(trigger);const s=ensure(trigger.player);if(s)await afterDraw(s,trigger.result?.cards||trigger.cards||[]);}return;
                }
                if(name==="damageBegin1"){
                    const use=nearestUse(trigger),entry=uses.get(use);
                    if(entry?.attackRecord && entry.s.player===trigger.source && valid(trigger.player,entry.s.token) && trigger.source.isEnemyOf(trigger.player) &&
                        !entry.attackRecord.targets.includes(trigger.player))entry.attackRecord.targets.push(trigger.player);
                    if(entry && entry.s.player===trigger.source && (trigger.mengsanAttack_shuying||isAttackCard(trigger.card)))trigger.num+=entry.vigor;
                    if(trigger.source)for(const mark of b.sharedKnockdowns||[])if(mark.target===trigger.player&&valid(mark.owner,entry?.s.token||tokenOf(mark.owner))&&mark.owner!==trigger.source&&mark.owner.isFriendOf(trigger.source))trigger.num*=mark.multiplier;
                    return;
                }
                if(name==="damageBegin4"||name==="loseHpBegin"){
                    const s=stateOf(trigger.player);if(s?.powers.intangible&&trigger.num>1)trigger.num=1;return;
                }
                if(name==="damageBegin2" && (trigger.mengsanAttack_shuying||isAttackCard(trigger.card))){
                    // Wiki's interception is attack damage suppression + doubled holder damage, not native retargeting.
                    let multiplier=1;
                    for(const p of b.players){const s=stateOf(p);if(!s?.turn.intercept || !valid(p,s.token) || !p.isEnemyOf(trigger.source))continue;
                        if(trigger.player===s.turn.intercept)multiplier=0;
                        if(trigger.player===p)multiplier*=2;
                    }
                    trigger.num=Math.floor(trigger.num*multiplier);return;
                }
                if(name==="damage"){
                    const s=stateOf(trigger.player);
                    // This native signal is after block/HP change and before ordinary dying rescue.
                    // Clear before forcing death so immunity cannot cause a second kill after rescue.
                    if(s?.powers.gambit && trigger.num>(trigger.hujia||0) && (trigger.mengsanAttack_shuying||isAttackCard(trigger.card))){s.powers.gambit=false;await trigger.player.die(trigger.source);}return;
                }
                if(name==="changeHujiaAfter"){
                    const s=stateOf(trigger.player);
                    if(s?.powers.beacon_of_hope && status.currentPhase===s.player && trigger.num>0 && !trigger.mengsanSharedBeacon_shuying){
                        const n=Math.floor(trigger.num/2)*s.powers.beacon_of_hope;
                        if(n)for(const p of friends(s).filter(p=>p!==s.player)){if(!valid(s.player,s.token))return;const e=p.changeHujia(n);e.mengsanSharedBeacon_shuying=true;await e;}
                    }return;
                }
            },
        },
    };
    return {cards,translate,skills,names:sharedCards.map(c=>c.name),
        async onDeath(event){
            const seen=new Set();for(let e=event;e&&!seen.has(e);e=e.parent){
                seen.add(e);const entry=kills.get(e);if(!entry||entry.claimed||entry.target!==event.player)continue;
                entry.claimed=true;const {s,gold}=entry;
                if(valid(s.player,s.token)&&s.player===game.me&&entry.target.isDead()){
                    const run=s.token.run;add(run.player,"gold",gold);add(run.statistics,"goldEarned",gold);
                }break;
            }
        },
    };
}