GROUPBY

1 groupby_fn "GROUPBY" (3, 8) [R "row_fields", R "values", R "function", V "field_headers", V "total_depth", R "sort_order", R "filter_array", V "field_relationship"] |s, a, sv| { groupby(s, a, sv) }

fn groupby(site: &Site<'_>, a: &[CalcValue], sv: &mut EvalServices<'_>) -> Step<CalcValue> {
    let fields = table(site, a, 0, sv)?;
    let values = table(site, a, 1, sv)?;
    let functions = functions(a, 2)?;
    if fields.height() != values.height() {
        return fail(W::Value);
    }
    let (has_header, show) = headers(site, a, 3, &values)?;
    let depth = whole(site, a, 4)?.unwrap_or(1);
    let entries = sort_entries(site, a, 5)?;
    let tabular = match whole(site, a, 7)? {
        None | Some(0) => false,
        Some(1) => true,
        Some(_) => return fail(W::Value),
    };
    let k = fields.cols;
    if !(-2..=2).contains(&depth) || (depth.abs() == 2 && (k < 2 || tabular)) {
        return fail(W::Value);
    }
    let pairs = pairs(&functions, values.cols)?;
    if entries
        .iter()
        .any(|e| e.unsigned_abs() as usize > k + pairs.len())
    {
        return fail(W::Value);
    }
    let start = usize::from(has_header);
    if values.height() <= start {
        return fail(W::Value);
    }
    let count = values.height() - start;
    let keep = filter(site, a, 6, count, values.height(), sv)?;
    let rows: Vec<usize> = (start..values.height()).filter(|r| keep[r - start]).collect();
    let mut groups = Vec::new();
    let keys = canonical(site, &fields.rows, &rows)?;
    for (key, members) in group(site, &keys, &rows)? {
        let mut aggregates = Vec::with_capacity(pairs.len());
        for &(v, f) in &pairs {
            aggregates.push(aggregate(site, sv, &functions[f], &values, v, &members, &rows)?);
        }
        groups.push((key, members, aggregates));
    }
    sort_groups(site, &mut groups, k, &entries, tabular)?;
    let width = k + pairs.len();
    let mut out: Vec<Vec<CalcValue>> = Vec::new();
    if show {
        let mut header: Vec<CalcValue> = (0..k)
            .map(|c| if has_header { fields.rows[0][c].clone() } else { text(&format!("Row Field {}", c + 1)) })
            .collect();
        for &(v, f) in &pairs {
            header.push(if functions.len() > 1 {
                function_name(&functions[f])
            } else if has_header {
                values.rows[0][v].clone()
            } else {
                text(&format!("Value {}", v + 1))
            });
        }
        out.push(header);
    } else if functions.len() > 1 {
        let mut header = vec![text(""); k];
        header.extend(pairs.iter().map(|&(_, f)| function_name(&functions[f])));
        out.push(header);
    }
    let totals = |site: &Site<'_>, sv: &mut EvalServices<'_>, label: &str, prefix: Option<&CalcValue>, members: &[usize]| -> Step<Vec<CalcValue>> {
        let mut row = vec![text(""); width];
        match prefix {
            Some(key) => row[0] = key.clone(),
            None => row[0] = text(label),
        }
        for (at, &(v, f)) in pairs.iter().enumerate() {
            row[k + at] = aggregate(site, sv, &functions[f], &values, v, members, &rows)?;
        }
        Ok(row)
    };
    let grand_label = if depth.abs() == 2 { "Grand Total" } else { "Total" };
    if depth < 0 {
        out.push(totals(site, sv, grand_label, None, &rows)?);
    }
    let mut at = 0;
    while at < groups.len() {
        let mut end = at + 1;
        if depth.abs() == 2 {
            while end < groups.len() && same(site, &groups[end].0[0], &groups[at].0[0])? {
                end += 1;
            }
        }
        let members: Vec<usize> = groups[at..end].iter().flat_map(|g| g.1.iter().copied()).collect();
        if depth == -2 {
            out.push(totals(site, sv, "", Some(&groups[at].0[0]), &members)?);
        }
        for g in &groups[at..end] {
            let mut row = g.0.clone();
            row.extend(g.2.iter().cloned());
            out.push(row);
        }
        if depth == 2 {
            out.push(totals(site, sv, "", Some(&groups[at].0[0]), &members)?);
        }
        at = end;
    }
    if depth > 0 {
        out.push(totals(site, sv, grand_label, None, &rows)?);
    }
    for row in &mut out {
        for cell in row.iter_mut() {
            if matches!(cell.core_ref(), CoreRef::Missing) {
                *cell = text("");
            }
        }
    }
    result(out)
}