UNIQUE

5 unique_fn "UNIQUE" (1, 3) [R "array", V "by_col", V "exactly_once"] |s, a, sv| {
    unique(s, a, sv)
}

/// The cells of row (or column, `by_col`) `index` of `array`.
fn line(array: &CalcArray, index: usize, by_col: bool) -> Vec<CalcValue> {
    let ArrayShape { rows, cols } = array.shape();
    if by_col {
        (0..rows)
            .map(|r| {
                array
                    .get(r, index)
                    .cloned()
                    .unwrap_or_else(CalcValue::empty)
            })
            .collect()
    } else {
        (0..cols)
            .map(|c| {
                array
                    .get(index, c)
                    .cloned()
                    .unwrap_or_else(CalcValue::empty)
            })
            .collect()
    }
}

/// Whether two cells are the same for UNIQUE: numbers when equal as binary64 (OxFunc's rule), text
/// ignoring case under the collation, and otherwise equal kinds with equal values.
fn same(site: &Site<'_>, x: &CalcValue, y: &CalcValue) -> Step<bool> {
    match (x.core_ref(), y.core_ref()) {
        (CoreRef::Text(a), CoreRef::Text(b)) => {
            comparison::texts(a.utf16_code_units(), b.utf16_code_units(), Want::Equality)
                .map(Ordering::is_eq)
                .map_err(|_| site.not_modelled(None))
        }
        (CoreRef::Number(a), CoreRef::Number(b)) => Ok(a == b),
        _ => order(site, x, y).map(Ordering::is_eq),
    }
}

/// A coarse key under which equal cells always fall together (text by its collation sort key,
/// numbers by their bits), so each line is compared only with the lines that share it; `None`
/// when a text's sort key is not built (dc-zsn.1), whose equality to the other texts is then not
/// decided.
fn bucket(cells: &[CalcValue]) -> Option<String> {
    let mut key = String::new();
    for cell in cells {
        match cell.core_ref() {
            CoreRef::Number(n) => key.push_str(&format!("n{:x}|", (n + 0.0).to_bits())),
            CoreRef::Text(t) => {
                key.push('t');
                for byte in comparison::text_bucket(t.utf16_code_units())? {
                    key.push_str(&format!("{byte:02x}"));
                }
                key.push('|');
            }
            CoreRef::Logical(b) => key.push_str(if b { "T|" } else { "F|" }),
            CoreRef::Error(code) => key.push_str(&format!("e{}|", code as u8)),
            _ => key.push_str("b|"),
        }
    }
    Some(key)
}

fn unique(site: &Site<'_>, a: &[CalcValue], sv: &mut EvalServices<'_>) -> Step<CalcValue> {
    let args = prepared(site, a, sv)?;
    let array = as_array(&args[0]);
    let by_col = flag(site, args.get(1))?;
    let exactly_once = flag(site, args.get(2))?;
    let ArrayShape { rows, cols } = array.shape();
    let len = if by_col { cols } else { rows };
    let lines: Vec<Vec<CalcValue>> = (0..len).map(|i| line(&array, i, by_col)).collect();
    // Each line's group: the first earlier line equal to it, or itself.
    let mut buckets: HashMap<String, Vec<usize>> = HashMap::new();
    let mut group = vec![0usize; len];
    for i in 0..len {
        let key = bucket(&lines[i]).ok_or_else(|| site.not_modelled(None))?;
        let members = buckets.entry(key).or_default();
        let mut found = None;
        for &j in members.iter() {
            let mut equal = true;
            for (x, y) in lines[i].iter().zip(&lines[j]) {
                if !same(site, x, y)? {
                    equal = false;
                    break;
                }
            }
            if equal {
                found = Some(j);
                break;
            }
        }
        match found {
            Some(j) => group[i] = j,
            None => {
                group[i] = i;
                members.push(i);
            }
        }
    }
    let mut counts = vec![0usize; len];
    for &g in &group {
        counts[g] += 1;
    }
    let kept: Vec<usize> = (0..len)
        .filter(|&i| group[i] == i && (!exactly_once || counts[i] == 1))
        .collect();
    if kept.is_empty() {
        return fail(WorksheetErrorCode::Calc);
    }
    let (out_rows, out_cols) = if by_col {
        (rows, kept.len())
    } else {
        (kept.len(), cols)
    };
    let mut cells = Vec::with_capacity(out_rows * out_cols);
    for r in 0..out_rows {
        for c in 0..out_cols {
            let value = if by_col {
                &lines[kept[c]][r]
            } else {
                &lines[kept[r]][c]
            };
            cells.push(value.clone());
        }
    }
    Ok(CalcValue::array(
        CalcArray::new(
            ArrayShape {
                rows: out_rows,
                cols: out_cols,
            },
            cells,
        )
        .expect("a shape of its cells"),
    ))
}

/// A key under which texts the comparison operators hold equal always fall together, for a
/// grouping that compares only the texts sharing a key (UNIQUE): the weights the second pass
/// compares but the diacritics (texts the first pass holds equal differ in ASCII case alone,
/// which the weights ignore), or `None` when the collation builds none for `text`.
pub(super) fn text_bucket(text: &[u16]) -> Option<Vec<u8>> {
    if text.iter().any(|&code| sort_key::refused(code)) {
        return None;
    }
    let parts = sort_key::parts(text).ok()?;
    let mut key = parts.primary;
    key.push(1);
    key.extend_from_slice(&parts.rest);
    Some(key)
}

/// Whether a unit has no measured comparison route. Partial Jamo groups reach
/// `parts`, which still refuses a comparison needing their unknown bytes.
pub(super) fn refused(code: u16) -> bool {
    match code {
        0x0001..=0x007F => false,
        _ => matches!(table().weights[usize::from(code)], Weight::Refused),
    }
}