///|
#derive(Debug)
pub(all) struct TestComparison {
  signature : TestSignature
  before : TestStatistics
  after : TestStatistics
  mean_delta : Double?
  failure_rate_delta : Double?
}

///|
#derive(Debug)
pub(all) struct BatchComparison {
  before_yield : YieldSummary
  after_yield : YieldSummary
  tests : Array[TestComparison]
  diagnostics : Array[Diagnostic]
}

///|
fn comparison_identity(signature : TestSignature) -> String {
  "\{signature.kind}/\{signature.number}"
}

///|
fn comparison_unresolved(signature : TestSignature) -> Bool {
  (signature.kind == "PTR" || signature.kind == "MPR") &&
  signature.units is None
}

///|
fn comparison_delta(before : Double?, after : Double?) -> Double? {
  match (before, after) {
    (Some(a), Some(b)) => {
      let delta = b - a
      if a.is_finite() && b.is_finite() && delta.is_finite() {
        Some(delta)
      } else {
        None
      }
    }
    _ => None
  }
}

///|
fn comparison_warn(
  diagnostics : Array[Diagnostic],
  signature : TestSignature,
  side : String,
  code : String,
) -> Unit {
  diagnostics.push({
    offset: 0,
    code,
    message: "\{side} batch: \{code}; \{@debug.to_string(signature)}",
  })
}

///|
/// Compare raw batch statistics in left first-seen context order. Exact
/// signatures are required, independently of text. PTR/MPR with missing units
/// are unresolved, even if both sides have the same missing context. FTR can
/// match without units because it supplies execution status, not numeric data.
/// Every unmatched signature on either side produces a diagnostic; matched
/// variants do not hide additional changed variants. Diagnostics use offset 0
/// because a signature can aggregate observations at multiple source offsets.
/// Deltas are after minus before, absent if either metric or the delta is
/// nonfinite. No significance or causal claim is inferred from a difference.
pub fn compare_batches(
  left : Array[Part],
  right : Array[Part],
) -> BatchComparison {
  let before = test_statistics(left)
  let after = test_statistics(right)
  let before_identities : Map[String, Bool] = Map([])
  let after_identities : Map[String, Bool] = Map([])
  let after_indexes : Map[TestSignature, Int32] = Map([])
  for item in before {
    before_identities[comparison_identity(item.signature)] = true
  }
  for i in 0..