// 指令参数(CP)数据区。
//
// 标准约定:字段名与字段值用 `=` 连接;同一项的不同取值用 `,` 分隔;
// 不同项之间用 `;` 分隔;整个数据区外面套一层 `&& ... &&`。
//
// 解析必须容忍现场设备的写法差异:空格、末尾多余的分号、缺失的 `&&`。
// 但序列化一律输出规范形式,因此「解码再编码」是一步归一化,而不是原样回吐。

///|
pub fn DataArea::new() -> DataArea {
  { items: [], }
}

///|
/// 解析数据区文本。
///
/// 接受带 `&&...&&` 包装的形式,也接受裸数据区(便于单独测试数据区)。
pub fn DataArea::parse(text : String) -> Result[DataArea, DecodeError] {
  let mut cs = trim_chars(chars_of(text))
  // 标准 6.3.2 规定指令参数 CP 的取值是 `&&数据区&&`。没有这层包装说明
  // 对方用的不是 HJ 212 的数据区格式,宁可报错也不要猜。
  if cs.length() < 2 || cs[0] != '&' || cs[1] != '&' {
    return Err(BadDataArea("数据区必须以 \"&&\" 开头"))
  }
  let close = find_seq(cs, "&&", 2)
  if close < 0 {
    return Err(BadDataArea("以 \"&&\" 开头但没有结束的 \"&&\""))
  }
  let mut tail = close + 2
  while tail < cs.length() {
    if !is_space_char(cs[tail]) {
      return Err(TrailingGarbage(slice_chars(cs, tail, cs.length())))
    }
    tail = tail + 1
  }
  cs = trim_chars(chars_slice(cs, 2, close))
  let items : Array[DataItem] = []
  if cs.length() == 0 {
    return Ok({ items, })
  }
  let mut start = 0
  let mut i = 0
  while i <= cs.length() {
    let at_end = i == cs.length()
    if at_end || cs[i] == ';' {
      let piece = trim_chars(chars_slice(cs, start, i))
      if piece.length() > 0 {
        match parse_item(piece) {
          Ok(item) => items.push(item)
          Err(e) => return Err(e)
        }
      }
      start = i + 1
    }
    i = i + 1
  }
  Ok({ items, })
}

///|
/// 解析单个 `名称=值[,值...]`。
fn parse_item(cs : Array[Char]) -> Result[DataItem, DecodeError] {
  let eq = find_char(cs, '=', 0)
  if eq < 0 {
    return Err(BadField(slice_chars(cs, 0, cs.length())))
  }
  let name = trim_text(slice_chars(cs, 0, eq))
  if name == "" {
    return Err(BadDataArea("出现空的字段名"))
  }
  if !is_valid_field_name(name) {
    return Err(BadDataArea("字段名 \"\{name}\" 含非法字符"))
  }
  let vcs = trim_chars(chars_slice(cs, eq + 1, cs.length()))
  let values : Array[String] = []
  let mut start = 0
  let mut i = 0
  while i <= vcs.length() {
    let at_end = i == vcs.length()
    if at_end || vcs[i] == ',' {
      values.push(trim_text(slice_chars(vcs, start, i)))
      start = i + 1
    }
    i = i + 1
  }
  Ok({ name, values, })
}

///|
fn find_char(cs : Array[Char], target : Char, from : Int32) -> Int32 {
  let mut i = from
  while i < cs.length() {
    if cs[i] == target {
      return i
    }
    i = i + 1
  }
  -1
}

///|
/// 字段名只允许字母、数字、下划线与连字符(如 `Data-Flag`)。
fn is_valid_field_name(name : String) -> Bool {
  if name == "" {
    return false
  }
  for c in name {
    let ok = (c >= 'A' && c <= 'Z') ||
      (c >= 'a' && c <= 'z') ||
      (c >= '0' && c <= '9') ||
      c == '_' ||
      c == '-'
    if !ok {
      return false
    }
  }
  true
}

///|
/// 渲染成规范形式(不含 `&&` 包装)。
pub fn DataArea::text(self : DataArea) -> String {
  let sb = StringBuilder()
  let mut i = 0
  while i < self.items.length() {
    if i > 0 {
      sb.write_char(';')
    }
    let item = self.items[i]
    sb.write_string(item.name)
    sb.write_char('=')
    let mut j = 0
    while j < item.values.length() {
      if j > 0 {
        sb.write_char(',')
      }
      sb.write_string(item.values[j])
      j = j + 1
    }
    i = i + 1
  }
  sb.to_string()
}

///|
/// 渲染成报文里的 `CP` 取值,带 `&&` 包装。
pub fn DataArea::wrapped_text(self : DataArea) -> String {
  "&&\{self.text()}&&"
}

///|
/// 取某个字段的第一个值。
pub fn DataArea::get(self : DataArea, name : String) -> String? {
  let mut i = 0
  while i < self.items.length() {
    if self.items[i].name == name {
      let values = self.items[i].values
      if values.length() > 0 {
        return Some(values[0])
      }
      return Some("")
    }
    i = i + 1
  }
  None
}

///|
/// 取某个字段的全部值。
pub fn DataArea::get_all(self : DataArea, name : String) -> Array[String] {
  let out : Array[String] = []
  let mut i = 0
  while i < self.items.length() {
    if self.items[i].name == name {
      for v in self.items[i].values {
        out.push(v)
      }
    }
    i = i + 1
  }
  out
}

///|
/// 字段是否出现。
pub fn DataArea::has(self : DataArea, name : String) -> Bool {
  match self.get(name) {
    Some(_) => true
    None => false
  }
}

///|
/// 取某个字段的值,不存在时返回给定的默认值。
pub fn DataArea::get_or(
  self : DataArea,
  name : String,
  fallback : String,
) -> String {
  match self.get(name) {
    Some(v) => v
    None => fallback
  }
}

///|
/// 把字段值当整数读。
///
/// 常见于 `RtdInterval`、`Flag` 一类整数字段。返回 `None` 有两种情况:
/// 字段不存在,或者取值不是整数——包括标准里用 `N` / `U` 表示
/// 「无有效数据」的那种写法,此时上层应当按缺失处理而不是当成 0。
pub fn DataArea::get_int(self : DataArea, name : String) -> Int32? {
  match self.get(name) {
    Some(v) => parse_int_text(v)
    None => None
  }
}

///|
/// 把字段值当浮点数读。
///
/// 监测值形如 `1.52`、`-3.00`、`0`;无有效数据时现场会写 `N`,此时返回
/// `None`。不接受科学计数法——标准里的数值类型(`N14.2` 等)没有这种写法,
/// 放进来只会掩盖「对方发的不是这个字段」的问题。
pub fn DataArea::get_float(self : DataArea, name : String) -> Double? {
  match self.get(name) {
    Some(v) => parse_float_text(v)
    None => None
  }
}

///|
/// 删除某个字段,返回是否真的删掉了。
pub fn DataArea::remove(self : DataArea, name : String) -> Bool {
  let mut i = 0
  while i < self.items.length() {
    if self.items[i].name == name {
      let _ = self.items.remove(i)
      return true
    }
    i = i + 1
  }
  false
}

///|
/// 解析带符号整数。允许前导 `+` / `-`,不允许小数点。
fn parse_int_text(text : String) -> Int32? {
  let cs = trim_chars(chars_of(text))
  if cs.length() == 0 {
    return None
  }
  let mut i = 0
  let mut negative = false
  if cs[0] == '-' {
    negative = true
    i = 1
  } else if cs[0] == '+' {
    i = 1
  }
  if i >= cs.length() {
    return None
  }
  let mut value : Int32 = 0
  while i < cs.length() {
    if !is_digit_char(cs[i]) {
      return None
    }
    value = value * 10 + (cs[i].to_int() - 48)
    i = i + 1
  }
  if negative {
    Some(-value)
  } else {
    Some(value)
  }
}

///|
/// 解析十进制小数,形如 `-12.34`、`0`、`.5`、`5.`。
///
/// 手写而不是转调标准库的浮点解析:核心库要保持零依赖,而这个格式
/// (可选符号 + 数字 + 可选小数点 + 数字)用不着通用解析器。
fn parse_float_text(text : String) -> Double? {
  let cs = trim_chars(chars_of(text))
  if cs.length() == 0 {
    return None
  }
  let mut i = 0
  let mut sign = 1.0
  if cs[0] == '-' {
    sign = -1.0
    i = 1
  } else if cs[0] == '+' {
    i = 1
  }
  let mut int_part = 0.0
  let mut digits = 0
  while i < cs.length() && is_digit_char(cs[i]) {
    int_part = int_part * 10.0 + (cs[i].to_int() - 48).to_double()
    i = i + 1
    digits = digits + 1
  }
  let mut frac = 0.0
  let mut scale = 1.0
  if i < cs.length() && cs[i] == '.' {
    i = i + 1
    while i < cs.length() && is_digit_char(cs[i]) {
      frac = frac * 10.0 + (cs[i].to_int() - 48).to_double()
      scale = scale * 10.0
      i = i + 1
      digits = digits + 1
    }
  }
  // 一个数字都没有(如 ""、"-"、".")算解析失败;
  // 还有剩余字符(如 "1.2.3"、"12a")也算失败,不做「读到哪算哪」的容错。
  if digits == 0 || i != cs.length() {
    return None
  }
  Some(sign * (int_part + frac / scale))
}

///|
/// 追加或覆盖一个单值字段。
pub fn DataArea::set(self : DataArea, name : String, value : String) -> Unit {
  self.set_values(name, [value])
}

///|
/// 追加或覆盖一个多值字段。
pub fn DataArea::set_values(
  self : DataArea,
  name : String,
  values : Array[String],
) -> Unit {
  let mut i = 0
  while i < self.items.length() {
    if self.items[i].name == name {
      self.items[i].values = values
      return
    }
    i = i + 1
  }
  self.items.push({ name, values, })
}

///|
/// 字段个数。
pub fn DataArea::length(self : DataArea) -> Int32 {
  self.items.length()
}