///|
/// Gauge family indexed by a validated positional label schema.
pub struct GaugeVec {
  descriptor : @metric.Descriptor
  schema : LabelSchema
  children : Map[String, @metric.Gauge]
  lock : @storage.Mutex
}

///|
pub fn GaugeVec::new(
  descriptor : @metric.Descriptor,
  cardinality_limit? : Int,
) -> GaugeVec raise VectorError {
  expect_kind(descriptor, GaugeKind)
  let schema = make_schema(descriptor, cardinality_limit)
  { descriptor, schema, children: Map([]), lock: @storage.Mutex::new() }
}

///|
pub fn GaugeVec::descriptor(self : GaugeVec) -> @metric.Descriptor {
  self.descriptor
}

///|
pub fn GaugeVec::with_label_values(
  self : GaugeVec,
  values : Array[String],
) -> @metric.Gauge raise VectorError {
  let key = self.schema.encode_key(values)
  self.lock.lock()
  defer self.lock.unlock()
  match self.children.get(key) {
    Some(child) => child
    None => {
      ensure_capacity(self.schema.cardinality_limit(), self.children.length())
      let labels = child_labels(self.descriptor, self.schema, values)
      let child = make_gauge_child(self.descriptor, labels)
      self.children[key] = child
      child
    }
  }
}

///|
pub fn GaugeVec::with_labels(
  self : GaugeVec,
  labels : Map[String, String],
) -> @metric.Gauge raise VectorError {
  self.with_label_values(self.schema.values_from_labels(labels))
}

///|
pub fn GaugeVec::delete_label_values(
  self : GaugeVec,
  values : Array[String],
) -> Bool raise VectorError {
  let key = self.schema.encode_key(values)
  self.lock.lock()
  defer self.lock.unlock()
  if !self.children.contains(key) {
    return false
  }
  self.children.remove(key)
  true
}

///|
pub fn GaugeVec::delete_labels(
  self : GaugeVec,
  labels : Map[String, String],
) -> Bool raise VectorError {
  self.delete_label_values(self.schema.values_from_labels(labels))
}

///|
pub fn GaugeVec::reset(self : GaugeVec) -> Int {
  self.lock.lock()
  defer self.lock.unlock()
  let count = self.children.length()
  self.children.clear()
  count
}

///|
pub fn GaugeVec::child_count(self : GaugeVec) -> Int {
  self.lock.lock()
  defer self.lock.unlock()
  self.children.length()
}

///|
pub fn GaugeVec::children(self : GaugeVec) -> Array[@metric.Gauge] {
  self.lock.lock()
  defer self.lock.unlock()
  self.children.values().collect()
}