///|
/// Pipe-separated records, comma-separated lists, key=value defaults.
/// Shared groups are parsed once; element rules (and the attribute group
/// defaults they use) are kept as raw records and expanded on demand.
priv struct SvgTables {
  attr_groups : Map[String, Array[String]]
  group_defaults : Map[String, String]
  content_groups : Map[String, Array[String]]
  elements : Map[String, String]
  expanded : Map[String, SvgElementTables]
  known_elements : Set[String]
  presentation_non_inheritable : Set[String]
  inheritable : Set[String]
  path_elems : Set[String]
  references_props : Set[String]
  /// group name -> `safe|unsafe` attribute lists
  deprecated_groups : Map[String, String]
}

///|
priv struct SvgElementTables {
  allowed_attrs : Set[String]
  defaults : Map[String, String]
  allowed_children : Set[String]
  deprecated_safe : Set[String]
  deprecated_unsafe : Set[String]
}

///|
let svg_tables_cache : Ref[SvgTables?] = { val: None, }

///|
fn table_list(raw : StringView) -> Array[String] {
  raw.split(",").filter(s => !s.is_empty()).map(s => s.to_owned()).to_array()
}

///|
fn table_pairs(raw : StringView) -> Map[String, String] {
  let values : Map[String, String] = Map([])
  for entry in raw.split(",") {
    if entry.to_owned().split_once("=") is Some((key, value)) {
      values[key.to_owned()] = value.to_owned()
    }
  }
  values
}

///|
fn table_groups(raw : String) -> Map[String, Array[String]] {
  let groups : Map[String, Array[String]] = Map([])
  for row in raw.split("\n") {
    if row.to_owned().split_once("|") is Some((name, values)) {
      groups[name.to_owned()] = table_list(values)
    }
  }
  groups
}

///|
fn svg_tables() -> SvgTables {
  if svg_tables_cache.val is Some(tables) {
    return tables
  }
  let group_defaults : Map[String, String] = Map([])
  for row in svg_attr_defaults_data.split("\n") {
    if row.to_owned().split_once("|") is Some((name, values)) {
      group_defaults[name.to_owned()] = values.to_owned()
    }
  }
  let tables : SvgTables = {
    attr_groups: table_groups(svg_attr_groups_data),
    group_defaults,
    content_groups: table_groups(svg_content_groups_data),
    elements: Map([]),
    expanded: Map([]),
    known_elements: Set([]),
    presentation_non_inheritable: Set::from_array(
      table_list(svg_non_inheritable_data[:]),
    ),
    inheritable: Set::from_array(table_list(svg_inheritable_data[:])),
    path_elems: Set::from_array(table_list(svg_path_elems_data[:])),
    references_props: Set::from_array(table_list(svg_references_props_data[:])),
    deprecated_groups: Map([]),
  }
  for row in svg_deprecated_groups_data.split("\n") {
    if row.to_owned().split_once("|") is Some((name, lists)) {
      tables.deprecated_groups[name.to_owned()] = lists.to_owned()
    }
  }
  for row in svg_elements_data.split("\n") {
    if row.to_owned().split_once("|") is Some((name, _)) {
      let name = name.to_owned()
      tables.elements[name] = row.to_owned()
      tables.known_elements.add(name)
    }
  }
  svg_tables_cache.val = Some(tables)
  tables
}

///|
fn SvgTables::element(self : SvgTables, name : String) -> SvgElementTables? {
  if self.expanded.get(name) is Some(element) {
    return Some(element)
  }
  guard self.elements.get(name) is Some(row) else { return None }
  let fields = row.split("|").to_array()
  let attrs = Set::from_array(table_list(fields[2]))
  let defaults = table_pairs(fields[3])
  // Preserve the previous generator's precedence: own defaults first,
  // then each attribute group's defaults in upstream declaration order.
  for group in table_list(fields[1]) {
    if self.attr_groups.get(group) is Some(values) {
      for value in values {
        attrs.add(value)
      }
    }
    if self.group_defaults.get(group) is Some(values) {
      for key, value in table_pairs(values) {
        defaults[key] = value
      }
    }
  }
  let children = Set::from_array(table_list(fields[5]))
  for group in table_list(fields[4]) {
    if self.content_groups.get(group) is Some(values) {
      for value in values {
        children.add(value)
      }
    }
  }
  let deprecated_safe = if fields.length() > 6 {
    Set::from_array(table_list(fields[6]))
  } else {
    Set([])
  }
  let deprecated_unsafe = if fields.length() > 7 {
    Set::from_array(table_list(fields[7]))
  } else {
    Set([])
  }
  // merge group-level deprecated attributes into the element's sets
  for group in table_list(fields[1]) {
    if self.deprecated_groups.get(group) is Some(lists) &&
      lists.split_once("|") is Some((safe, unsafe_attrs)) {
      for name in table_list(safe) {
        deprecated_safe.add(name)
      }
      for name in table_list(unsafe_attrs) {
        deprecated_unsafe.add(name)
      }
    }
  }
  let element : SvgElementTables = {
    allowed_attrs: attrs,
    defaults,
    allowed_children: children,
    deprecated_safe,
    deprecated_unsafe,
  }
  self.expanded[name] = element
  Some(element)
}