# prefs.ludic — `Prefs.*`: named integer preferences persisted as plain text.
#
#   Prefs.load("save/prefs.txt")      read the file if it exists (missing = empty)
#   Prefs.get("best_floor", 0)        an int by name, with a default
#   Prefs.set("best_floor", 3)        set (and remember) a value
#   Prefs.save()                      write every key back as `key=value` lines
#
# Deterministic and dependency-free: one file, up to PREFS_MAX entries.

const PREFS_MAX: int = 64

state PrefsState {
  prefs_path:  pointer  = null
  prefs_names: pointers = pointers(PREFS_MAX)
  prefs_vals:  words    = words(PREFS_MAX)
  prefs_n:     int      = 0
}

namespace Prefs {

  internal function find(prefs_st: PrefsState, key: pointer) -> int {
    var i = 0
    while i < prefs_st.prefs_n { if prefs_st.prefs_names[i] == key { return i };  i += 1 }
    return -1
  }

  export function get(prefs_st: mut PrefsState, key: pointer, fallback: int) -> int {
    let i = find(prefs_st, key)
    if i < 0 { return fallback }
    return prefs_st.prefs_vals[i]
  }

  # keep the larger of the stored value and `value`; true when `value` is a new record
  export function max(prefs_st: mut PrefsState, key: pointer, value: int) -> bool {
    if value <= get(prefs_st, key, 0) { return false }
    set(prefs_st, key, value)
    return true
  }

  export function set(prefs_st: mut PrefsState, key: pointer, value: int) -> void {
    var i = find(prefs_st, key)
    if i < 0 {
      if prefs_st.prefs_n >= PREFS_MAX { return }
      i = prefs_st.prefs_n
      prefs_st.prefs_names[i] = key
      prefs_st.prefs_n += 1
    }
    prefs_st.prefs_vals[i] = value
  }

  # the text of a whole file, or null when it does not exist
  internal function read_all(path: pointer) -> pointer {
    let f = file_open(path, "rb")
    if f == null { return null }
    file_seek(f, 0, 2)
    let size = file_tell(f)
    file_seek(f, 0, 0)
    let buf = bytes(size + 1)
    file_read(f, buf, size)
    file_close(f)
    buf[size] = 0
    return buf
  }

  # digits after `=` on one line -> an int (a leading '-' negates)
  internal function parse_line(prefs_st: mut PrefsState, buf: pointer, from: int, to: int) -> void {
    var eq = from
    while (eq < to) and (buf[eq] != '=') { eq += 1 }          # '='
    if eq >= to { return }
    let key = bytes(eq - from + 1)
    var k = 0
    while k < eq - from { key[k] = buf[from + k];  k += 1 }
    key[eq - from] = 0
    var v = 0
    var neg = false
    var p = eq + 1
    if (p < to) and (buf[p] == '-') { neg = true;  p += 1 }   # '-'
    while (p < to) and (buf[p] >= '0') and (buf[p] <= '9') { v = v * 10 + (buf[p] - 48);  p += 1 }
    if neg { v = -v }
    set(prefs_st, key, v)
  }

  export function load(prefs_st: mut PrefsState, path: pointer) -> void {
    prefs_st.prefs_path = path
    let buf = read_all(path)
    if buf == null { return }
    var start = 0
    var i = 0
    while buf[i] != 0 {
      if buf[i] == '\n' { parse_line(prefs_st, buf, start, i);  start = i + 1 }   # newline
      i += 1
    }
    if i > start { parse_line(prefs_st, buf, start, i) }
  }

  internal function write_text(f: pointer, s: pointer) -> void {
    var n = 0
    while s[n] != 0 { n += 1 }
    file_write(f, s, n)
  }

  export function save(prefs_st: mut PrefsState) -> void {
    if prefs_st.prefs_path == null { return }
    let f = file_open(prefs_st.prefs_path, "wb")
    if f == null { return }
    var i = 0
    while i < prefs_st.prefs_n {
      write_text(f, `{prefs_st.prefs_names[i]}={string(prefs_st.prefs_vals[i])}\n`)
      i += 1
    }
    file_close(f)
  }
}