# tracks_test.ludic - prints go into a ring per kind and are drawn through the hook, they age on
# the world's clock, the nearest is found, a read is a fact every time and a count once, and the
# reader's state saves
import "ludic.tracks"
import "ludic.base"
program TracksTest {
  numbers float
  state TracksTestState {
    now: float = 0.0
    skill: int = 1
    placed_n: int = 0
    placed_last: int = -1
  }

  function fake_now(tracks_test_st: TracksTestState) -> float { return tracks_test_st.now }
  function fake_skill(tracks_test_st: TracksTestState) -> int { return tracks_test_st.skill }
  function fake_bearing(yaw: float) -> string {
    if yaw > 0.0 { return "east" }
    return "west"
  }
  function fake_placed(tracks_test_st: mut TracksTestState, kind: int, i: int) -> void {
    tracks_test_st.placed_n += 1
    tracks_test_st.placed_last = i
  }

  bind TracksWorld { now: fn fake_now, skill: fn fake_skill, bearing: fn fake_bearing, placed: fn fake_placed }

  function fresh(tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) -> void {
    tracks_test_st.now = 10.0
    tracks_test_st.skill = 1
    tracks_test_st.placed_n = 0
    tracks_test_st.placed_last = -1
    tracks_config(tracks_st, 3, 4)
    tracks_config_reading(tracks_st, 1, 0.5, 2.5)
    tracks_reset(tracks_st)
  }

  function reads(tracks_st: TracksState) -> []TrackRead { return q_drain(tracks_reads(tracks_st)) }

  test "a print goes into its kind's ring and is drawn" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    let i = tracks_leave(tracks_st, 1, 5.0, 6.0, 1.0, 7, false, -1)
    expect_eq(i, 0)
    expect_eq(tracks_count(tracks_st, 1), 1)
    expect_eq(tracks_count(tracks_st, 0), 0)
    expect_eq(tracks_test_st.placed_n, 1)
    let s = tracks_slot(tracks_st, 1, 0)
    expect(tracks_x(tracks_st, s) == 5.0 and tracks_z(tracks_st, s) == 6.0)
    expect_eq(tracks_sp(tracks_st, s), 7)
  }

  test "a full ring writes over its oldest print" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    for n in 0 .. 5 { tracks_leave(tracks_st, 2, float(n), 0.0, 0.0, n, false, -1) }
    expect_eq(tracks_count(tracks_st, 2), 4)
    expect_eq(tracks_test_st.placed_last, 0)
    expect_eq(tracks_sp(tracks_st, tracks_slot(tracks_st, 2, 0)), 4)
  }

  test "a print ages on the world's clock" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 1, false, -1)
    tracks_test_st.now = 13.0
    let s = tracks_slot(tracks_st, 1, 0)
    expect(tracks_age(tracks_st, s) == 3.0)
    expect_eq(tracks_fresh_of(tracks_st, tracks_age(tracks_st, s)), TRACK_OLD)
    expect_eq(tracks_fresh_of(tracks_st, 0.2), TRACK_FRESH)
    expect_eq(tracks_fresh_of(tracks_st, 1.0), TRACK_RECENT)
  }

  test "the nearest print within reach, or none" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    tracks_leave(tracks_st, 1, 10.0, 0.0, 0.0, 1, false, -1)
    tracks_leave(tracks_st, 2, 1.0, 1.0, 0.0, 2, false, -1)
    expect_eq(tracks_nearest(tracks_st, 0.0, 0.0, 2.0), tracks_slot(tracks_st, 2, 0))
    expect_eq(tracks_nearest(tracks_st, 50.0, 50.0, 2.0), -1)
  }

  test "a print read twice is two facts and one count" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    tracks_leave(tracks_st, 1, 0.0, 0.0, 1.0, 3, true, -1)
    let s = tracks_nearest(tracks_st, 0.0, 0.0, 2.0)
    tracks_read(tracks_st, s)
    tracks_read(tracks_st, s)
    let rs = reads(tracks_st)
    expect_eq(len(rs), 2)
    expect(rs[0].first and not rs[1].first)
    expect_eq(rs[0].source, TRACK_PRINT)
    expect_eq(rs[0].kind, 1)
    expect(rs[0].legend)
    expect(rs[0].bearing == "east")
    expect_eq(tracks_read_count(tracks_st), 1)
    expect(tracks_has_bearing(tracks_st) and tracks_last_yaw(tracks_st) == 1.0)
  }

  test "a reader without the skill cannot name the animal" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    tracks_test_st.skill = 0
    tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 3, false, -1)
    tracks_read(tracks_st, tracks_slot(tracks_st, 1, 0))
    expect(not reads(tracks_st)[0].named)
  }

  test "a sign that is not a print is told, and counts when it is the first" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    tracks_note(tracks_st, 4, TRACK_SCAT, false, -1.0, true)
    tracks_note(tracks_st, 4, TRACK_SCAT, false, -1.0, false)
    let rs = reads(tracks_st)
    expect_eq(len(rs), 2)
    expect_eq(rs[0].source, TRACK_SCAT)
    expect_eq(tracks_read_count(tracks_st), 1)
  }

  test "a written-over slot is a new, unread print" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    tracks_leave(tracks_st, 0, 0.0, 0.0, 0.0, 1, false, -1)
    tracks_read(tracks_st, tracks_slot(tracks_st, 0, 0))
    for n in 0 .. 4 { tracks_leave(tracks_st, 0, 0.0, 0.0, 0.0, 2, false, -1) }
    expect(not tracks_was_read(tracks_st, tracks_slot(tracks_st, 0, 0)))
  }

  test "clearing the ground forgets the prints, not the reader" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 1, false, -1)
    tracks_read(tracks_st, tracks_slot(tracks_st, 1, 0))
    tracks_clear(tracks_st)
    expect_eq(tracks_count(tracks_st, 1), 0)
    expect_eq(tracks_read_count(tracks_st), 1)
  }

  test "a save section reads back the same reader" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
    fresh(tracks_st, tracks_test_st)
    tracks_note(tracks_st, 1, TRACK_SIGN, true, 0.0, true)
    tracks_note_bearing(tracks_st, 2.5)
    let root = save_tree()
    save_section(root, "tracks", 1, tracks_save(tracks_st))
    let text = save_encode(root)
    tracks_reset(tracks_st)
    let n = load_section(save_decode(text), "tracks")
    tracks_load(tracks_st, n.data, n.version)
    expect_eq(tracks_read_count(tracks_st), 1)
    expect(tracks_has_bearing(tracks_st) and tracks_last_yaw(tracks_st) == 2.5)
  }
}