COUNT

aggregate(COUNT, "COUNT", VALUES, count)

/// COUNT: how many numbers there are. A held number counts; a direct argument counts when it is
/// a number, a logical, text that reads as a number, or omitted (read as 0). Nothing else counts,
/// and an error is not the result. Counting needs no rounding.
fn count(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    let site = Site::new(COUNT, services);
    let mut counted = 0u64;
    let read_through = read_through_held_arrays(arguments);
    let arguments: &[CalcValue] = read_through.as_deref().unwrap_or(arguments);
    let held = match read_held_references(&site, services, arguments, HeldReference::NoNumber) {
        Ok(held) => held,
        Err(exit) => return Site::finish(Err(exit)),
    };
    let arguments: &[CalcValue] = held.as_deref().unwrap_or(arguments);
    let read = each_value(&site, arguments, services, &mut |index, origin, value| {
        if counts_as_number(&site, index, origin, value)? {
            counted += 1;
        }
        Ok(())
    });
    Site::finish(read.and_then(|()| site.number(counted as f64)))
}

fn counts_as_number(
    site: &Site<'_>,
    index: usize,
    origin: Origin,
    value: &CalcValue,
) -> Step<bool> {
    match (origin, value.core_ref()) {
        (_, CoreRef::Number(n)) => finite(site, index, n).map(|()| true),
        (Origin::Direct, CoreRef::Logical(_) | CoreRef::Empty | CoreRef::Missing) => Ok(true),
        // Whether the text reads as a number decides; its value is not used, so nothing rounds.
        (Origin::Direct, CoreRef::Text(_)) => match coerce::number(value) {
            Ok(Numeric::Decimal(decimal)) => match decimal.nearest() {
                Ok(_) => Ok(true),
                // Decimal text beyond the range Excel reads is no number, not an error.
                Err(Stop::Error(_)) => Ok(false),
                Err(stop) => Err(site.stop(stop, Some(index))),
            },
            Ok(Numeric::Number(_)) => Ok(true),
            Err(Stop::Error(_)) => Ok(false),
            // Text coercion alone does not read (a date without a year, dc-bd5: COUNT("1/2") is
            // 1): read as VALUE reads it under the call's environment.
            Err(Stop::NotModelled) => match site.read_text(index, value) {
                Ok(Some(_)) => Ok(true),
                Ok(None) => Err(site.not_modelled(Some(index))),
                Err(Exit::Error(_)) => Ok(false),
                Err(exit) => Err(exit),
            },
        },
        (_, CoreRef::Array(_) | CoreRef::Reference(_)) => Err(site.not_modelled(Some(index))),
        (_, CoreRef::Text(_) | CoreRef::Logical(_) | CoreRef::Error(_))
        | (Origin::Held | Origin::Element, CoreRef::Empty | CoreRef::Missing) => Ok(false),
    }
}