fn fault() -> Fault {
    &FaultInfo {
        message: "integer arithmetic fault",
        source: "reference.dever",
        line: 1,
        column: 1,
    }
}

fn map_reference(values: &[i64]) -> Result<Vec<i64>, Fault> {
    let mut output = Vec::with_capacity(values.len());
    for value in values {
        output.push(value.checked_add(1).ok_or_else(fault)?);
    }
    Ok(output)
}

fn total_reference(values: &[i64]) -> Result<i64, Fault> {
    let mut total = 0i64;
    for value in values {
        let adjusted = value.checked_add(1).ok_or_else(fault)?;
        total = total.checked_add(adjusted).ok_or_else(fault)?;
    }
    Ok(total)
}

// 与跨包调用一致，投影失败和累计失败必须能定位到不同来源。
fn total_reference_distinct_faults(values: &[i64]) -> Result<i64, Fault> {
    let mut total = 0i64;
    for value in values {
        let adjusted = value.checked_add(1).ok_or(&FaultInfo {
            message: "integer arithmetic fault",
            source: "reference/value.rs",
            line: 1,
            column: 1,
        })?;
        total = total.checked_add(adjusted).ok_or(&FaultInfo {
            message: "integer arithmetic fault",
            source: "reference/batch.rs",
            line: 2,
            column: 1,
        })?;
    }
    Ok(total)
}

fn dispatch_generated(values: &[i64]) -> Result<i64, Fault> {
    GENERATED_DISPATCH(values.first().copied().unwrap_or(0))
}

fn dispatch_reference(values: &[i64]) -> Result<i64, Fault> {
    values
        .first()
        .copied()
        .unwrap_or(0)
        .checked_mul(2)
        .ok_or_else(fault)
}

fn dispatch_total_reference(values: &[i64]) -> Result<i64, Fault> {
    let mut total = 0i64;
    for value in values {
        let doubled = value.checked_mul(2).ok_or_else(fault)?;
        total = total.checked_add(doubled).ok_or(&FaultInfo {
            message: "integer overflow",
            source: "reference/dispatch.rs",
            line: 2,
            column: 1,
        })?;
    }
    Ok(total)
}

fn main() {
    let values: Vec<i64> = (0..1024).map(|value| value % 17).collect();
    for values in [&[i64::MAX][..], &[i64::MAX - 1, 1][..], &[i64::MIN][..]] {
        assert_eq!(
            GENERATED_MAP(values).map_err(|_| ()),
            map_reference(values).map_err(|_| ())
        );
        assert_eq!(
            GENERATED_TOTAL(values).map_err(|_| ()),
            total_reference(values).map_err(|_| ())
        );
        assert_eq!(
            GENERATED_TOTAL(values).map_err(|fault| fault.message),
            total_reference_distinct_faults(values).map_err(|fault| fault.message)
        );
        assert_eq!(
            dispatch_generated(values).map_err(|_| ()),
            dispatch_reference(values).map_err(|_| ())
        );
    }
    let projection = GENERATED_TOTAL(&[i64::MAX]).unwrap_err();
    let sum = GENERATED_TOTAL(&[i64::MAX - 1, 1]).unwrap_err();
    assert_ne!(projection.source, sum.source);
    assert_ne!(
        total_reference_distinct_faults(&[i64::MAX])
            .unwrap_err()
            .source,
        total_reference_distinct_faults(&[i64::MAX - 1, 1])
            .unwrap_err()
            .source
    );
    for values in [&[i64::MAX][..], &[i64::MAX / 2, 1][..], &[i64::MIN][..]] {
        assert_eq!(
            GENERATED_DISPATCH_TOTAL(values).map_err(|fault| fault.message),
            dispatch_total_reference(values).map_err(|fault| fault.message)
        );
    }
    println!("case,sample,implementation,elapsed_ns,checksum");
    compare(
        "package_map",
        &values,
        20000,
        GENERATED_MAP,
        map_reference,
        |value| value.iter().map(|value| *value as u64).sum(),
    );
    compare(
        "package_total",
        &values,
        20000,
        GENERATED_TOTAL,
        total_reference,
        |value| *value as u64,
    );
    compare(
        "package_total_distinct_faults",
        &values,
        20000,
        GENERATED_TOTAL,
        total_reference_distinct_faults,
        |value| *value as u64,
    );
    compare(
        "package_dispatch",
        &[21],
        3000000,
        dispatch_generated,
        dispatch_reference,
        |value| *value as u64,
    );
    compare(
        "package_dispatch_batch",
        &values,
        20000,
        GENERATED_DISPATCH_TOTAL,
        dispatch_total_reference,
        |value| *value as u64,
    );
}