## Guess-factor gun: statistical targeting via GF histogram.
## Bins: 31, ranging GF -1 (max CW escape) to +1 (max CCW escape).
## Learns from virtual bullet outcomes; caches wave state per-tick.

import std/math
import gun_harness/gun_interface

const
  GFBins  = 31
  GFPrior = 0.1

type
  Wave = object
    fireX, fireY: float
    fireBearing:  float  # atan2(enemyY-selfY, enemyX-selfX) at fire tick (rad)
    mea:          float  # max escape angle (rad)

  GFGun* = object
    bins:        array[GFBins, float]
    waves:       seq[Wave]         # pending unresolved waves
    # per-tick cache: store wave only once across multiple power-bin calls
    cachedTick:  int
    cachedWaveStored: bool

proc initGFGun*(): GFGun =
  result.cachedTick = -1
  for i in 0..<GFBins:
    result.bins[i] = GFPrior

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

proc indexToGF(idx: int): float {.inline.} =
  float(idx) / float(GFBins - 1) * 2.0 - 1.0

proc peakBin(g: GFGun): int =
  var best = 0
  for i in 1..<GFBins:
    if g.bins[i] > g.bins[best]:
      best = i
  best

proc predict*(g: var GFGun, state: WorldState, bulletSpeed: float): GunPrediction =
  if bulletSpeed <= 0.0:
    return GunPrediction(x: state.enemyX, y: state.enemyY)

  let dx = state.enemyX - state.selfX
  let dy = state.enemyY - state.selfY
  let dist   = sqrt(dx*dx + dy*dy)
  let bearing = arctan2(dy, dx)
  let mea    = arcsin(clamp(8.0 / bulletSpeed, -1.0, 1.0))

  # Store one wave per tick regardless of how many power bins call us
  if state.tick != g.cachedTick:
    g.cachedTick = state.tick
    g.cachedWaveStored = false

  if not g.cachedWaveStored:
    g.waves.add Wave(
      fireX:       state.selfX,
      fireY:       state.selfY,
      fireBearing: bearing,
      mea:         mea,
    )
    g.cachedWaveStored = true

  let gfAngle = bearing + indexToGF(g.peakBin()) * mea
  # Aim from self at gfAngle, at current dist (angular targeting)
  let px = state.selfX + cos(gfAngle) * dist
  let py = state.selfY + sin(gfAngle) * dist

  GunPrediction(
    x: clamp(px, BotRadius, state.arenaWidth  - BotRadius),
    y: clamp(py, BotRadius, state.arenaHeight - BotRadius),
  )

proc onResult*(g: var GFGun, e: FeedbackEvent) =
  ## Called when a virtual bullet resolves. Match the wave by predicted point,
  ## compute actual GF, and increment the histogram with a smoothing kernel.
  ## We don't have the original wave tick here, so we use the prediction coords
  ## to identify and remove the matching wave.
  ## ponytail: O(n) scan over waves; waves list stays tiny (< a dozen at a time)
  if g.waves.len == 0:
    return

  # Pop the oldest wave (FIFO matches bullet resolution order)
  let w = g.waves[0]
  g.waves.delete(0)

  # Compute actual bearing from fire position to where the enemy actually was
  let actualDx = e.actualX - w.fireX
  let actualDy = e.actualY - w.fireY
  let actualBearing = arctan2(actualDy, actualDx)
  var bearingDelta = actualBearing - w.fireBearing
  # Normalize to [-PI, PI]
  while bearingDelta >  PI: bearingDelta -= 2.0*PI
  while bearingDelta < -PI: bearingDelta += 2.0*PI

  let gf = if w.mea > 1e-10: clamp(bearingDelta / w.mea, -1.0, 1.0) else: 0.0
  let centerIdx = gfToIndex(gf)

  # Triangular smoothing kernel over adjacent bins
  for i in 0..<GFBins:
    let dist = abs(i - centerIdx)
    g.bins[i] += 1.0 / float(1 + dist)