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

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

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

///|
pub fn CounterVec::with_label_values(
  self : CounterVec,
  values : Array[String],
) -> @metric.Counter 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_counter_child(self.descriptor, labels)
      self.children[key] = child
      child
    }
  }
}

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

///|
pub fn CounterVec::delete_label_values(
  self : CounterVec,
  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 CounterVec::delete_labels(
  self : CounterVec,
  labels : Map[String, String],
) -> Bool raise VectorError {
  self.delete_label_values(self.schema.values_from_labels(labels))
}

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

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

///|
/// Return the currently registered child objects as a detached table copy.
pub fn CounterVec::children(self : CounterVec) -> Array[@metric.Counter] {
  self.lock.lock()
  defer self.lock.unlock()
  self.children.values().collect()
}