// server/sim/content/kits/ops/op-demetr.js — 贝洛内 (char_4037_demetr) 自选 operator kit: 6★ 斗士 (近卫), an owned-6★ pick of
// the tier-5 and tier-6 自选 slots; every skill, both talents, the trait, his module at every form and his summon 牵绊.
// Kit contract and the 自选 rules: ../README.md ("How to add an operator (自选)").
//
// Forms (data/backups.json units.char_4037_demetr, the DIY slot statuses): normal = E2 Lv1, skills at rank 4, no module;
// elite = E2 Lv60, rank 7, FGT-Y (his only module) at stage 1 (tier 5) or 3 (tier 6) or none. Full potential (the owner's
// decision of 2026-10-07). Sources: character_table / skill_table / battle_equip_table (zh_CN, as built into backups.json; the 牵绊 token
// record backups.json tokens.token_10065_demetr_dmtpos); PRTS 贝洛内 (家族手段 备注 "防御减少效果于贝洛内每次普通攻击时，计算伤害前
// 施加（可影响当次攻击）…防御减少方式为最终乘算…多个贝洛内之间的【手段】间仅防御减少量最高者生效…每0.1秒自然更新一次；当具有≥6层层数
// 的【手段】自然更新/响应更新时，若该【手段】的来源（贝洛内）不处于2技能状态或已离场，层数将强制变回5层…增伤效果为线性提升，可对任何来自
// 贝洛内的伤害（不止普通攻击）生效"; 街头直觉 备注 "部署时立刻获得80%物理/法术闪避，之后每秒衰减2%（至多衰减20次），最终变为40%";
// 家主的余裕 备注 "可触发两次第一天赋"; 军师的手段 备注; 清算 备注 — the 牵绊 rules, "每次移动的目标地块必须为合法、可部署、未部署有
// 牵绊/贝洛内自己以外单位的地面地块", "在受到致命伤害结算后立即结束技能，因返回而部署时获得短暂的不死", "若技能开启时，若存在目标则会立刻
// 尝试移动；否则会尝试原地移动一次", "技能结束时，若不位于初始位置且场上不存在牵绊，贝洛内将被强制撤退"); PRTS 牵绊 备注 (无敌, 孤立,
// 晕眩 / 冻结 / 寒冷 / 沉睡 免疫); PRTS 卫戍协议/帮助 特殊策略 (【清算】 "在自定义范围内存在敌人时释放技能", x-2); gamedata_const
// ba.addash 移动 "不退场，以当前血量在目标位置部署"; the client's battle data — charpack char_4037_demetr (every attack ability
// carries demetr_t1[def_dec]; S2 mode `demetr_s2[mark]`; S3 modes), skchr_demetr_3 (FlyToTarget / FlyToTargetSecond: the
// x-2 selector around his located tile, buildable melee low-ground tiles empty but for him and his token; RespawnEnd), buff
// _template_data `demetr_t1[def_dec]` / `[def_dec_core]` / `[dmg_inc]`, `demetr_t2[evade]`, `demetr_s3[bonus]` / `[target_timer]`
// / `[timer]` / `[elite_finish_listener]` / `[undeadable]` / `[restore]`; his skeleton (Skill_3_Back 0.5 s).
// - Trait (斗士) "能够阻挡一个敌人": the profession default (block 1, melee, ground only). Module FGT-Y “实用的工具” "生命值高于
//   50%时攻击速度+10" (trait bb attack_speed / hp_ratio): ASPD while HP > hp_ratio.
// - T1 家族手段 (bb attack@def / attack@limited_stack_cnt / attack@s2_limited_stack_cnt / attack@def_dec_duration,
//   min/max_hp_ratio, min/max_add_on_scale): each of his attack hits puts 【手段】 on its target before the damage (it counts
//   for that hit): one stack more (at most limited_stack_cnt, s2_limited_stack_cnt while S2 runs), DEF ×(1 − |def| × stacks)
//   (FINAL_SCALER), def_dec_duration s from the last hit; at s2_limited_stack_cnt stacks the target is 停顿 (sluggish) for as
//   long as it keeps them; every 0.1 s a 【手段】 above limited_stack_cnt whose 贝洛内 is not in S2 (or not on the field) drops
//   back to limited_stack_cnt, keeping its time. One 【手段】 per enemy: several 贝洛内 (a shared field) share its stacks and
//   the higher per-stack value [ASSUMED: the client keeps one per source and only the highest reduction acts]. And every
//   damage of his ×(1 + add-on), the add-on linear from min_add_on_scale at min_hp_ratio of the target's HP to
//   max_add_on_scale at max_hp_ratio and below (DamageScaleAccordingToHpRatio, the target's HP before the hit). FGT-Y stage 3:
//   8 % per stack, +50 % at most.
// - T2 街头直觉 (bb init_prob / dec_prob / trig_cnt): from every deployment — a 【移动】 is one (demetr_s3_t[born_sync]) —
//   physical and arts dodge init_prob, −dec_prob each second trig_cnt times (80 % → 40 %), then stays.
// - S1 家主的余裕 (AUTO, attack SP 4; data DEFAULT): the next attack strikes its target twice for atk_scale × ATK physical
//   (`_additionalTimes` 1 — both strikes land in the attack [ASSUMED: the skeleton's 0.2 s between them is not modelled]);
//   each strike adds a 【手段】 stack.
// - S2 军师的手段 (MANUAL, 15 / 18 s; data ACTIVE_RANGE on its 3-13): range 3-13, ASPD +attack_speed, every attack strikes
//   attack@max_target targets for attack@atk_scale × ATK physical; 【手段】 up to s2_limited_stack_cnt and 停顿 at the cap. Its
//   attack is a projectile in the client (projectile_chr_demetr_s2): the hits land at the attack [ASSUMED: flight not
//   modelled]; ground targets only, as every attack of his (selector targetMotion 1).
// - S3 清算 (MANUAL, 30 s; data CUSTOM_RANGE on x-2): ATK +atk, ASPD +attack_speed, each damage instance attack@…prob to be
//   ×prob_atk_scale (AtkScaleUp: on the attack's ATK, before DEF). At the cast he 【移动】s (Battle.moveRedeploy: no exit, HP
//   / buffs / the skill kept, deploy effects again — 街头直觉's 80 %) onto the tile of the first ground enemy of the x-2 around
//   his located tile (his tile at the cast) whose tile he may take — a melee-buildable low-ground tile of the field, nobody
//   on it but his 牵绊 or himself, no knocked-out operator, no other piece's reserved tile — in the usual target order
//   (sortEnemyTargets); without one he moves in place once. He takes another target the same way when the elite / leader
//   enemy he attacked last (within attack@finish_listener_duration s) is knocked out, and whenever 1 s (interval × time_stack)
//   passed without him dealing damage — retried every interval while no target exists, never while he cannot act. Leaving his
//   located tile he leaves 牵绊 there (when none of his is up); moving back onto it retreats 牵绊 first. A lethal hit while it
//   runs does not knock him out: 不死, untargetable, blocking nothing, 禁疗 (demetr_s3[undeadable]) and the skill ends on the
//   next tick. At the end he returns — a 【移动】 onto his located tile (in place when he is there) that empties his SP — and
//   gets a short 不死 (RETURN_UNDYING); not on that tile and no 牵绊 of his up (or the tile taken) ⇒ forced retreat ('retreat').
//   The client's wind-up / landing clips (Skill_3_ReStart_Begin 0.2 s, _End 0.3 s) are not modelled: each move is instant
//   [ASSUMED].
// - 牵绊 (token_10065_demetr_dmtpos, S3 only — its variant bySkill 2): "贝洛内技能结束时返回该位置，并且其他干员不能部署" — it holds
//   his located tile; 无敌, untargetable, 孤立, no attack, blocks nothing (blockCnt 0) — PRTS 牵绊 备注.
// Melee, ground-only (data canHitFly false: no anti-air); ground enemies target him normally (no 起飞 / 迷彩 / 隐匿).

import { num, talentBb, traitBb, skillRec, up, onHitBy, toggleBuff, once } from '../shared/tier1.js';
import { isElite } from '../shared/tier6.js';
import { absoluteRangeKeys, sortEnemyTargets } from '../../../targeting.js';

const S1 = 'skchr_demetr_1';
const S2 = 'skchr_demetr_2';
const S3 = 'skchr_demetr_3';
export const BOND = 'token_10065_demetr_dmtpos';
/** S3's search area when the data carries none (x-2: the 5 × 5 square around him without its corners). */
const X2 = Object.freeze([[2, -1], [2, 0], [2, 1], [1, -2], [1, -1], [1, 0], [1, 1], [1, 2], [0, -2], [0, -1], [0, 0], [0, 1],
  [0, 2], [-1, -2], [-1, -1], [-1, 0], [-1, 1], [-1, 2], [-2, -1], [-2, 0], [-2, 1]]);
/** "因返回而部署时获得短暂的不死" (PRTS 备注; no number): his return clip, Skill_3_Back 0.5 s [ASSUMED]. */
export const RETURN_UNDYING = 0.5;
/** 【手段】 on an enemy (one per enemy) and its 停顿 at the S2 cap; the 【手段】 refresh tick (PRTS 备注 "每0.1秒自然更新一次"). */
export const MEANS_KEY = 'talent:demetr:means';
export const MEANS_SLUG_KEY = 'talent:demetr:means:sluggish';
const MEANS_TICK = 0.1;
export const STREET_KEY = 'talent:demetr:street';
export const UNDEAD_KEY = 'skill:demetr:undeadable';

const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
const s2On = (u) => !!(u && u.skill && u.skill.active && u.skill.id === S2);
const s3On = (u) => !!(u && u.skill && u.skill.active && u.skill.id === S3);

/** 牵绊's kit (a fresh one per summon): no attack, 无敌 and 孤立 (spawnToken adds untargetable). */
export function bondKit() {
  return {
    skill: null,
    trait: { noAttack: true },
    install(battle, tok) {
      battle.addBuff(tok, { key: 'token:demetr:bond', flags: { invulnerable: true, isolated: true }, persist: true, allowDead: true });
    },
  };
}

/** Put / refresh 【手段】 on `e` (the stack rule of demetr_t1[def_dec]) and its 停顿 at the S2 cap. */
function applyMeans(battle, unit, e, p) {
  const cur = e.findBuff(MEANS_KEY);
  const old = cur?.data?.stacks ?? 0;
  const cap = s2On(unit) ? p.cap8 : p.cap5;
  const stacks = old < cap ? old + 1 : old;
  const other = cur && cur.data?.src !== unit && up(cur.data?.src) ? num(cur.data?.pct) : 0;
  const pct = Math.max(p.pct, other);
  setMeans(battle, e, unit, { stacks, pct, cap5: p.cap5, cap8: p.cap8 }, p.dur);
}
function setMeans(battle, e, src, data, dur) {
  battle.addBuff(e, { key: MEANS_KEY, duration: dur, refresh: 'replace', source: src, mods: { defMul: Math.max(0, 1 - data.pct * data.stacks) }, data: { ...data, src }, tags: ['talent'] });
  if (data.stacks >= data.cap8) battle.addBuff(e, { key: MEANS_SLUG_KEY, duration: dur, refresh: 'replace', source: src, status: 'sluggish', mods: { moveMul: 0.2 }, visible: true, tags: ['talent'] });
  else battle.removeBuff(e, MEANS_SLUG_KEY);
}
/** The 0.1 s update of every 【手段】 (battle-wide, once): above the normal cap without its 贝洛内 in S2 ⇒ back to it. */
function installMeansTick(battle) {
  once(battle, 'demetr:means', () => battle.every(MEANS_TICK, () => {
    for (const e of battle.enemies) {
      if (!e.alive) continue;
      const b = e.findBuff(MEANS_KEY);
      const d = b?.data;
      if (!d || !(d.stacks > d.cap5)) continue;
      if (d.src && d.src.alive && d.src.deployed && s2On(d.src)) continue;
      setMeans(battle, e, d.src, { stacks: d.cap5, pct: d.pct, cap5: d.cap5, cap8: d.cap8 }, b.timeLeft);
    }
  }));
}

export default {
  char_4037_demetr: (bb, chess) => {
    const tb = traitBb(chess);       // FGT-Y: attack_speed / hp_ratio
    const t0 = talentBb(chess, 0);   // 家族手段 (FGT-Y stage 3: def −0.08, max_add_on_scale 0.5)
    const t1 = talentBb(chess, 1);   // 街头直觉
    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
    const s2 = skillRec(chess, S2), s3 = skillRec(chess, S3);
    const area = s3?.trigger?.customRangeGrid ?? X2;
    const means = {
      pct: Math.abs(num(t0['attack@def'])), cap5: Math.max(1, Math.floor(num(t0['attack@limited_stack_cnt'], 5))),
      cap8: Math.max(1, Math.floor(num(t0['attack@s2_limited_stack_cnt'], 8))), dur: num(t0['attack@def_dec_duration'], 10),
    };
    const hpHi = num(t0.min_hp_ratio, 1), hpLo = num(t0.max_hp_ratio, 0.2);
    const addLo = num(t0.min_add_on_scale), addHi = num(t0.max_add_on_scale);
    const iv = num(b3['attack@demetr_s3[target_timer].interval'], 0.5);
    const idle = iv * Math.max(1, num(b3['attack@demetr_s3[target_timer].time_stack'], 2));
    const listen = num(b3['attack@finish_listener_duration'], 3);
    const prob = num(b3['attack@demetr_s3[bonus].prob']), probScale = num(b3['attack@demetr_s3[bonus].prob_atk_scale'], 1);

    /** A tile he may 【移动】 onto (FlyToTarget selector options, PRTS 备注). */
    const tileOk = (battle, unit, st, r, c) => {
      if (!battle.grid.inRect(r, c) || !battle.grid.canStand(r, c) || !battle.grid.isLow(r, c) || battle.downOn(r, c)) return false;
      if (r === unit.tileR && c === unit.tileC) return true;
      const occ = battle.unitAt(r, c);
      if (occ) return occ === st.bond;
      return !battle.isReservedTile(r, c);
    };
    /** The first ground enemy of the x-2 around his located tile standing on a tile he may take. */
    const pickTarget = (battle, unit, st) => {
      const keys = absoluteRangeKeys(area, st.home[0], st.home[1], unit.dir, 0);
      const list = battle.enemiesInKeys(keys, unit, { canHitFly: false, groundOnly: true })
        .filter((e) => !e.isFlying && tileOk(battle, unit, st, Math.round(e.y), Math.round(e.x)));
      sortEnemyTargets(battle, unit, list, unit.profile?.priority ?? null);
      return list[0] ?? null;
    };
    const retreatBond = (battle, st) => {
      if (st.bond && st.bond.alive) battle.retreat(st.bond, { reason: 'expired', permanent: true });
      st.bond = null;
    };
    /** One 【移动】 of S3 onto (r, c): 牵绊 retreated first when it is his located tile, left there when he leaves it. */
    const moveTo = (battle, unit, st, r, c) => {
      const [hr, hc] = st.home;
      const home = r === hr && c === hc;
      if (home && (unit.tileR !== hr || unit.tileC !== hc)) retreatBond(battle, st);
      const fromX = unit.x, fromY = unit.y;
      if (!battle.moveRedeploy(unit, r, c)) return false;
      battle.fx('teleport', { x: unit.x, y: unit.y, id: unit.id, fromX, fromY });
      if (!home && !(st.bond && st.bond.alive)) st.bond = battle.spawnToken(unit, BOND, hr, hc, { untargetable: true, kit: bondKit() });
      return true;
    };
    /** FlyToTarget(Second): move onto the next target's tile; false without one (or when he cannot act). */
    const flyTo = (battle, unit, st) => {
      if (!up(unit) || !unit.canAct || st.undead) return false;
      const t = pickTarget(battle, unit, st);
      if (!t || !moveTo(battle, unit, st, Math.round(t.y), Math.round(t.x))) return false;
      st.next = battle.time + idle;
      return true;
    };

    return {
      skills: {
        [S1]: { kind: 'instant', attack: { atkScale: num(b1.atk_scale, 1), hits: 2 } },
        [S2]: {
          kind: 'duration',
          mods: { aspd: num(b2.attack_speed) },
          targeting: { ...(s2?.rangeGrid?.length ? { rangeGrid: s2.rangeGrid } : {}), maxTargets: Math.max(1, num(b2['attack@max_target'], 3)) },
          attack: { atkScale: num(b2['attack@atk_scale'], 1) },
        },
        [S3]: {
          kind: 'duration',
          mods: { atkPct: num(b3['attack@demetr_s3[bonus].atk']), aspd: num(b3['attack@demetr_s3[bonus].attack_speed']) },
          onStart({ battle, unit, skill }) {
            const st = { home: [unit.tileR, unit.tileC], bond: null, next: battle.time + idle, act: skill.activations, lastHit: null, lastHitAt: -Infinity, retarget: false, undead: false };
            unit.mem.demetrS3 = st;
            // "若技能开启时，若存在目标则会立刻尝试移动；否则会尝试原地移动一次"
            if (!flyTo(battle, unit, st) && up(unit)) moveTo(battle, unit, st, unit.tileR, unit.tileC);
          },
          onTick({ battle, unit }) {
            const st = unit.mem.demetrS3;
            if (!st) return;
            // the elite / leader he attacked last fell: FlyToTargetSecond at once (one try; the idle timer runs on)
            if (st.retarget) {
              st.retarget = false;
              if (flyTo(battle, unit, st)) return;
            }
            if (battle.time + 1e-9 < st.next) return;
            // no target (or he cannot act): the timer keeps counting — the next try at its next interval
            if (!flyTo(battle, unit, st)) while (st.next <= battle.time + 1e-9) st.next += iv;
          },
          onEnd({ battle, unit }) {
            const st = unit.mem.demetrS3;
            unit.mem.demetrS3 = null;
            if (!st) return;
            battle.removeBuff(unit, UNDEAD_KEY);
            if (!unit.alive || !unit.deployed) { retreatBond(battle, st); return; }
            const [hr, hc] = st.home;
            const atHome = unit.tileR === hr && unit.tileC === hc;
            const bondUp = !!(st.bond && st.bond.alive);
            retreatBond(battle, st);
            const fromX = unit.x, fromY = unit.y;
            // 【返回】: a 【移动】 onto the located tile (in place when he stands on it) that empties the SP (demetr_s3[restore])
            if ((atHome || bondUp) && battle.moveRedeploy(unit, hr, hc, { clearSp: true })) {
              if (!atHome) battle.fx('teleport', { x: unit.x, y: unit.y, id: unit.id, fromX, fromY });
              unit.mem.demetrGraceUntil = battle.time + RETURN_UNDYING;
              return;
            }
            battle.retreat(unit, { reason: 'retreat' });   // "贝洛内将被强制撤退"
          },
        },
      },
      talents: [
        { install(battle, unit) { // 家族手段
          installMeansTick(battle);
          battle.on('hit', (c) => {
            if (c.source !== unit || !c.dmg?.isAttack || !c.target || c.target.side !== 'enemy' || !c.target.alive) return;
            if (means.pct > 0) applyMeans(battle, unit, c.target, means);
          }, { owner: unit, priority: 10 });
          if (addHi || addLo) {
            onHitBy(battle, unit, (c) => {
              const r = c.target.hpRatio;
              const t = hpHi > hpLo ? Math.min(1, Math.max(0, (hpHi - r) / (hpHi - hpLo))) : (r <= hpLo ? 1 : 0);
              c.dmg.mul *= 1 + addLo + (addHi - addLo) * t;
            });
          }
        } },
        { install(battle, unit) { // 街头直觉
          const init = num(t1.init_prob), dec = num(t1.dec_prob), cnt = Math.max(0, Math.floor(num(t1.trig_cnt)));
          if (!(init > 0)) return;
          const set = (p) => battle.addBuff(unit, { key: STREET_KEY, mods: { dodgePhys: p, dodgeArts: p }, data: { p }, tags: ['talent'] });
          battle.on('deploy', (ctx) => {
            if (ctx.unit !== unit) return;
            const seq = unit.deploySeq;
            let p = init, n = 0;
            set(p);
            if (!(dec > 0) || !cnt) return;
            battle.every(1, (b, sc) => {
              if (!unit.alive || unit.deploySeq !== seq) { sc.cancel(); return; }
              p = Math.abs(p - dec);
              set(p);
              if (++n >= cnt) sc.cancel();
            }, { owner: unit });
          }, { owner: unit });
        } },
      ],
      install(battle, unit) {
        // FGT-Y: 生命值高于50%时攻击速度+10
        const aspd = num(tb.attack_speed);
        if (aspd) toggleBuff(battle, unit, 'trait:demetr:aspd', () => unit.hpRatio > num(tb.hp_ratio, 0.5), { aspd });
        // S3 清算: ×prob_atk_scale at prob per damage instance (AtkScaleUp: the attack's ATK, before DEF)
        if (prob > 0 && probScale !== 1) {
          onHitBy(battle, unit, (c) => {
            if (s3On(unit) && battle.rng.chance(prob)) c.dmg.amount *= probScale;
          });
        }
        // S3: the target he attacked last (an elite / leader one re-targets him when it falls within `listen` s)
        battle.on('hit', (c) => {
          const st = unit.mem.demetrS3;
          if (!st || c.source !== unit || !c.dmg?.isAttack || !c.target || c.target.side !== 'enemy') return;
          st.lastHit = c.target;
          st.lastHitAt = battle.time;
        }, { owner: unit });
        // S3: 1 s without output damage re-targets him (the timer restarts with each damage instance he deals)
        battle.on('damaged', (c) => {
          const st = unit.mem.demetrS3;
          if (st && c.source === unit && c.target && c.target.side === 'enemy') st.next = battle.time + idle;
        }, { owner: unit });
        battle.on('death', (c) => {
          const st = unit.mem.demetrS3;
          if (!st || c.reason !== 'killed' || c.unit !== st.lastHit || !isElite(c.unit) || battle.time - st.lastHitAt > listen + 1e-9) return;
          st.lastHit = null;
          st.retarget = true;   // taken in his next skill tick (the enemy index of that tick sees every enemy)
        }, { owner: unit });
        // S3: 受到致命伤害时不撤退但会结束技能 (demetr_s3[undeadable]); the return's short 不死
        battle.on('fatal', (c) => {
          if (c.unit !== unit || c.prevented) return;
          const st = unit.mem.demetrS3;
          if (st && s3On(unit)) {
            c.prevented = true;
            if (st.undead) return;
            st.undead = true;
            battle.addBuff(unit, { key: UNDEAD_KEY, flags: { untargetable: true, noBlock: true, healFree: true }, tags: ['skill'], visible: true });
            battle.fx('undying', { x: unit.x, y: unit.y, id: unit.id });
            const act = st.act;
            battle.after(0, () => { if (unit.mem.demetrS3 === st && s3On(unit) && unit.skill.activations === act) unit.skill.end('fatal'); }, { owner: unit });
            return;
          }
          if (battle.time < (unit.mem.demetrGraceUntil ?? -Infinity) - 1e-9) c.prevented = true;
        }, { owner: unit, priority: -50 });
      },
    };
  },
};