## Virtual body tracker — mirrors virtual_bullets.nim but for movement modules.
## Tracks simulated positions for each movement candidate under enemy waves.
## Scores modules by how often they sit in high-danger GF bins.
## Caller feeds actual hit data via registerHit() to build the danger profile.

import std/math
import gun_harness/gun_interface
import movement_harness/movement_interface
import movement_harness/gunheat_tracker
import movement_harness/bullet_shadows

const
  VB_BINS*     = 31      ## GF bins from -1 to +1
  MaxWaves*    = 64      ## hard cap; ponytail: ring buffer, resize if needed
  MaxModules*  = 8       ## max movement modules tracked

type
  VBWave = object
    fireX, fireY:    float
    fireBearingRad:  float   ## bearing from fireOrigin to REAL bot at fire time (radians)
    speed:           float
    radius:          float
    fireTick:        int
    startDist:       float

  VirtualBody = object
    x, y:     float
    heading:  float   ## degrees (Tank Royale / bot API)
    speed:    float   ## current speed px/tick

  VirtualBodyTracker* = object
    numModules:    int
    bodies:        array[MaxModules, VirtualBody]
    dangerScore:   array[MaxModules, float]       ## accumulated danger hits
    dangerBins:    array[VB_BINS, float]          ## populated from registerHit
    waves:         array[MaxWaves, VBWave]
    waveCount:     int
    waveHead:      int  ## ring buffer head
    gunheat:       GunheatTracker
    shadows*:      ShadowTracker  ## our bullets in flight for shadow computation
    arenaW, arenaH: float

proc initVirtualBodyTracker*(numModules: int): VirtualBodyTracker =
  result.numModules = numModules
  result.gunheat    = initGunheatTracker()
  # Seed bins so we have a uniform prior before any real hits
  for i in 0..<VB_BINS: result.dangerBins[i] = 1.0

proc resetRound*(t: var VirtualBodyTracker, startX, startY, startHeading, startSpeed: float) =
  ## Reset virtual body positions to actual bot position at round start.
  for i in 0..<t.numModules:
    t.bodies[i] = VirtualBody(x: startX, y: startY,
                               heading: startHeading, speed: startSpeed)
  t.waveCount = 0
  t.waveHead  = 0
  t.gunheat.resetRound()

proc registerHit*(t: var VirtualBodyTracker, bulletPower: float, bulletHeadingDeg: float,
                  realX, realY: float) =
  ## Feed an actual HitByBullet event in. Computes exact GF bin and increments danger.
  ## bulletHeadingDeg: the heading the bullet was travelling when it hit (degrees).
  ## We need the wave that fired it to get fireBearing; absent that, just increment center.
  ## ponytail: approximate — we don't correlate to exact wave here, just record impact direction.
  ## The bearing the bullet came FROM reversed = direction from fireOrigin to us at impact.
  ## Without access to the wave origin we use a weight-1 spike at center bin.
  ## TODO: correlate to nearest wave for exact GF if needed.
  let centerBin = VB_BINS div 2
  t.dangerBins[centerBin] += 2.0  # spike center on real hit

proc gfToBin(gf: float): int {.inline.} =
  clamp(int(round((gf.clamp(-1.0, 1.0) + 1.0) * 0.5 * float(VB_BINS - 1))), 0, VB_BINS - 1)

proc mea(speed: float): float {.inline.} = arcsin(min(8.0 / speed, 1.0))

proc advanceBody(b: var VirtualBody, cmd: MoveCommand, arenaW, arenaH: float) =
  ## Single-tick physics: apply MoveCommand, clamp to arena.
  let (targetSpeed, desiredTurn) = cmd
  # maxTurnRate depends on current speed (Tank Royale formula)
  let maxTurn = 10.0 - 0.75 * abs(b.speed)
  b.heading += clamp(desiredTurn, -maxTurn, maxTurn)
  # Speed ramps ±1 toward target, clamped to [-8, 8]
  let tgt = clamp(targetSpeed, -8.0, 8.0)
  if b.speed < tgt:
    b.speed = min(b.speed + 1.0, tgt)
  else:
    b.speed = max(b.speed - 1.0, tgt)
  let headingRad = degToRad(b.heading)
  b.x += b.speed * cos(headingRad)
  b.y += b.speed * sin(headingRad)
  b.x = clamp(b.x, 18.0, arenaW - 18.0)
  b.y = clamp(b.y, 18.0, arenaH - 18.0)

proc tick*[N: static int](t: var VirtualBodyTracker, state: WorldState,
                           cmds: array[N, MoveCommand]) =
  ## Per-tick update. cmds[i] is computeMove() output of module i.
  ## Call AFTER collecting all module commands for this tick.

  # --- Fire detection via gunheat tracker ---
  let waveEvents = t.gunheat.tick(state)
  for ev in waveEvents:
    let bspeed = 20.0 - 3.0 * ev.bulletPower
    let bearingRad = arctan2(state.selfY - ev.fireY, state.selfX - ev.fireX)
    let d = hypot(state.selfX - ev.fireX, state.selfY - ev.fireY)
    let slot = t.waveHead mod MaxWaves
    t.waves[slot] = VBWave(
      fireX:          ev.fireX,
      fireY:          ev.fireY,
      fireBearingRad: bearingRad,
      speed:          bspeed,
      radius:         0.0,
      fireTick:       ev.tick,
      startDist:      d,
    )
    t.waveHead = (t.waveHead + 1) mod MaxWaves
    if t.waveCount < MaxWaves: inc t.waveCount

  # --- Advance virtual bodies ---
  for i in 0..<t.numModules:
    when N > MaxModules:
      {.error: "cmds array exceeds MaxModules".}
    if i < N:
      advanceBody(t.bodies[i], cmds[i], state.arenaWidth, state.arenaHeight)

  # --- Advance our bullets (for shadow tracking) ---
  t.shadows.tick()

  # --- Advance waves and score ---
  # ponytail: O(waves * modules), small counts, fine
  for wi in 0..<t.waveCount:
    let idx = wi mod MaxWaves
    var w = addr t.waves[idx]
    if w.speed <= 0.0: continue
    w.radius += w.speed
    # Compute bullet shadows for this wave once; reuse across all virtual bodies
    let waveShadows = t.shadows.getShadows(w.fireX, w.fireY,
                                           w.fireBearingRad, w.radius, w.speed)
    for mi in 0..<t.numModules:
      let bx = t.bodies[mi].x
      let by = t.bodies[mi].y
      let d = hypot(bx - w.fireX, by - w.fireY)
      # Wave crosses virtual body: within BotRadius of its current position
      if abs(w.radius - d) <= BotRadius:
        let toBotRad = arctan2(by - w.fireY, bx - w.fireX)
        var off = toBotRad - w.fireBearingRad
        while off >  PI: off -= 2.0 * PI
        while off < -PI: off += 2.0 * PI
        let maxA = mea(w.speed)
        if maxA >= 1e-9:
          let gf = clamp(off / maxA, -1.0, 1.0)
          let bin = gfToBin(gf)
          # Shadow zones are guaranteed safe — reduce danger by 90%
          let shadowMul = if isShadowed(waveShadows, gf): 0.1 else: 1.0
          t.dangerScore[mi] += t.dangerBins[bin] * shadowMul

proc bestMovement*(t: VirtualBodyTracker): int =
  ## Returns index of module with lowest accumulated danger score.
  result = 0
  var best = t.dangerScore[0]
  for i in 1..<t.numModules:
    if t.dangerScore[i] < best:
      best = t.dangerScore[i]
      result = i