///|
/// XGBoost stores most scalar parameters as strings, e.g. `"num_class": "3"`.
fn param_int(obj : Src, key : String) -> Int32 raise ModelError {
  let s = obj.field(key).string(key)
  @string.parse_int(s) catch {
    _ => raise InvalidModel("`\{key}` is not an integer: \{s}")
  }
}

///|
/// `base_score` is `"0.5"` in older models and a vector such as `"[5E-1]"`
/// in 3.x, where multiclass models keep one entry per class.
fn parse_base_score(s : String) -> Array[Float] raise ModelError {
  let out = []
  for part in s.trim(chars="[] ").split(",") {
    let d = @string.parse_double(part.trim(chars=" ")) catch {
      _ => raise InvalidModel("bad base_score: \{s}")
    }
    out.push(Float::from_double(d))
  }
  out
}

///|
/// Parse one tree. `weight` scales its leaves (DART's tree weights): XGBoost
/// adds `leaf * weight` rounded to float32, so the scaled leaf is exactly the
/// term it adds.
fn parse_tree(t : Src, weight : Float) -> Tree raise ModelError {
  let left = t.field("left_children").ints("left_children")
  let split_type = t.field("split_type").ints("split_type")
  let categories : Array[Array[Int32]?] = Array::make(left.length(), None)
  if split_type.iter().any(k => k != 0) {
    let cats = t.field("categories").ints("categories")
    let nodes = t.field("categories_nodes").ints("categories_nodes")
    let segs = t.field("categories_segments").ints("categories_segments")
    let sizes = t.field("categories_sizes").ints("categories_sizes")
    if nodes.length() != segs.length() || nodes.length() != sizes.length() {
      raise InvalidModel("categorical split arrays have inconsistent lengths")
    }
    for i, node in nodes {
      let start = segs[i]
      let end = start + sizes[i]
      if node < 0 || node >= left.length() || start < 0 || end > cats.length() {
        raise InvalidModel("categorical split \{i} is out of range")
      }
      categories[node] = Some(cats[start:end].to_owned())
    }
    for i, k in split_type {
      if k != 0 && categories[i] is None {
        raise InvalidModel("node \{i} is categorical but has no categories")
      }
    }
  }
  let value = t.field("split_conditions").floats("split_conditions")
  if value.length() != left.length() {
    raise InvalidModel("tree arrays have inconsistent lengths")
  }
  Tree::new(
    left~,
    right=t.field("right_children").ints("right_children"),
    feature=t.field("split_indices").ints("split_indices"),
    value=if weight == 1.0 {
      value
    } else {
      Array::makei(value.length(), i => {
        if left[i] == -1 {
          value[i] * weight
        } else {
          value[i]
        }
      })
    },
    default_left=t.field("default_left").ints("default_left").map(x => x != 0),
    categories~,
  )
}

///|
/// Load a model saved by XGBoost's `Booster.save_model("model.json")`.
///
/// Supports the `gbtree` booster with numerical and categorical splits, DART
/// models (tree weights, in both the 3.x layout and the older `dart` booster
/// object) and the `gblinear` booster. Categorical features are passed as
/// their integer codes.
pub fn Model::from_xgboost_json(text : StringView) -> Model raise ModelError {
  model_from_src(Src::parse(text))
}

///|
fn model_from_src(root : Src) -> Model raise ModelError {
  let learner = root.field("learner")
  let lmp = learner.field("learner_model_param")
  let num_feature = param_int(lmp, "num_feature")
  let num_class = param_int(lmp, "num_class")
  let base_score = parse_base_score(
    lmp.field("base_score").string("base_score"),
  )
  let objective = Objective::from_name(
    learner.field("objective").field("name").string("objective.name"),
    num_class~,
  )
  let num_group = if num_class > 1 { num_class } else { 1 }
  let gb = learner.field("gradient_booster")
  let booster = gb.field("name").string("gradient_booster.name")
  // optional; anything but an array of strings is ignored as before
  let names = if learner.has("feature_names") {
    learner.field("feature_names").items("feature_names") catch {
      _ => []
    }
  } else {
    []
  }
  let feature_names = names.map(v => v.string("feature_names"))
  if booster == "gblinear" {
    return Model::linear(
      weights=gb.field("model").field("weights").floats("weights"),
      num_group~,
      num_feature~,
      base_score=base_score[0],
      objective~,
      feature_names~,
    )
  }
  // DART: 3.x saves a `gbtree` whose model carries `weight_drop`; older
  // releases save a `dart` booster wrapping the gbtree, weights beside it.
  let (model, weights) = match booster {
    "gbtree" => {
      let model = gb.field("model")
      let w = if model.has("weight_drop") {
        model.field("weight_drop").floats("weight_drop")
      } else {
        []
      }
      (model, w)
    }
    "dart" =>
      (
        gb.field("gbtree").field("model"),
        gb.field("weight_drop").floats("weight_drop"),
      )
    _ => raise Unsupported("booster \{booster}")
  }
  let items = model.field("trees").items("trees")
  if weights.length() > items.length() {
    raise InvalidModel(
      "\{weights.length()} tree weights for \{items.length()} trees",
    )
  }
  let trees = items.mapi((i, t) => {
    parse_tree(t, if i < weights.length() { weights[i] } else { 1.0 })
  })
  let tree_group = model.field("tree_info").ints("tree_info")
  if base_score.length() != 1 && base_score.length() != num_group {
    raise InvalidModel(
      "\{base_score.length()} base scores for \{num_group} groups",
    )
  }
  Model::new(
    trees~,
    tree_group~,
    num_group~,
    num_feature~,
    base_score=base_score[0],
    objective~,
    feature_names~,
    base_scores=if base_score.length() == num_group { base_score } else { [] },
  )
}