ADDRESS

6 address_entry "ADDRESS" (2, 5) [V "row_num", V "column_num", V "abs_num", V "a1", V "sheet_text"] |s, a, sv| { address_fn(s, a) }

fn address_fn(site: &Site<'_>, a: &[CalcValue]) -> Step<CalcValue> {
    let given = |i: usize| a.get(i).is_some_and(|v| !v.is_missing());
    let row = if a[0].is_missing() {
        0
    } else {
        let n = num(site, a, 0)?;
        if !n.is_finite() {
            return fail(WorksheetErrorCode::Value);
        }
        address::address_integer(n)
    };
    let col = {
        if a[1].is_missing() {
            return fail(WorksheetErrorCode::Value);
        }
        let n = num(site, a, 1)?;
        if !n.is_finite() {
            return fail(WorksheetErrorCode::Value);
        }
        address::address_integer(n)
    };
    let abs = if given(2) {
        let n = num(site, a, 2)?;
        if !n.is_finite() {
            return fail(WorksheetErrorCode::Value);
        }
        address::address_integer(n)
    } else {
        1
    };
    let a1 = if given(3) {
        match a[3].core_ref() {
            CoreRef::Logical(b) => b,
            CoreRef::Text(_) => site.argument(3, coerce::logical(&a[3]))?,
            _ => num(site, a, 3)? != 0.0,
        }
    } else {
        true
    };
    let sheet_text = if given(4) {
        Some(text_arg(site, a, 4)?)
    } else {
        None
    };
    if !(1..=4).contains(&abs) {
        return fail(WorksheetErrorCode::Value);
    }
    address::format_address_body(row, col, abs as usize, a1, sheet_text.as_ref())
        .map(CalcValue::text)
        .map_err(Exit::Error)
}

pub(crate) fn address_integer(number: f64) -> i64 {
    // On ADDRESS's admitted integer range, Excel's observed conversion is
    // floor(RN53(RN64(number + 2^31)) - 2^31). The two rounding steps admit
    // the lower neighbor of each integer through these inclusive thresholds.
    // This reduced comparison avoids platform-dependent extended precision.
    // W111 retains exact-bit boundary probes for both thresholds and all axes.
    let upper = number.ceil();
    let threshold = if upper > 0.0 {
        2.0_f64.powi(-22) + 2.0_f64.powi(-33)
    } else {
        2.0_f64.powi(-23) + 2.0_f64.powi(-34)
    };
    if upper - number <= threshold {
        upper as i64
    } else {
        number.floor() as i64
    }
}

fn literal(&mut self, text: &str) {
    let remaining = 258usize.saturating_sub(self.0.len());
    self.0.extend(text.encode_utf16().take(remaining));
}

fn integer(&mut self, number: i64) {
    // Signs are literal fragments; magnitude digits append atomically.
    if number < 0 {
        self.literal("-");
    }
    let digits = number.unsigned_abs().to_string();
    if digits.len() <= 258usize.saturating_sub(self.0.len()) {
        self.literal(&digits);
    }
}

fn column_label_from_index(mut col: usize) -> Option<String> {
    if col == 0 {
        return None;
    }
    let mut chars = Vec::new();
    while col > 0 {
        let rem = (col - 1) % 26;
        chars.push((b'A' + rem as u8) as char);
        col = (col - 1) / 26;
    }
    chars.reverse();
    Some(chars.into_iter().collect())
}

pub(crate) fn format_address_body(
    row: i64,
    col: i64,
    abs_num: usize,
    a1_style: bool,
    sheet_text: Option<&ExcelText>,
) -> Result<ExcelText, WorksheetErrorCode> {
    if !(1..=4).contains(&abs_num) {
        return Err(WorksheetErrorCode::Value);
    }
    let row_relative = !a1_style && matches!(abs_num, 3 | 4);
    let col_relative = !a1_style && matches!(abs_num, 2 | 4);
    let valid_coordinate = |value: i64, limit: i64, relative: bool| {
        if relative {
            (-limit + 1..limit).contains(&value)
        } else {
            (1..=limit).contains(&value)
        }
    };
    if !valid_coordinate(row, 1_048_576, row_relative)
        || !valid_coordinate(col, 16_384, col_relative)
    {
        return Err(WorksheetErrorCode::Value);
    }
    let prefix = match sheet_text {
        Some(sheet) => {
            let mut prefix = quote_sheet_text_if_needed(sheet)?;
            prefix.push(33);
            prefix
        }
        None => Vec::new(),
    };
    // The sheet prefix is constructed before the bounded body append. An
    // admitted escaped name can make the prefix itself 259 UTF-16 units long.
    let mut address = AddressBuffer(prefix);
    if a1_style {
        let col_part = column_label_from_index(col as usize)
            .ok_or(WorksheetErrorCode::Value)?;
        if matches!(abs_num, 1 | 3) {
            address.literal("$");
        }
        address.literal(&col_part);
        if matches!(abs_num, 1 | 2) {
            address.literal("$");
        }
        address.integer(row);
    } else {
        for (label, number, relative) in [("R", row, row_relative), ("C", col, col_relative)] {
            address.literal(label);
            if !relative || number != 0 {
                if relative {
                    address.literal("[");
                }
                address.integer(number);
                if relative {
                    address.literal("]");
                }
            }
        }
    }
    Ok(ExcelText::from_utf16_code_units(address.0))
}