#Rolling log files

///|
import {
  "moonrockz/moon-lander-logging/formatting",
  "moonrockz/moon-lander-logging/rolling",
}

#Settings

#File names

///|
test "the file set owns only its exact names" {
  let stem = @rolling.LogFileStem::parse("acme")
  let set = @rolling.FileSet::new(stem, Text, @rolling.RollingPolicy::default())
  assert_true(set.parse_name("acme-20261027_001.log") is Some(_))
  assert_true(set.parse_name("acme-old.log") is None)
  assert_true(set.parse_name("acme-20261027.log.bak") is None)
  assert_true(set.parse_name("acme-20261027.jsonl") is None)
  assert_eq(set.marker_name(), "acme.log.lock")
  assert_true(set.parse_name(set.marker_name()) is None)
}

#Plan each record

• The size is the UTF-8 bytes of the rendered record, including its LF and its error lines.
• A nonempty file rolls before a record that does not fit. An exact fit appends.
• An empty file takes a record larger than the limit, and the next record rolls. A record never splits across files.
• A daily policy rolls at the first record of a later UTC day. That plan reads the listing, as at a restart, so a file of the new day from an earlier run is appended to when it has room. needs_listing(now) tells the adapter when to list the directory. When the clock moves back, the writer stays in the day of the active file.
• Size does not roll at a new day. Daily does not roll at any size.
• At the first open, the plan reads the directory listing. It appends to the newest owned regular file of the current period when that file has room, and else it opens the next sequence number.

///|
test "a day with two size rolls" {
  let stem = @rolling.LogFileStem::parse("acme")
  let limit = @rolling.FileByteLimit::bytes(100L)
  let set = @rolling.FileSet::new(stem, JsonLines, DailyAndSize(limit))
  let now = @formatting.LogTimestamp::from_epoch_millis(1793110987024L)
  let mut state = @rolling.RollingState::new(set)
  let names = []
  for size in [60L, 40L, 1L, 99L, 1L] {
    let bytes = @rolling.ByteCount::of(size)
    let plan = state.plan(now, bytes, [])
    match plan {
      Append(name) => names.push("append \{name}")
      Open(name, existing_size~) => {
        state = state.opened(name, existing_size)
        names.push("open \{name}")
      }
      Roll(name, existing_size~) => {
        state = state.opened(name, existing_size)
        names.push("roll \{name}")
      }
    }
    state = state.wrote(bytes)
  }
  inspect(names.join("\n"), content=(
    #|open acme-20261027.jsonl
    #|append acme-20261027.jsonl
    #|roll acme-20261027_001.jsonl
    #|append acme-20261027_001.jsonl
    #|roll acme-20261027_002.jsonl
  ))
}

///|
test "a restart appends to the newest file of the day" {
  let stem = @rolling.LogFileStem::parse("acme")
  let set = @rolling.FileSet::new(stem, Text, @rolling.RollingPolicy::default())
  let now = @formatting.LogTimestamp::from_epoch_millis(1793110987024L)
  let listing : Array[@rolling.ListedFile] = [
    { name: "acme-20261027.log", size: @rolling.ByteCount::of(10485760L), regular: true },
    { name: "acme-20261027_001.log", size: @rolling.ByteCount::of(2048L), regular: true },
    { name: "acme.log.lock", size: @rolling.ByteCount::zero(), regular: true },
  ]
  let plan = @rolling.RollingState::new(set).plan(
    now,
    @rolling.ByteCount::of(120L),
    listing,
  )
  guard plan is Open(name, existing_size~) else { fail("no open plan") }
  assert_eq(name.to_string(), "acme-20261027_001.log")
  assert_eq(existing_size.to_int64(), 2048L)
}

#Retention

///|
test "keep the newest three files" {
  let stem = @rolling.LogFileStem::parse("acme")
  let set = @rolling.FileSet::new(stem, Text, Daily)
  let names = [
    "acme-20261024.log", "acme-20261025.log", "acme-20261026.log", "acme-20261027.log",
    "acme-20261027.log.bak",
  ]
  let listing = names.map(name => @rolling.ListedFile::{
    name,
    size: @rolling.ByteCount::of(1L),
    regular: true,
  })
  guard set.parse_name("acme-20261027.log") is Some(active) else {
    fail("not owned")
  }
  let retention = @rolling.Retention::KeepNewest(
    @rolling.RetainedFileCount::count(3),
  )
  assert_eq(set.retention(retention, listing, active).map(name => name.to_string()), ["acme-20261024.log"])
}