# read.ludic - reading the ground. A print is read once: reading it again says the same thing
# and counts nothing, so pressing a key over one print is not as good as walking a trail.
export function tracks_fresh_of(tracks_st: TracksState, age: float) -> int {
  if age > tracks_st.tk_recent_h { return TRACK_OLD }
  if age > tracks_st.tk_fresh_h { return TRACK_RECENT }
  return TRACK_FRESH
}

function tk_push(tracks_st: mut TracksState, f: TrackRead) -> void {
  if f.first { tracks_st.tk_read_n += 1 }
  q_push(tracks_reads(tracks_st), f)
}

# read the print at a slot (tracks_nearest's answer): a fact every time, a count the first time
export function tracks_read(tracks_st: mut TracksState, slot: int) -> void {
  if slot < 0 or tracks_st.tk_ring == null or slot >= len(tracks_st.tk_ring) { return }
  let t = tracks_st.tk_ring[slot]
  let f = tk_rec(tracks_st)
  f.sp = t.sp
  f.source = TRACK_PRINT
  f.kind = slot / tracks_st.tk_cap
  f.legend = t.legend
  f.age = tracks_age(tracks_st, slot)
  f.fresh = tracks_fresh_of(tracks_st, f.age)
  f.yaw = t.yaw
  f.named = tk_named(tracks_st)
  f.bearing = tk_bearing(t.yaw)
  f.first = not t.read
  t.read = true
  tracks_note_bearing(tracks_st, t.yaw)
  tk_chain_read(tracks_st, t)
  tk_push(tracks_st, f)
}

# a sign that is not a print (droppings, a legend's mark): the caller knows whether it is the
# first reading of it
export function tracks_note(tracks_st: mut TracksState, sp: int, source: int, legend: bool, yaw: float, first: bool) -> void {
  let f = tk_rec(tracks_st)
  f.sp = sp
  f.source = source
  f.legend = legend
  f.yaw = yaw
  f.named = tk_named(tracks_st)
  f.bearing = tk_bearing(yaw)
  f.first = first
  tk_push(tracks_st, f)
}

# the way the last thing read went (a bed, droppings, a print)
export function tracks_note_bearing(tracks_st: mut TracksState, yaw: float) -> void {
  tracks_st.tk_yaw = yaw
  tracks_st.tk_has_yaw = true
}

export function tracks_set_read_count(tracks_st: mut TracksState, n: int) -> void { tracks_st.tk_read_n = n }

# a reading's record from the queue's ring (ludic.base's q_rec), every field back to its default
function tk_rec(tracks_st: mut TracksState) -> TrackRead {
  var f = q_rec(tracks_reads(tracks_st))
  if f == null {
    @alloc_ok("past the ring: more readings in a frame than its records, then kept in it")
    f = new TrackRead
    q_ring_add(tracks_reads(tracks_st), f)
  }
  f.kind = 0
  f.age = 0.0
  f.fresh = 0
  f.named = true
  f.bearing = ""
  return f
}