# tpl.ludic - a template file read into what the builder walks: every attribute and every
# element's text an expression, every on-* attribute an action. A file holds <component>s and
# <screen>s under one root; a component is used as a tag of its own name anywhere after.
export property UiTpl {
  tag: string = ""
  keys: []string = null
  vals: []UiExpr = null
  on_keys: []string = null
  on_acts: []UiAct = null
  text: UiExpr = null
  kids: []UiTpl = null
  comp: UiTpl = null            # the component this tag names, found when its file loads
  cls: UiClass = null           # or the Ludic-declared component it names
  sheet: UiSheet = null         # the styles of the file it was written in
  style: UiRule = null          # its style="..." attribute, read as declarations
  raw: string = ""              # a <style>'s text, which is not a template's
  where: string = ""            # file:line, for an error
}
@alloc_ok("a template being read: once per component class (uc_load)")
function tpl_read(ui_st: mut UiState, x: Xml, file: string) -> UiTpl {
  let t = new UiTpl
  t.tag = Xml.tag(x)
  t.keys = new []string
  t.vals = new []UiExpr
  t.on_keys = new []string
  t.on_acts = new []UiAct
  t.kids = new []UiTpl
  t.where = `{file}:{tp_line(ui_st, x.at)}`
  let err = new []string
  for i in 0 .. len(x.akeys) {
    let k: string = x.akeys[i]
    let v: string = x.avals[i]
    if len(k) > 3 and sat(k, 0, "on-") {
      push(t.on_keys, tpl_event(k[3..len(k)]))
      push(t.on_acts, act_parse(v, err))
    } else if k == "onclick" {
      push(t.on_keys, "press")
      push(t.on_acts, act_parse(v, err))
    } else if k == "style" { t.style = lss_decls(v, err) } else {
      push(t.keys, k)
      push(t.vals, tpl_value(v, err))
    }
    # the value is parsed (an action, a style, an expression), each copying what it keeps; an
    # empty one is the reader's own literal
    if len(v) > 0 { unsafe { free(v) } }
  }
  if tp_mixed(x) { tp_read_mixed(ui_st, t, x, file, err) } else {
    for i in 0 .. Xml.child_count(x) { push(t.kids, tpl_read(ui_st, Xml.child(x, i), file)) }
  }
  if t.tag == "style" {
    t.raw = Xml.text(x)
    return t
  }
  let words = tpl_words(Xml.text(x))
  if len(words) > 0 and Xml.child_count(x) == 0 { t.text = ex_text(words, err) }
  @alloc_ok("only when a template is wrong: a broken screen, never a working one")
  for i in 0 .. len(err) { ui_err(ui_st, `{t.where}: <{t.tag}> {err[i]}`) }
  return t
}
# on-click is on-press, as a browser would have it
function tpl_event(name: string) -> string {
  if name == "click" { return "press" }
  return name
}
# an attribute: a plain number is a number, anything else text with {holes}
function tpl_value(v: string, err: []string) -> UiExpr {
  var num = len(v) > 0
  for i in 0 .. len(v) {
    if not ((v[i] >= 48 and v[i] <= 57) or v[i] == 46 or (i == 0 and v[i] == 45)) { num = false }
  }
  if num { return ex_parse(v, err) }
  return ex_text(v, err)
}
# text as a reader sees it: the ends trimmed and every run of white space one space
@alloc_ok("a memo miss (tw) or a template being read: once per text")
function tpl_words(s: string) -> string {
  if tpl_clean(s) { return s }
  # written once into bytes of its own, as a TextRing slot is: a text built a character at a time
  # left a string behind for every character
  var p: pointer = null
  unsafe { p = bytes(len(s) + 1) }
  var n = 0
  var gap = false
  for i in 0 .. len(s) {
    let c = s[i]
    if c == 32 or c == 9 or c == 10 or c == 13 { gap = n > 0 } else {
      unsafe {
        if gap {
          p[n] = 32
          n += 1
        }
        p[n] = c
      }
      n += 1
      gap = false
    }
  }
  unsafe { p[n] = 0 }
  return p
}
function tpl_attr(t: UiTpl, key: string) -> UiExpr {
  for i in 0 .. len(t.keys) {
    if t.keys[i] == key { return t.vals[i] }
  }
  return null
}
# no space at either end, no two together, no tab or line break: tpl_words would give it back as is
function tpl_clean(s: string) -> bool {
  let n = len(s)
  if n == 0 { return true }
  if s[0] == 32 or s[n - 1] == 32 { return false }
  for i in 0 .. n {
    let c = s[i]
    if c == 9 or c == 10 or c == 13 { return false }
    if c == 32 and s[i + 1] == 32 { return false }
  }
  return true
}