import { Component } from '@babylonjsmarket/ecs'

export interface TwinStickEnemyInput {
  speed?: number
  spawnerId?: string
  /** Points awarded to the player on kill. */
  pointsOnKill?: number
  /** XZ distance below which this enemy pushes against another. */
  separationRadius?: number
  /** XZ distance below which this enemy damages the player on contact. */
  contactRange?: number
  /** Damage dealt per contact event. HealthSystem's i-frames pace the rate. */
  contactDamage?: number
  /** Tag of the entity to chase + damage on contact. */
  targetTag?: string
  /** Arena half-extents to clamp the enemy inside (0 = unbounded). */
  arenaHalfWidth?: number
  arenaHalfDepth?: number
  /**
   * Optional animation clip names. When `walkClip` is set, TwinStickEnemySystem drives a
   * SkeletonAnimator on the same entity: it loops `walkClip` while chasing,
   * switches to `attackClip` within contact range, and on death plays one of
   * `deathClips` (chosen at random) once, re-parking only after it completes.
   * Empty = no animation (the classic sphere enemy).
   */
  walkClip?: string
  attackClip?: string
  /** Death clips; one is chosen at random per death. Empty = no death animation. */
  deathClips?: string[]
  /**
   * Directional death clips. When the killing shot's direction is known, the
   * clip is chosen by where it hit relative to the robot's facing instead of at
   * random: a hit to the FRONT (robot facing the shooter) plays a `fallBackClips`
   * entry, a hit to the BACK (facing away) plays a `fallForwardClips` entry.
   * Leave both empty to keep the random `deathClips` behaviour.
   */
  fallBackClips?: string[]
  fallForwardClips?: string[]
  /** Multiplier on contactRange for the attack→walk exit threshold (anti-flicker). */
  attackRangeHysteresis?: number
  /** Seconds to fade the model out after its death clip finishes, before recycling. */
  deathFadeSeconds?: number
  /**
   * On death (animated enemies only), the corpse is blown back along the
   * killing shot at this initial speed (units/sec) and barrels into the swarm.
   * 0 = no knockback (die in place).
   */
  knockbackSpeed?: number
  /** Per-second exponential decay of the knockback slide (higher = stops sooner). */
  knockbackDamping?: number
  /**
   * Relative mass of a corpse while it's sliding from knockback. Heavier than a
   * living enemy (weight 1) so separation shoves the living aside rather than
   * deflecting the corpse off them — that's the "knock into other robots" feel.
   */
  knockbackMass?: number
  /** Move speed while wandering (no line of sight). Usually slower than `speed`. */
  wanderSpeed?: number
  /** Seconds between picking a new wander heading. */
  wanderInterval?: number
}

export class TwinStickEnemyComponent extends Component {
  speed: number
  spawnerId: string
  pointsOnKill: number
  separationRadius: number
  contactRange: number
  contactDamage: number
  targetTag: string
  arenaHalfWidth: number
  arenaHalfDepth: number
  walkClip: string
  attackClip: string
  deathClips: string[]
  fallBackClips: string[]
  fallForwardClips: string[]
  attackRangeHysteresis: number
  deathFadeSeconds: number
  knockbackSpeed: number
  knockbackDamping: number
  knockbackMass: number
  wanderSpeed: number
  wanderInterval: number

  constructor(data: TwinStickEnemyInput = {}) {
    super()
    this.speed = data.speed ?? 2.5
    this.spawnerId = data.spawnerId ?? ''
    this.pointsOnKill = data.pointsOnKill ?? 100
    this.separationRadius = data.separationRadius ?? 1.0
    this.contactRange = data.contactRange ?? 1.1
    this.contactDamage = data.contactDamage ?? 1
    this.targetTag = data.targetTag ?? 'player'
    this.arenaHalfWidth = data.arenaHalfWidth ?? 0
    this.arenaHalfDepth = data.arenaHalfDepth ?? 0
    this.walkClip = data.walkClip ?? ''
    this.attackClip = data.attackClip ?? ''
    this.deathClips = data.deathClips ? [...data.deathClips] : []
    this.fallBackClips = data.fallBackClips ? [...data.fallBackClips] : []
    this.fallForwardClips = data.fallForwardClips ? [...data.fallForwardClips] : []
    this.attackRangeHysteresis = data.attackRangeHysteresis ?? 1.15
    this.deathFadeSeconds = data.deathFadeSeconds ?? 0.6
    this.knockbackSpeed = data.knockbackSpeed ?? 12
    this.knockbackDamping = data.knockbackDamping ?? 6
    this.knockbackMass = data.knockbackMass ?? 5
    this.wanderSpeed = data.wanderSpeed ?? 1.8
    this.wanderInterval = data.wanderInterval ?? 2.0
  }

  serialize(): TwinStickEnemyInput {
    return {
      speed: this.speed,
      spawnerId: this.spawnerId,
      pointsOnKill: this.pointsOnKill,
      separationRadius: this.separationRadius,
      contactRange: this.contactRange,
      contactDamage: this.contactDamage,
      targetTag: this.targetTag,
      arenaHalfWidth: this.arenaHalfWidth,
      arenaHalfDepth: this.arenaHalfDepth,
      walkClip: this.walkClip,
      attackClip: this.attackClip,
      deathClips: [...this.deathClips],
      fallBackClips: [...this.fallBackClips],
      fallForwardClips: [...this.fallForwardClips],
      attackRangeHysteresis: this.attackRangeHysteresis,
      deathFadeSeconds: this.deathFadeSeconds,
      knockbackSpeed: this.knockbackSpeed,
      knockbackDamping: this.knockbackDamping,
      knockbackMass: this.knockbackMass,
      wanderSpeed: this.wanderSpeed,
      wanderInterval: this.wanderInterval,
    }
  }
}

export const EnemyEvents = {
  KILLED: 'enemy.killed',
} as const

export function decideLocomotion(
  distance: number,
  contactRange: number,
  current: 'walk' | 'attack',
  hysteresis: number,
): 'walk' | 'attack' {
  if (distance <= contactRange) return 'attack'
  if (distance > contactRange * hysteresis) return 'walk'
  return current
}

export function allDeathClips(
  deathClips: ReadonlyArray<string>,
  fallBackClips: ReadonlyArray<string>,
  fallForwardClips: ReadonlyArray<string>,
): string[] {
  if (fallBackClips.length === 0 && fallForwardClips.length === 0) return [...deathClips]
  return Array.from(new Set([...deathClips, ...fallBackClips, ...fallForwardClips]))
}

export function chooseDeathClip(
  deathClips: ReadonlyArray<string>,
  fallBackClips: ReadonlyArray<string>,
  fallForwardClips: ReadonlyArray<string>,
  dot: number | null,
  rand: number,
): string | undefined {
  if (dot !== null) {
    const directional = dot < 0 ? fallBackClips : fallForwardClips
    if (directional.length > 0) return directional[Math.floor(rand * directional.length)]
  }
  const pool =
    deathClips.length > 0 ? deathClips : Array.from(new Set([...fallBackClips, ...fallForwardClips]))
  return pool.length > 0 ? pool[Math.floor(rand * pool.length)] : undefined
}

export function wanderHeading(
  awayX: number,
  awayZ: number,
  jitter: number,
  randomAngle: number,
): [number, number] {
  const mag = Math.hypot(awayX, awayZ)
  const angle = mag < 1e-4 ? randomAngle : Math.atan2(awayZ, awayX) + jitter
  return [Math.cos(angle), Math.sin(angle)]
}

import { BulletEvents, HealthEvents, HealthInputEvents, LineOfSightEvents, PoolInputEvents, ScoreInputEvents, SkeletonAnimatorEvents, SkeletonAnimatorInputEvents } from '@babylonjsmarket/arcade';
import { System } from '@babylonjsmarket/ecs'
import type { Entity } from '@babylonjsmarket/ecs'
import { MeshPrimitiveComponent } from '../MeshPrimitive/MeshPrimitive'
import { collectObstacleBoxes, resolveCircleVsBox } from '../Obstacle/Obstacle'
import {
  TwinStickEnemyComponent,
  EnemyEvents,
  decideLocomotion,
  wanderHeading,
  allDeathClips,
  chooseDeathClip,
} from './TwinStickEnemy.core'

export {
  TwinStickEnemyComponent,
  EnemyEvents,
  decideLocomotion,
  wanderHeading,
  allDeathClips,
  chooseDeathClip,
  type TwinStickEnemyInput,
} from './TwinStickEnemy.core'

const WANDER_JITTER = 0.9

export class TwinStickEnemySystem extends System {
  // Parked (pooled) enemies are inactive, so the query already excludes them —
  // no tag needed. A `dying` enemy (playing its death animation before the
  // pool re-parks it) is excluded so it stops chasing / dealing contact damage
  // while the corpse falls.
  protected query = { required: [TwinStickEnemyComponent, MeshPrimitiveComponent], excludedTags: ['dying'] }
  // Enemies that (re)entered the query this frame — e.g. a pooled enemy
  // un-parked by the Pool. MeshPrimitiveSystem repositions their mesh on that
  // same frame; committing a position here too would make two systems write the
  // one handle (an adapter race). Skip them once; they start chasing next frame.
  private newborns = new Set<string>()
  // Animation state per enemy (animated enemies only) so a clip change only
  // fires on a transition: 'walk' loops the walk clip, 'idle' stops it (freeze
  // when not moving), 'attack' stops the loop and throws punches on top.
  // Cleared on (re)spawn so the state re-emits. undefined = not yet decided.
  private animState = new Map<string, 'idle' | 'walk' | 'attack'>()
  // Enemies with a punch one-shot in flight. Gates one swing at a time; cleared
  // when the punch completes (where the hit lands) so the next swing can start.
  private punching = new Set<string>()
  // Last committed XZ per enemy, to tell whether it actually moved this frame
  // (a wall-blocked or fully-separated enemy stops walking). Cleared on respawn.
  private prevPos = new Map<string, { x: number; z: number }>()
  // Enemies fading out after their death clip: entityId → fade countdown. A
  // dying enemy is excluded from the query, so this is driven directly each
  // frame (independent of `this.entities`); on completion the slot recycles.
  private fading = new Map<string, { t: number; total: number }>()
  // Last shot direction per enemy, recorded off `bullet.hit` (normalized XZ).
  // Read when the enemy dies to aim the knockback slide; cleared on (re)spawn.
  private lastHitDir = new Map<string, { x: number; z: number }>()
  // Enemies currently sliding from a death knockback: entityId → XZ velocity.
  // Dying enemies are excluded from the query, so this drives them directly —
  // each frame we integrate + decay the slide and fold them into separation so
  // the corpse shoves the living swarm. Dropped once the slide dies out.
  private knockback = new Map<string, { vx: number; vz: number }>()
  // Per-enemy wander state. `wanderTimer` counts down to the next re-heading.
  // `facingX/facingZ` is the travel direction (matching the visual yaw), used at
  // death to pick a directional fall clip from the shot angle. Cleared on respawn.
  private ai = new Map<
    string,
    { wanderTimer: number; wanderX: number; wanderZ: number; facingX: number; facingZ: number }
  >()
  // Whether each enemy currently sees its target, fed by LineOfSightSystem's
  // `lineofsight.acquired`/`lost` events. Missing entry → not yet reported →
  // default to chasing (an enemy with no LineOfSight component just chases).
  private canSee = new Map<string, boolean>()

  protected onEntityAdded(entity: Entity): void {
    this.newborns.add(entity.id)
    // Force a fresh clip on (re)spawn — a recycled slot's animator forgot its
    // loop on park, so we must re-tell it. Also drop any in-flight punch.
    this.animState.delete(entity.id)
    this.punching.delete(entity.id)
    this.prevPos.delete(entity.id)
    // Drop any stale death-fade for a recycled slot (defensive against a
    // pool recycling a still-fading enemy under pressure).
    this.fading.delete(entity.id)
    // Clear knockback bookkeeping so a recycled slot doesn't inherit the
    // previous occupant's hit direction or a half-finished slide.
    this.lastHitDir.delete(entity.id)
    this.knockback.delete(entity.id)
    // Fresh AI state — a recycled slot must re-decide chase/wander from scratch.
    this.ai.delete(entity.id)
    // Default to chasing until LineOfSightSystem reports otherwise.
    this.canSee.delete(entity.id)
  }

  protected onInitialize(): void {
    // HP lives on the entity's HealthComponent — when HealthSystem decrements
    // it to 0 it fires `health.died`, and we do the enemy-specific post-death
    // cleanup (score award + emit `enemy.killed`). We do NOT destroy the
    // entity: it's pooled, so we ask the Pool to re-park the slot via
    // `pool.release` — immediately for a plain enemy, or after the death
    // clip finishes for an animated one. HealthSystem listens for
    // `health.damage` events emitted by BulletSystem.
    // Perception lives in LineOfSightSystem; we just track the latest result
    // per enemy and let it drive chase vs wander.
    this.listen(LineOfSightEvents.ACQUIRED, (data: { entityId: string }) => {
      this.canSee.set(data.entityId, true)
    })
    this.listen(LineOfSightEvents.LOST, (data: { entityId: string }) => {
      this.canSee.set(data.entityId, false)
      // Re-path immediately instead of coasting on a stale wander heading.
      const ai = this.ai.get(data.entityId)
      if (ai) ai.wanderTimer = 0
    })
    // Record each shot's heading so a fatal hit can fling the corpse the way
    // the bullet was travelling. Fires for every hit; the latest wins.
    this.listen(
      BulletEvents.HIT,
      (data: { entityId: string; dirX?: number; dirZ?: number }) => {
        if (typeof data.dirX !== 'number' || typeof data.dirZ !== 'number') return
        const len = Math.hypot(data.dirX, data.dirZ)
        if (len < 1e-4) return
        this.lastHitDir.set(data.entityId, { x: data.dirX / len, z: data.dirZ / len })
      },
    )
    this.listen(HealthEvents.DIED, (data: { entityId: string }) => {
      const w = this.world
      if (!w) return
      const ent = w.getEntity(data.entityId)
      const e = ent?.get(TwinStickEnemyComponent)
      // Only fire enemy-specific cleanup for entities that actually
      // had an TwinStickEnemyComponent — Player death goes through Health's
      // respawn path and shouldn't trigger score/killed events here.
      if (!ent || !e) return
      this.eventBus.emit(EnemyEvents.KILLED, {
        entityId: data.entityId,
        spawnerId: e.spawnerId,
      })
      this.eventBus.emit(ScoreInputEvents.ADD, {
        ownerEntity: 'Player',
        points: e.pointsOnKill,
      })
      // Animated enemies fall before recycling: tag `dying` (which drops them
      // from this system's query, stopping chase/contact) and play a death clip
      // once, holding its last frame (no resume to walk). When that clip
      // finishes (`completed` below) the corpse fades out, then the slot
      // re-parks. A plain (non-animated) enemy has no death clips, so recycle
      // its slot immediately.
      if (allDeathClips(e.deathClips, e.fallBackClips, e.fallForwardClips).length > 0) {
        ent.addTag('dying')
        // Blow the corpse back along the killing shot. It keeps separating
        // (heavier, in onUpdate) so it knocks into the living swarm. No
        // recorded direction (e.g. died to contact) → just fall in place.
        const dir = this.lastHitDir.get(data.entityId)
        if (e.knockbackSpeed > 0 && dir) {
          this.knockback.set(data.entityId, {
            vx: dir.x * e.knockbackSpeed,
            vz: dir.z * e.knockbackSpeed,
          })
        }
        // Pick the fall direction from the shot angle: dot of the robot's
        // facing with the bullet's travel direction. < 0 → shot in the front
        // (faces the shooter) → fall back; >= 0 → shot in the back → fall
        // forward. null (no shot dir or facing) → random over deathClips.
        const ai = this.ai.get(data.entityId)
        let dot: number | null = null
        if (dir && ai && Math.hypot(ai.facingX, ai.facingZ) > 1e-3) {
          dot = ai.facingX * dir.x + ai.facingZ * dir.z
        }
        this.lastHitDir.delete(data.entityId)
        const clip = chooseDeathClip(
          e.deathClips,
          e.fallBackClips,
          e.fallForwardClips,
          dot,
          Math.random(),
        )
        if (clip) {
          this.eventBus.emit(SkeletonAnimatorInputEvents.PLAY_ONCE, {
            entityId: data.entityId,
            clip,
            hold: true,
          })
        }
      } else {
        this.eventBus.emit(PoolInputEvents.RELEASE, { entityId: data.entityId })
      }
    })
    // One-shot finished. A death clip → fade the corpse out (driven in
    // onUpdate) then re-park, or recycle now if no fade. A punch clip → the
    // swing lands NOW: damage the target if it's still in contact, then free
    // the slot for the next swing. Pacing the hit to the punch's completion is
    // what keeps the attack rate in step with the animation.
    this.listen(
      SkeletonAnimatorEvents.COMPLETED,
      (data: { entityId: string; clip: string }) => {
        const w = this.world
        const ent = w?.getEntity(data.entityId)
        const e = ent?.get(TwinStickEnemyComponent)
        if (!w || !ent || !e) return

        if (allDeathClips(e.deathClips, e.fallBackClips, e.fallForwardClips).includes(data.clip)) {
          if (e.deathFadeSeconds > 0) {
            this.fading.set(data.entityId, { t: e.deathFadeSeconds, total: e.deathFadeSeconds })
          } else {
            this.eventBus.emit(PoolInputEvents.RELEASE, { entityId: data.entityId })
          }
          return
        }

        if (e.attackClip && data.clip === e.attackClip) {
          this.punching.delete(data.entityId)
          // Don't connect if the enemy started dying mid-swing (the death clip
          // overrides the punch and excludes it from the query).
          if (ent.hasTag('dying')) return
          const m = ent.get(MeshPrimitiveComponent)
          const target = w.getEntitiesByTag(e.targetTag)[0]
          const tm = target?.get(MeshPrimitiveComponent)
          if (m && target && tm) {
            const cx = tm.position[0] - m.position[0]
            const cz = tm.position[2] - m.position[2]
            if (cx * cx + cz * cz <= e.contactRange * e.contactRange) {
              this.eventBus.emit(HealthInputEvents.DAMAGE, {
                entityId: target.id,
                damage: e.contactDamage,
                source: data.entityId,
              })
            }
          }
        }
      },
    )
  }

  protected onShutdown(): void {
    this.animState.clear()
    this.punching.clear()
    this.prevPos.clear()
    this.fading.clear()
    this.lastHitDir.clear()
    this.knockback.clear()
    this.ai.clear()
    this.canSee.clear()
  }

  protected onUpdate(dt: number): void {
    const w = this.world
    const r = w?.renderer
    // Consume this frame's newborns: they're skipped exactly once (their mesh
    // was just positioned at creation), then driven normally from next frame.
    const newborns = this.newborns
    this.newborns = new Set<string>()
    if (!w || !r) return

    // Advance death-fades. Dying enemies are excluded from the query, so this
    // runs off the `fading` map rather than `this.entities`: ramp the model's
    // alpha to 0, then release the slot back to the pool.
    if (this.fading.size > 0) {
      for (const [id, f] of this.fading) {
        f.t -= dt
        r.setModelAlpha(id, f.t <= 0 ? 0 : f.t / f.total)
        if (f.t <= 0) {
          this.fading.delete(id)
          this.eventBus.emit(PoolInputEvents.RELEASE, { entityId: id })
        }
      }
    }

    // Snapshot of (enemy, TwinStickEnemyComponent, MeshPrimitiveComponent) so the
    // separation pass can mutate positions in-place without re-querying.
    const live: Array<{ id: string; e: TwinStickEnemyComponent; m: MeshPrimitiveComponent }> = []
    for (const ent of this.entities) {
      if (newborns.has(ent.id)) continue
      const e = ent.get(TwinStickEnemyComponent)
      const m = ent.get(MeshPrimitiveComponent)
      if (e && m?.handle) live.push({ id: ent.id, e, m })
    }

    // Snapshot corpses still sliding from a death knockback. They're tagged
    // `dying` (so excluded from the query above), but still occupy space:
    // integrate + decay their slide here, then fold them into separation so a
    // blown-back corpse barrels into the living swarm and shoves it aside.
    const knocked: Array<{ e: TwinStickEnemyComponent; m: MeshPrimitiveComponent }> = []
    for (const [id, kv] of this.knockback) {
      const ent = w.getEntity(id)
      const e = ent?.get(TwinStickEnemyComponent)
      const m = ent?.get(MeshPrimitiveComponent)
      if (!ent || !ent.active || !e || !m?.handle) {
        this.knockback.delete(id)
        continue
      }
      m.position[0] += kv.vx * dt
      m.position[2] += kv.vz * dt
      const decay = Math.exp(-e.knockbackDamping * dt)
      kv.vx *= decay
      kv.vz *= decay
      knocked.push({ e, m })
      // Stop tracking once the slide all but dies out — the corpse holds its
      // resting spot and fades on its own.
      if (Math.hypot(kv.vx, kv.vz) < 0.1) this.knockback.delete(id)
    }

    if (live.length === 0 && knocked.length === 0) return

    // Living enemies share the same `targetTag` (per-entity input, but in
    // practice one shared target). Grab the first match — if the scene has no
    // such entity (or there are no living enemies), we skip chase + contact but
    // still run separation so corpses and any swarm don't stack.
    const targetTag = live[0]?.e.targetTag
    const targets = targetTag ? w.getEntitiesByTag(targetTag) : []
    const target = targets[0]
    const targetMesh = target?.get(MeshPrimitiveComponent)
    const targetId = target?.id

    // Obstacle footprints this frame: every barrier blocks movement (resolved
    // after separation). Static, so collect once. (Sight occlusion now lives in
    // LineOfSightSystem.)
    const obstacleBoxes = collectObstacleBoxes(w)

    // Crowd centroid (XZ) of the living swarm — wanderers steer away from it so
    // the pack spreads out instead of all funnelling onto the player.
    let crowdX = 0
    let crowdZ = 0
    for (const { m } of live) {
      crowdX += m.position[0]
      crowdZ += m.position[2]
    }
    crowdX /= live.length
    crowdZ /= live.length

    // CHASE vs WANDER — driven by LineOfSightSystem's acquired/lost events
    // (default: chase until told otherwise). Sees the player → walk straight at
    // it (planting in contact range). Can't see it (buried in the pack, behind
    // a wall, or outside its FOV) → wander away from the crowd, so the swarm
    // fans out and flanks instead of single-filing the player.
    for (const { id, e, m } of live) {
      let ai = this.ai.get(id)
      if (!ai) {
        ai = { wanderTimer: 0, wanderX: 0, wanderZ: 0, facingX: 0, facingZ: 0 }
        this.ai.set(id, ai)
      }
      const canSee = this.canSee.get(id) ?? true

      if (canSee && targetMesh) {
        const dx = targetMesh.position[0] - m.position[0]
        const dz = targetMesh.position[2] - m.position[2]
        const len = Math.hypot(dx, dz)
        // A chaser faces the player even when planted in contact range, so track
        // facing here (before the movement guard).
        if (len > 1e-4) {
          ai.facingX = dx / len
          ai.facingZ = dz / len
        }
        // Plant once in contact range: hold position so the punch plays
        // sustained instead of pushing through the player.
        if (len > e.contactRange) {
          m.position[0] += (dx / len) * e.speed * dt
          m.position[2] += (dz / len) * e.speed * dt
        }
      } else {
        // WANDER — re-pick a heading away from the crowd every `wanderInterval`,
        // then drift along it. Confinement (below) keeps it inside the arena.
        ai.wanderTimer -= dt
        if (ai.wanderTimer <= 0) {
          ai.wanderTimer = e.wanderInterval
          const jitter = (Math.random() * 2 - 1) * WANDER_JITTER
          const [hx, hz] = wanderHeading(
            m.position[0] - crowdX,
            m.position[2] - crowdZ,
            jitter,
            Math.random() * Math.PI * 2,
          )
          ai.wanderX = hx
          ai.wanderZ = hz
        }
        m.position[0] += ai.wanderX * e.wanderSpeed * dt
        m.position[2] += ai.wanderZ * e.wanderSpeed * dt
        ai.facingX = ai.wanderX
        ai.facingZ = ai.wanderZ
      }

      // Aim the model: write the AI's facing (player-ward while chasing, the
      // heading while wandering) onto the proxy's rotation. The follow mesh
      // (faceMode:'proxy') copies it, so a planted, crowded robot keeps facing
      // the player instead of spinning toward separation nudges.
      if (Math.hypot(ai.facingX, ai.facingZ) > 1e-4) {
        m.rotation[1] = Math.atan2(ai.facingX, ai.facingZ)
      }
    }

    // SEPARATION — pairwise push apart over every body that occupies space:
    // living enemies (weight 1) plus knocked-back corpses (weight
    // `knockbackMass`, heavier). O(n²) is fine for the small live count. The
    // pair splits the overlap by mass: equal weights → half each (the original
    // behaviour), while a heavy sliding corpse barely deflects and the light
    // living enemy it hits takes most of the push — so it gets knocked aside.
    const bodies: Array<{ e: TwinStickEnemyComponent; m: MeshPrimitiveComponent; weight: number }> = []
    for (const l of live) bodies.push({ e: l.e, m: l.m, weight: 1 })
    for (const k of knocked) bodies.push({ e: k.e, m: k.m, weight: k.e.knockbackMass })
    for (let i = 0; i < bodies.length; i++) {
      for (let j = i + 1; j < bodies.length; j++) {
        const a = bodies[i]!
        const b = bodies[j]!
        const dx = b.m.position[0] - a.m.position[0]
        const dz = b.m.position[2] - a.m.position[2]
        const dist = Math.hypot(dx, dz)
        const minDist = a.e.separationRadius + b.e.separationRadius
        if (dist >= minDist || dist < 1e-4) continue
        const overlap = minDist - dist
        const ux = dx / dist
        const uz = dz / dist
        // Lighter body takes the larger share of the push.
        const total = a.weight + b.weight
        const pushA = overlap * (b.weight / total)
        const pushB = overlap * (a.weight / total)
        a.m.position[0] -= ux * pushA
        a.m.position[2] -= uz * pushA
        b.m.position[0] += ux * pushB
        b.m.position[2] += uz * pushB
      }
    }

    // CONFINE — keep bodies inside the arena (chase, separation, and knockback
    // can push an edge body past the walls). 0 = unbounded.
    for (const { e, m } of bodies) {
      if (e.arenaHalfWidth > 0) {
        m.position[0] = clamp(m.position[0], -e.arenaHalfWidth, e.arenaHalfWidth)
      }
      if (e.arenaHalfDepth > 0) {
        m.position[2] = clamp(m.position[2], -e.arenaHalfDepth, e.arenaHalfDepth)
      }
    }

    // OBSTACLES — every barrier (full or low cover) blocks movement; push each
    // body's circle out of any box it ended up overlapping. Runs last so it has
    // the final say over chase/wander/separation/knockback motion.
    if (obstacleBoxes.length > 0) {
      for (const { m } of bodies) {
        const radius = m.diameter > 0 ? m.diameter / 2 : 0.5
        for (const b of obstacleBoxes) {
          const [nx, nz] = resolveCircleVsBox(m.position[0], m.position[2], radius, b)
          m.position[0] = nx
          m.position[2] = nz
        }
      }
    }

    // Commit the sliding corpses' positions. They're dead — no contact damage
    // or locomotion anim, just the moved transform under their death clip.
    for (const { m } of knocked) {
      r.setMeshPosition(m.handle!, m.position[0], m.position[1], m.position[2])
    }

    // Commit living positions to the renderer, then drive contact + animation.
    if (targetMesh && targetId) {
      for (const { id, e, m } of live) {
        r.setMeshPosition(m.handle!, m.position[0], m.position[1], m.position[2])
        const cx = targetMesh.position[0] - m.position[0]
        const cz = targetMesh.position[2] - m.position[2]
        const inContact = cx * cx + cz * cz <= e.contactRange * e.contactRange

        if (e.walkClip) {
          // Animated enemy: idle / walk / attack. The hit no longer fires every
          // frame — it lands on each punch's completion (in the COMPLETED
          // listener above), so the attack rate matches the punch animation.
          const dist = Math.hypot(cx, cz)
          const prev = this.animState.get(id)
          const basis = prev === 'attack' ? 'attack' : 'walk'
          const attacking =
            !!e.attackClip &&
            decideLocomotion(dist, e.contactRange, basis, e.attackRangeHysteresis) === 'attack'

          // Did it actually move? Enemies face their travel direction, so a still
          // enemy isn't rotating either — a wall-blocked or fully-separated one
          // reads as not moving and stops the walk cycle.
          const pp = this.prevPos.get(id)
          const moved = pp ? Math.hypot(m.position[0] - pp.x, m.position[2] - pp.z) : Infinity
          const moving = moved > 1e-3 + e.speed * dt * 0.1

          const next: 'idle' | 'walk' | 'attack' = attacking ? 'attack' : moving ? 'walk' : 'idle'
          if (next !== prev) {
            this.animState.set(id, next)
            if (next === 'walk') {
              this.eventBus.emit(SkeletonAnimatorInputEvents.SET_LOOP, { entityId: id, clip: e.walkClip })
            } else {
              // idle OR attack: stop the base loop ('' freezes the current
              // frame). For attack the punch one-shots play on top, so the model
              // doesn't shuffle its feet between swings.
              this.eventBus.emit(SkeletonAnimatorInputEvents.SET_LOOP, { entityId: id, clip: '' })
              if (next === 'attack') this.punching.delete(id) // let the first swing fire now
            }
          }
          // Keep swinging while in range — one punch at a time; the hit lands on
          // its completion (above).
          if (next === 'attack' && !this.punching.has(id)) {
            this.punching.add(id)
            this.eventBus.emit(SkeletonAnimatorInputEvents.PLAY_ONCE, { entityId: id, clip: e.attackClip })
          }
        } else if (inContact) {
          // Plain (non-animated) enemy: damage every frame in contact, paced by
          // HealthSystem's i-frames — the original behaviour.
          this.eventBus.emit(HealthInputEvents.DAMAGE, {
            entityId: targetId,
            damage: e.contactDamage,
            source: id,
          })
        }

        this.prevPos.set(id, { x: m.position[0], z: m.position[2] })
      }
    } else {
      // No target — only positions need committing.
      for (const { id, m } of live) {
        r.setMeshPosition(m.handle!, m.position[0], m.position[1], m.position[2])
        this.prevPos.set(id, { x: m.position[0], z: m.position[2] })
      }
    }
  }
}

function clamp(v: number, lo: number, hi: number): number {
  return v < lo ? lo : v > hi ? hi : v
}

import { runMechanicContract } from '@babylonjsmarket/ecs/testing';
import { TwinStickEnemyComponent, TwinStickEnemySystem } from './TwinStickEnemy';
import { MeshPrimitiveComponent } from '../MeshPrimitive/MeshPrimitive.core';

runMechanicContract({
  name: 'Enemy',
  componentClass: TwinStickEnemyComponent,
  systemClass: TwinStickEnemySystem,
  sampleInput: { speed: 5, pointsOnKill: 250, targetTag: 'hero' },
  // TwinStickEnemySystem mutates the entity's sibling MeshPrimitive each frame.
  companions: [MeshPrimitiveComponent],
  events: {
    // TwinStickEnemySystem.onInitialize subscribes to 'health.died' to drive the kill
    // cleanup flow (emit EnemyEvents.KILLED + 'score.add' + remove entity).
    input: ['health.died'],
    // Skipping events.output — KILLED / 'score.add' only fire after a
    // 'health.died' event for an entity that *also* has a HealthComponent
    // worth of state behind it; that's a multi-system flow covered by
    // scene-level tests, not this contract.
  },
});

import { describe, it, expect } from 'vitest';
import {
  TwinStickEnemyComponent,
  wanderHeading,
  allDeathClips,
  chooseDeathClip,
  decideLocomotion,
} from './TwinStickEnemy.core';

describe('TwinStickEnemyComponent', () => {
  it('applies defaults', () => {
    const c = new TwinStickEnemyComponent();
    expect(c.speed).toBe(2.5);
    expect(c.spawnerId).toBe('');
    expect(c.pointsOnKill).toBe(100);
    expect(c.separationRadius).toBe(1.0);
    expect(c.contactRange).toBe(1.1);
    expect(c.contactDamage).toBe(1);
    expect(c.targetTag).toBe('player');
  });

  it('merges overrides on top of defaults', () => {
    const c = new TwinStickEnemyComponent({
      speed: 5,
      pointsOnKill: 250,
      targetTag: 'hero',
    });
    expect(c.speed).toBe(5);
    expect(c.pointsOnKill).toBe(250);
    expect(c.targetTag).toBe('hero');
    expect(c.separationRadius).toBe(1.0); // untouched
    expect(c.contactRange).toBe(1.1); // untouched
    expect(c.contactDamage).toBe(1); // untouched
  });

  it('serialize round-trips', () => {
    const a = new TwinStickEnemyComponent({
      speed: 3.5,
      spawnerId: 'Spawner1',
      pointsOnKill: 200,
      separationRadius: 1.2,
      contactRange: 1.5,
      contactDamage: 2,
      targetTag: 'hero',
    });
    const b = new TwinStickEnemyComponent(a.serialize());
    expect(b.speed).toBe(a.speed);
    expect(b.spawnerId).toBe(a.spawnerId);
    expect(b.pointsOnKill).toBe(a.pointsOnKill);
    expect(b.separationRadius).toBe(a.separationRadius);
    expect(b.contactRange).toBe(a.contactRange);
    expect(b.contactDamage).toBe(a.contactDamage);
    expect(b.targetTag).toBe(a.targetTag);
  });
});

describe('wanderHeading', () => {
  it('heads directly away from the crowd with no jitter', () => {
    // Self is +X of the centroid → away vector points +X.
    const [x, z] = wanderHeading(2, 0, 0, 0);
    expect(x).toBeCloseTo(1, 5);
    expect(z).toBeCloseTo(0, 5);
  });

  it('returns a unit vector', () => {
    const [x, z] = wanderHeading(3, -4, 0.5, 1.2);
    expect(Math.hypot(x, z)).toBeCloseTo(1, 5);
  });

  it('falls back to the random angle when sitting on the centroid', () => {
    const [x, z] = wanderHeading(0, 0, 0.5, Math.PI / 2); // π/2 → +Z
    expect(x).toBeCloseTo(0, 5);
    expect(z).toBeCloseTo(1, 5);
  });
});

describe('allDeathClips', () => {
  it('returns deathClips when no directional clips are configured', () => {
    expect(allDeathClips(['a', 'b'], [], [])).toEqual(['a', 'b']);
  });

  it('returns the de-duped union when directional clips are configured', () => {
    expect(allDeathClips(['a'], ['a', 'back'], ['fwd']).sort()).toEqual(['a', 'back', 'fwd']);
  });
});

describe('chooseDeathClip', () => {
  const back = ['Shot_and_Blown_Back', 'Walking_Blow_Back'];
  const fwd = ['Fall_Forward'];

  it('picks a fall-back clip when shot in the front (dot < 0)', () => {
    expect(back).toContain(chooseDeathClip([], back, fwd, -0.8, 0));
    expect(back).toContain(chooseDeathClip([], back, fwd, -0.8, 0.99));
  });

  it('picks a fall-forward clip when shot in the back (dot >= 0)', () => {
    expect(chooseDeathClip([], back, fwd, 0.5, 0)).toBe('Fall_Forward');
    expect(chooseDeathClip([], back, fwd, 0, 0)).toBe('Fall_Forward');
  });

  it('uses rand to index within the directional list', () => {
    // rand 0 → index 0, rand ~1 → last index.
    expect(chooseDeathClip([], back, fwd, -1, 0)).toBe('Shot_and_Blown_Back');
    expect(chooseDeathClip([], back, fwd, -1, 0.99)).toBe('Walking_Blow_Back');
  });

  it('falls back to random deathClips when direction is unknown', () => {
    expect(chooseDeathClip(['r1', 'r2'], back, fwd, null, 0)).toBe('r1');
  });

  it('falls back to deathClips when the matching directional list is empty', () => {
    // Shot in the back but no fall-forward clips configured → random deathClips.
    expect(chooseDeathClip(['r1'], back, [], 0.5, 0)).toBe('r1');
  });

  it('returns undefined when there are no clips at all', () => {
    expect(chooseDeathClip([], [], [], -1, 0)).toBeUndefined();
  });
});

describe('decideLocomotion', () => {
  it("attacks within contactRange regardless of the current state", () => {
    expect(decideLocomotion(1, 1.1, 'walk', 1.15)).toBe('attack');
    expect(decideLocomotion(1.1, 1.1, 'attack', 1.15)).toBe('attack');
  });

  it('walks once past contactRange * hysteresis', () => {
    // contactRange 1.1 * 1.15 = 1.265 → anything beyond exits to walk.
    expect(decideLocomotion(2, 1.1, 'attack', 1.15)).toBe('walk');
    expect(decideLocomotion(2, 1.1, 'walk', 1.15)).toBe('walk');
  });

  it('holds the current state in the hysteresis dead-band', () => {
    // Between contactRange (1.1) and contactRange*hysteresis (1.265): hold.
    expect(decideLocomotion(1.2, 1.1, 'attack', 1.15)).toBe('attack');
    expect(decideLocomotion(1.2, 1.1, 'walk', 1.15)).toBe('walk');
  });
});

import { BulletEvents, PoolInputEvents, HealthEvents, HealthInputEvents, LineOfSightEvents, SkeletonAnimatorEvents, SkeletonAnimatorInputEvents } from '@babylonjsmarket/arcade';
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { EventBus, World, MockRendererAdapter } from '@babylonjsmarket/ecs';
import { TwinStickEnemyComponent, TwinStickEnemySystem, EnemyEvents } from './TwinStickEnemy';
import { MeshPrimitiveComponent } from '../MeshPrimitive/MeshPrimitive.core';
import { ObstacleComponent } from '../Obstacle/Obstacle.core';

describe('TwinStickEnemySystem knockback', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new TwinStickEnemySystem(eventBus));
    world.initialize();
  });

  function makeEnemy(pos: [number, number, number], extra: Record<string, unknown> = {}) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2, position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.add(new TwinStickEnemyComponent({ separationRadius: 1.0, ...extra }));
    return entity;
  }

  // Burn the spawn frame: a freshly-added enemy is a "newborn" and is skipped
  // once so two systems don't write its mesh on the same frame.
  function warmup() {
    world.update(0.016);
  }

  it('blows a killed enemy back along the killing shot', () => {
    const enemy = makeEnemy([0, 0.5, 0], {
      deathClips: ['Shot_and_Blown_Back'],
      knockbackSpeed: 12,
    });
    warmup();

    // Shot travelling +X kills it → corpse should slide +X.
    eventBus.emit(BulletEvents.HIT, { entityId: enemy.id, dirX: 1, dirZ: 0 });
    eventBus.emit(HealthEvents.DIED, { entityId: enemy.id });
    for (let i = 0; i < 10; i++) world.update(0.016);

    const m = enemy.get(MeshPrimitiveComponent)!;
    expect(enemy.hasTag('dying')).toBe(true);
    expect(m.position[0]).toBeGreaterThan(0.5);
    expect(m.position[2]).toBeCloseTo(0, 5);
  });

  it('shoves a living enemy aside as the corpse slides into it', () => {
    // Corpse-to-be at the origin; a living enemy 1.5 ahead, inside the corpse's
    // slide path (combined separationRadius = 2.0). No player → the living one
    // doesn't chase, so any motion it shows is from being knocked into.
    const corpse = makeEnemy([0, 0.5, 0], {
      deathClips: ['Shot_and_Blown_Back'],
      knockbackSpeed: 12,
      knockbackMass: 5,
    });
    const living = makeEnemy([1.5, 0.5, 0]);
    warmup();

    eventBus.emit(BulletEvents.HIT, { entityId: corpse.id, dirX: 1, dirZ: 0 });
    eventBus.emit(HealthEvents.DIED, { entityId: corpse.id });
    for (let i = 0; i < 10; i++) world.update(0.016);

    const livingPos = living.get(MeshPrimitiveComponent)!.position;
    const corpsePos = corpse.get(MeshPrimitiveComponent)!.position;
    // The living enemy got knocked forward (+X) by the heavier sliding corpse...
    expect(livingPos[0]).toBeGreaterThan(1.5);
    // ...and, being lighter, moved further than the corpse retreated from it.
    expect(livingPos[0] - 1.5).toBeGreaterThan(Math.abs(corpsePos[0]));
  });

  it('does not knock back when the death had no recorded shot direction', () => {
    // Died to contact (no bullet.hit) → corpse falls in place, no slide.
    const enemy = makeEnemy([2, 0.5, -1], {
      deathClips: ['Fall_Forward'],
      knockbackSpeed: 12,
    });
    warmup();

    eventBus.emit(HealthEvents.DIED, { entityId: enemy.id });
    for (let i = 0; i < 10; i++) world.update(0.016);

    const m = enemy.get(MeshPrimitiveComponent)!;
    expect(m.position[0]).toBeCloseTo(2, 5);
    expect(m.position[2]).toBeCloseTo(-1, 5);
  });
});

describe('TwinStickEnemySystem chase / wander (driven by LineOfSight events)', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;

  beforeEach(() => {
    // Deterministic wander headings.
    vi.spyOn(Math, 'random').mockReturnValue(0);
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new TwinStickEnemySystem(eventBus));
    world.initialize();
  });

  afterEach(() => vi.restoreAllMocks());

  function makePlayer(pos: [number, number, number]) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.addTag('player');
    return entity;
  }

  function makeEnemy(pos: [number, number, number]) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2, position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.add(new TwinStickEnemyComponent({ speed: 2.5, wanderSpeed: 1.8 }));
    return entity;
  }

  function makeObstacle(pos: [number, number, number], halfWidth: number, halfDepth: number, full: boolean) {
    const entity = world.createEntity();
    entity.add(
      new MeshPrimitiveComponent({
        primitive: 'box',
        width: halfWidth * 2,
        height: full ? 3 : 1,
        depth: halfDepth * 2,
        position: pos,
      }),
    );
    entity.add(new ObstacleComponent({ halfWidth, halfDepth, blocksSight: full, blocksBullets: full }));
    entity.addTag('obstacle');
    return entity;
  }

  it('chases the player by default (no acquired/lost reported yet)', () => {
    makePlayer([10, 0.8, 0]);
    const enemy = makeEnemy([0, 0.5, 0]);
    world.update(0.016); // consume the spawn-frame newborn skip
    for (let i = 0; i < 8; i++) world.update(0.1);

    const p = enemy.get(MeshPrimitiveComponent)!.position;
    expect(p[0]).toBeGreaterThan(0.5); // closed toward the player (+X)
    expect(p[2]).toBeCloseTo(0, 5); // straight line, no sideways drift
  });

  it('wanders off the player when LineOfSight reports the target lost', () => {
    makePlayer([10, 0.8, 0]);
    // A second enemy gives the crowd a centroid to wander away from.
    makeEnemy([5, 0.5, 0]);
    const blocked = makeEnemy([0, 0.5, 0]);
    world.update(0.016); // consume newborns
    // LineOfSightSystem would emit this; here we drive it directly.
    eventBus.emit(LineOfSightEvents.LOST, { entityId: blocked.id });
    for (let i = 0; i < 8; i++) world.update(0.1);

    const p = blocked.get(MeshPrimitiveComponent)!.position;
    // It did NOT beeline the player — it veered away (−X) and off-axis.
    expect(p[0]).toBeLessThan(0);
    expect(Math.abs(p[2])).toBeGreaterThan(0.1);
  });

  it('cannot walk through a barrier', () => {
    makePlayer([10, 0.8, 0]);
    // Low cover (doesn't block sight) → the enemy keeps chasing straight into
    // it; the box must stop it. Near face is at x = 4.
    makeObstacle([5, 0.5, 0], 1, 2, false);
    const enemy = makeEnemy([0, 0.5, 0]);
    world.update(0.016); // consume newborns
    for (let i = 0; i < 40; i++) world.update(0.1);

    const p = enemy.get(MeshPrimitiveComponent)!.position;
    // Pressed against the near face (4) but pushed out by its radius (0.6) — it
    // never crossed to the player's side.
    expect(p[0]).toBeGreaterThan(3); // advanced up to the wall
    expect(p[0]).toBeLessThan(4); // but did not pass through it
  });
});

describe('TwinStickEnemySystem directional death clip', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;
  let playOnce: Array<{ entityId: string; clip: string }>;

  const FALL_BACK = ['Shot_and_Blown_Back', 'Walking_Blow_Back'];
  const FALL_FORWARD = ['Fall_Forward'];

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new TwinStickEnemySystem(eventBus));
    world.initialize();
    playOnce = [];
    eventBus.on(SkeletonAnimatorInputEvents.PLAY_ONCE, (d: { entityId: string; clip: string }) =>
      playOnce.push(d),
    );
  });

  function makePlayer(pos: [number, number, number]) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.addTag('player');
    return entity;
  }

  function makeEnemy(pos: [number, number, number]) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2, position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.add(new TwinStickEnemyComponent({ fallBackClips: FALL_BACK, fallForwardClips: FALL_FORWARD }));
    return entity;
  }

  // Player at +X; the enemy chases toward it so its facing settles to +X.
  function spawnChasingEnemy() {
    makePlayer([10, 0.8, 0]);
    const enemy = makeEnemy([0, 0.5, 0]);
    world.update(0.016); // consume newborns
    for (let i = 0; i < 3; i++) world.update(0.1); // chase → facing +X (toward player)
    return enemy;
  }

  it('falls backward when shot in the front (facing the player)', () => {
    const enemy = spawnChasingEnemy();
    // A shot from the player (+X side) travels −X into the robot's front.
    eventBus.emit(BulletEvents.HIT, { entityId: enemy.id, dirX: -1, dirZ: 0 });
    eventBus.emit(HealthEvents.DIED, { entityId: enemy.id });
    world.update(0.016);

    const last = playOnce.at(-1);
    expect(last?.entityId).toBe(enemy.id);
    expect(FALL_BACK).toContain(last?.clip);
  });

  it('pitches forward when shot in the back (facing away from the shot)', () => {
    const enemy = spawnChasingEnemy();
    // A shot travelling +X (from behind the +X-facing robot) hits its back.
    eventBus.emit(BulletEvents.HIT, { entityId: enemy.id, dirX: 1, dirZ: 0 });
    eventBus.emit(HealthEvents.DIED, { entityId: enemy.id });
    world.update(0.016);

    expect(playOnce.at(-1)?.clip).toBe('Fall_Forward');
  });
});

describe('TwinStickEnemySystem death flow & cleanup', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;
  let released: Array<{ entityId: string }>;
  let killed: Array<{ entityId: string; spawnerId: string }>;
  let scores: Array<{ ownerEntity: string; points: number }>;
  let playOnce: Array<{ entityId: string; clip: string; hold?: boolean }>;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new TwinStickEnemySystem(eventBus));
    world.initialize();
    released = [];
    killed = [];
    scores = [];
    playOnce = [];
    eventBus.on(PoolInputEvents.RELEASE, (d: { entityId: string }) => released.push(d));
    eventBus.on(EnemyEvents.KILLED, (d: { entityId: string; spawnerId: string }) => killed.push(d));
    eventBus.on('score.add', (d: { ownerEntity: string; points: number }) => scores.push(d));
    eventBus.on(
      SkeletonAnimatorInputEvents.PLAY_ONCE,
      (d: { entityId: string; clip: string; hold?: boolean }) => playOnce.push(d),
    );
  });

  function makeEnemy(pos: [number, number, number], extra: Record<string, unknown> = {}) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2, position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.add(new TwinStickEnemyComponent({ spawnerId: 'Spawner1', pointsOnKill: 150, ...extra }));
    return entity;
  }

  it('awards score + emits killed, and recycles a plain enemy immediately', () => {
    const enemy = makeEnemy([0, 0.5, 0]); // no death clips → plain enemy
    world.update(0.016);

    eventBus.emit(HealthEvents.DIED, { entityId: enemy.id });

    expect(killed).toEqual([{ entityId: enemy.id, spawnerId: 'Spawner1' }]);
    expect(scores).toEqual([{ ownerEntity: 'Player', points: 150 }]);
    // No death clips → released right away, never tagged dying.
    expect(released).toEqual([{ entityId: enemy.id }]);
    expect(enemy.hasTag('dying')).toBe(false);
  });

  it('ignores health.died for an entity that has no TwinStickEnemyComponent', () => {
    const player = world.createEntity();
    eventBus.emit(HealthEvents.DIED, { entityId: player.id });
    eventBus.emit(HealthEvents.DIED, { entityId: 'does-not-exist' });
    expect(killed).toHaveLength(0);
    expect(scores).toHaveLength(0);
    expect(released).toHaveLength(0);
  });

  it('fades the corpse out then releases it after the death clip completes', () => {
    const enemy = makeEnemy([0, 0.5, 0], {
      deathClips: ['Die'],
      deathFadeSeconds: 0.1,
      knockbackSpeed: 0,
    });
    world.update(0.016);
    eventBus.emit(HealthEvents.DIED, { entityId: enemy.id });
    expect(enemy.hasTag('dying')).toBe(true);

    // The death clip finishes → begin the fade (no immediate release).
    eventBus.emit(SkeletonAnimatorEvents.COMPLETED, { entityId: enemy.id, clip: 'Die' });
    expect(released).toHaveLength(0);

    // Drive the fade countdown: alpha ramps toward 0, then release fires.
    world.update(0.05);
    expect(renderer.setModelAlpha).toBeDefined;
    expect(released).toHaveLength(0);
    world.update(0.06); // crosses 0.1s total → release
    expect(released).toEqual([{ entityId: enemy.id }]);
  });

  it('releases immediately on death-clip completion when there is no fade', () => {
    const enemy = makeEnemy([0, 0.5, 0], { deathClips: ['Die'], deathFadeSeconds: 0 });
    world.update(0.016);
    eventBus.emit(HealthEvents.DIED, { entityId: enemy.id });

    eventBus.emit(SkeletonAnimatorEvents.COMPLETED, { entityId: enemy.id, clip: 'Die' });
    expect(released).toEqual([{ entityId: enemy.id }]);
  });

  it('ignores a COMPLETED event for an unknown entity / missing component', () => {
    eventBus.emit(SkeletonAnimatorEvents.COMPLETED, { entityId: 'ghost', clip: 'Die' });
    expect(released).toHaveLength(0);
  });

  it('drops a knockback slide once the corpse is parked (inactive)', () => {
    const enemy = makeEnemy([0, 0.5, 0], {
      deathClips: ['Die'],
      knockbackSpeed: 12,
      deathFadeSeconds: 0,
    });
    world.update(0.016);
    eventBus.emit(BulletEvents.HIT, { entityId: enemy.id, dirX: 1, dirZ: 0 });
    eventBus.emit(HealthEvents.DIED, { entityId: enemy.id });
    world.update(0.016); // slide started

    // Park the slot mid-slide: the knockback map entry must be dropped, not
    // integrated, and no crash on the missing/inactive entity.
    enemy.active = false;
    expect(() => world.update(0.016)).not.toThrow();
  });
});

describe('TwinStickEnemySystem animated locomotion (walk / idle / attack)', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;
  let setLoop: Array<{ entityId: string; clip: string }>;
  let playOnce: Array<{ entityId: string; clip: string }>;
  let damage: Array<{ entityId: string; damage: number; source: string }>;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new TwinStickEnemySystem(eventBus));
    world.initialize();
    setLoop = [];
    playOnce = [];
    damage = [];
    eventBus.on(SkeletonAnimatorInputEvents.SET_LOOP, (d: { entityId: string; clip: string }) =>
      setLoop.push(d),
    );
    eventBus.on(SkeletonAnimatorInputEvents.PLAY_ONCE, (d: { entityId: string; clip: string }) =>
      playOnce.push(d),
    );
    eventBus.on(HealthInputEvents.DAMAGE, (d: { entityId: string; damage: number; source: string }) =>
      damage.push(d),
    );
  });

  function makePlayer(pos: [number, number, number]) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.addTag('player');
    return entity;
  }

  function makeEnemy(pos: [number, number, number], extra: Record<string, unknown> = {}) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2, position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.add(new TwinStickEnemyComponent({ ...extra }));
    return entity;
  }

  it('loops the walk clip while chasing, then attacks once in contact range', () => {
    makePlayer([5, 0.8, 0]);
    const enemy = makeEnemy([0, 0.5, 0], {
      walkClip: 'Walk',
      attackClip: 'Punch',
      speed: 6,
      contactRange: 1.1,
      contactDamage: 4,
    });
    world.update(0.016); // burn newborn frame

    // First moving frame → SET_LOOP 'Walk'.
    world.update(0.1);
    expect(setLoop.some((s) => s.clip === 'Walk' && s.entityId === enemy.id)).toBe(true);

    // Close the gap until it plants in contact range and swings.
    for (let i = 0; i < 30; i++) world.update(0.1);
    // Attack stops the base loop ('') and fires a punch one-shot.
    expect(setLoop.some((s) => s.clip === '' && s.entityId === enemy.id)).toBe(true);
    expect(playOnce.some((p) => p.clip === 'Punch' && p.entityId === enemy.id)).toBe(true);
  });

  it('lands contact damage when a punch completes inside range, then re-arms', () => {
    makePlayer([0.5, 0.8, 0]); // already in contact range
    const enemy = makeEnemy([0, 0.5, 0], {
      walkClip: 'Walk',
      attackClip: 'Punch',
      contactRange: 1.1,
      contactDamage: 7,
    });
    world.update(0.016);
    world.update(0.1); // decides attack → fires first punch one-shot

    const firstPunch = playOnce.filter((p) => p.clip === 'Punch').length;
    expect(firstPunch).toBeGreaterThan(0);

    // The punch completes in contact → damage lands on the player.
    eventBus.emit(SkeletonAnimatorEvents.COMPLETED, { entityId: enemy.id, clip: 'Punch' });
    expect(damage.some((d) => d.source === enemy.id && d.damage === 7)).toBe(true);
  });

  it('does not connect a punch that completes after the enemy started dying', () => {
    makePlayer([0.5, 0.8, 0]);
    const enemy = makeEnemy([0, 0.5, 0], {
      walkClip: 'Walk',
      attackClip: 'Punch',
      contactRange: 1.1,
      contactDamage: 7,
    });
    world.update(0.016);
    world.update(0.1);

    enemy.addTag('dying'); // death clip overrode the swing
    eventBus.emit(SkeletonAnimatorEvents.COMPLETED, { entityId: enemy.id, clip: 'Punch' });
    expect(damage).toHaveLength(0);
  });

  it('does not connect a punch when the target left contact range', () => {
    const player = makePlayer([0.5, 0.8, 0]);
    const enemy = makeEnemy([0, 0.5, 0], {
      walkClip: 'Walk',
      attackClip: 'Punch',
      contactRange: 1.1,
      contactDamage: 7,
    });
    world.update(0.016);
    world.update(0.1);

    // Player runs far away before the punch lands.
    const pm = player.get(MeshPrimitiveComponent)!;
    pm.position[0] = 50;
    eventBus.emit(SkeletonAnimatorEvents.COMPLETED, { entityId: enemy.id, clip: 'Punch' });
    expect(damage).toHaveLength(0);
  });

  it('goes idle (stops the walk loop) when blocked from moving', () => {
    // No player and wander disabled by lost-LOS-less default? Use a still enemy:
    // a chaser planted on top of the player reads as not moving → idle.
    makePlayer([0, 0.8, 0]); // player AT the enemy → in contact, no travel
    const enemy = makeEnemy([0, 0.5, 0], {
      walkClip: 'Walk',
      contactRange: 1.1,
      speed: 6,
    });
    world.update(0.016);
    world.update(0.1); // in contact, planted → not moving → idle ('')
    world.update(0.1);

    expect(setLoop.some((s) => s.clip === '' && s.entityId === enemy.id)).toBe(true);
  });

  it('plain (non-animated) enemy damages every frame it is in contact', () => {
    makePlayer([0.5, 0.8, 0]); // inside contactRange
    const enemy = makeEnemy([0, 0.5, 0], { contactRange: 1.1, contactDamage: 3 }); // no walkClip
    world.update(0.016);
    world.update(0.016);
    world.update(0.016);
    const fromEnemy = damage.filter((d) => d.source === enemy.id && d.damage === 3);
    expect(fromEnemy.length).toBeGreaterThanOrEqual(2);
  });
});

describe('TwinStickEnemySystem arena confinement', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new TwinStickEnemySystem(eventBus));
    world.initialize();
  });

  function makePlayer(pos: [number, number, number]) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.addTag('player');
    return entity;
  }

  function makeEnemy(pos: [number, number, number], extra: Record<string, unknown> = {}) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2, position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.add(new TwinStickEnemyComponent({ speed: 50, ...extra }));
    return entity;
  }

  it('clamps an enemy chasing past the arena half-extents', () => {
    // Player far outside the arena → the fast enemy would overshoot the walls.
    makePlayer([100, 0.8, 100]);
    const enemy = makeEnemy([0, 0.5, 0], { arenaHalfWidth: 3, arenaHalfDepth: 4 });
    world.update(0.016);
    for (let i = 0; i < 20; i++) world.update(0.1);

    const p = enemy.get(MeshPrimitiveComponent)!.position;
    expect(p[0]).toBeLessThanOrEqual(3);
    expect(p[2]).toBeLessThanOrEqual(4);
    // Clamped right against the walls.
    expect(p[0]).toBeCloseTo(3, 5);
    expect(p[2]).toBeCloseTo(4, 5);
  });
});

describe('TwinStickEnemySystem LineOfSight ACQUIRED', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new TwinStickEnemySystem(eventBus));
    world.initialize();
  });

  function makePlayer(pos: [number, number, number]) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.addTag('player');
    return entity;
  }

  function makeEnemy(pos: [number, number, number]) {
    const entity = world.createEntity();
    const mesh = new MeshPrimitiveComponent({ primitive: 'sphere', diameter: 1.2, position: pos });
    mesh.handle = renderer.createMesh(entity.id, mesh.toPrimitiveSpec());
    entity.add(mesh);
    entity.add(new TwinStickEnemyComponent({ speed: 2.5 }));
    return entity;
  }

  it('chases after acquiring the target (canSee = true)', () => {
    makePlayer([10, 0.8, 0]);
    const enemy = makeEnemy([0, 0.5, 0]);
    world.update(0.016);
    // Report lost first, then re-acquired — drives both branches and confirms
    // chase resumes (closing the +X gap).
    eventBus.emit(LineOfSightEvents.LOST, { entityId: enemy.id });
    eventBus.emit(LineOfSightEvents.ACQUIRED, { entityId: enemy.id });
    for (let i = 0; i < 8; i++) world.update(0.1);

    const p = enemy.get(MeshPrimitiveComponent)!.position;
    expect(p[0]).toBeGreaterThan(0.5);
    expect(p[2]).toBeCloseTo(0, 5);
  });
});