use std::ops::Range;
use noodles_bam::record::codec::encoder::data::field::{ty, write_value};
use noodles_sam::alignment::record::data::field::Value as FieldValue;
use super::*;
const UNMAPPED_BIN: u16 = 4680;
const MAX_QUALITY: u8 = 93;
const MAX_NAME_LENGTH: usize = 254;
const CIGAR_TAG: [u8; 2] = *b"CG";
const ARRAY_HEADER_LEN: usize = 8;
pub(super) struct RecordEdit<'a> {
pub(super) start: usize,
pub(super) end: usize,
pub(super) name: Option<Vec<u8>>,
pub(super) updates: TagUpdates,
pub(super) remove: &'a TagRemoval,
pub(super) reason: Option<Reason>,
}
impl<'a> RecordEdit<'a> {
pub(super) fn unchanged(len: usize, remove: &'a TagRemoval) -> Self {
Self {
start: 0,
end: len,
name: None,
updates: Vec::new(),
remove,
reason: None,
}
}
}
enum FieldBytes {
Source(Range<usize>),
Sliced([u8; ARRAY_HEADER_LEN], Range<usize>),
Encoded(Range<usize>),
}
pub(super) struct RawField {
pub(super) tag: [u8; 2],
pub(super) ty: u8,
pub(super) bytes: Range<usize>,
pub(super) array: Option<(usize, usize)>,
}
fn invalid_input(message: &str) -> io::Error {
io::Error::new(io::ErrorKind::InvalidInput, message.to_string())
}
fn invalid_data(message: &str) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, message.to_string())
}
pub(super) fn next_field(aux: &[u8], pos: usize) -> io::Result<RawField> {
let &[t0, t1, ty, ..] = &aux[pos..] else {
return Err(invalid_data("truncated aux field"));
};
let value = pos + 3;
let (end, array) = match ty {
b'A' | b'c' | b'C' => (value + 1, None),
b's' | b'S' => (value + 2, None),
b'i' | b'I' | b'f' => (value + 4, None),
b'Z' | b'H' => {
let nul = aux[value..]
.iter()
.position(|&b| b == 0)
.ok_or_else(|| invalid_data("aux string is not NUL terminated"))?;
(value + nul + 1, None)
},
b'B' => {
let &[subtype, c0, c1, c2, c3, ..] = &aux[value.min(aux.len())..] else {
return Err(invalid_data("truncated aux array"));
};
let size = match subtype {
b'c' | b'C' => 1,
b's' | b'S' => 2,
b'i' | b'I' | b'f' => 4,
_ => return Err(invalid_data("invalid aux array subtype")),
};
let count = usize::try_from(u32::from_le_bytes([c0, c1, c2, c3]))
.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
let end = count
.checked_mul(size)
.and_then(|n| n.checked_add(value + 5))
.ok_or_else(|| invalid_data("truncated aux array"))?;
(end, Some((size, count)))
},
_ => return Err(invalid_data("invalid aux type")),
};
if end > aux.len() {
return Err(invalid_data("truncated aux field"));
}
Ok(RawField {
tag: [t0, t1],
ty,
bytes: pos..end,
array,
})
}
fn check_text(ty: u8, value: &[u8]) -> io::Result<()> {
match ty {
b'Z' if !value.iter().all(|b| matches!(b, b' '..=b'~')) => {
Err(invalid_input("invalid aux string"))
},
b'H' if !value.len().is_multiple_of(2)
|| !value.iter().all(|b| matches!(b, b'0'..=b'9' | b'A'..=b'F')) =>
{
Err(invalid_input("invalid aux hex value"))
},
_ => Ok(()),
}
}
fn slices_per_base(tag: [u8; 2]) -> bool {
!has_dedicated_rule(tag) && tag != RLE_COVERAGE_TAG && !FIXED_ARRAY_TAGS.contains(&tag)
}
fn push_array(dst: &mut Vec<u8>, array: &Array) -> io::Result<()> {
fn header(dst: &mut Vec<u8>, subtype: u8, len: usize) -> io::Result<()> {
let count =
u32::try_from(len).map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
dst.extend_from_slice(&[b'B', subtype]);
dst.extend_from_slice(&count.to_le_bytes());
Ok(())
}
match array {
Array::Int8(v) => {
header(dst, b'c', v.len())?;
dst.extend(v.iter().map(|&n| n as u8));
},
Array::UInt8(v) => {
header(dst, b'C', v.len())?;
dst.extend_from_slice(v);
},
Array::Int16(v) => {
header(dst, b's', v.len())?;
dst.extend(v.iter().flat_map(|n| n.to_le_bytes()));
},
Array::UInt16(v) => {
header(dst, b'S', v.len())?;
dst.extend(v.iter().flat_map(|n| n.to_le_bytes()));
},
Array::Int32(v) => {
header(dst, b'i', v.len())?;
dst.extend(v.iter().flat_map(|n| n.to_le_bytes()));
},
Array::UInt32(v) => {
header(dst, b'I', v.len())?;
dst.extend(v.iter().flat_map(|n| n.to_le_bytes()));
},
Array::Float(v) => {
header(dst, b'f', v.len())?;
dst.extend(v.iter().flat_map(|n| n.to_le_bytes()));
},
}
Ok(())
}
fn encode_field(scratch: &mut Vec<u8>, tag: [u8; 2], value: &Value) -> io::Result<Range<usize>> {
let begin = scratch.len();
scratch.extend_from_slice(&tag);
match value {
Value::Array(array) => push_array(scratch, array)?,
_ => {
let value = FieldValue::from(value);
scratch.push(ty::encode(value.ty()));
write_value(scratch, &value)?;
},
}
Ok(begin..scratch.len())
}
fn insert(fields: &mut Vec<([u8; 2], FieldBytes)>, tag: [u8; 2], bytes: FieldBytes) {
match fields.iter_mut().find(|(t, _)| *t == tag) {
Some(slot) => slot.1 = bytes,
None => fields.push((tag, bytes)),
}
}
fn edit_fields(
aux: &[u8],
orig_len: usize,
edit: &mut RecordEdit<'_>,
scratch: &mut Vec<u8>,
) -> io::Result<Vec<([u8; 2], FieldBytes)>> {
let (start, end) = (edit.start, edit.end);
let trimmed = start != 0 || end != orig_len;
let remove = edit.remove;
let updates = &mut edit.updates;
if !remove.is_empty() {
updates.retain(|(t, _)| !remove.contains(&<[u8; 2]>::from(*t)));
}
let mut fields = Vec::new();
let mut seen: Vec<[u8; 2]> = Vec::new();
let mut pos = 0;
while pos < aux.len() {
let field = next_field(aux, pos)?;
pos = field.bytes.end;
let tag = field.tag;
if seen.contains(&tag) {
return Err(invalid_data("duplicate aux tag"));
}
seen.push(tag);
if tag == CIGAR_TAG || remove.contains(&tag) {
continue;
}
if let Some(i) = updates.iter().position(|(t, _)| <[u8; 2]>::from(*t) == tag) {
if let (_, Some(value)) = updates.remove(i) {
let bytes = encode_field(scratch, tag, &value)?;
insert(&mut fields, tag, FieldBytes::Encoded(bytes));
}
continue;
}
let bytes = match field.array {
Some((size, count)) if trimmed && count == orig_len && slices_per_base(tag) => {
let (s, e) = if REVERSED_PERBASE_TAGS.contains(&tag) {
(orig_len - end, orig_len - start)
} else {
(start, end)
};
let first = field.bytes.start;
let elements = first + ARRAY_HEADER_LEN;
let mut head = [0; ARRAY_HEADER_LEN];
head[..4].copy_from_slice(&aux[first..first + 4]);
head[4..].copy_from_slice(&((e - s) as u32).to_le_bytes());
FieldBytes::Sliced(head, elements + s * size..elements + e * size)
},
_ => {
check_text(
field.ty,
&aux[field.bytes.start + 3..field.bytes.end.saturating_sub(1)],
)?;
FieldBytes::Source(field.bytes)
},
};
insert(&mut fields, tag, bytes);
}
for (tag, value) in updates.drain(..) {
if let Some(value) = value {
let tag = <[u8; 2]>::from(tag);
let bytes = encode_field(scratch, tag, &value)?;
insert(&mut fields, tag, FieldBytes::Encoded(bytes));
}
}
if let Some(reason) = edit.reason {
let tag = <[u8; 2]>::from(reject::REASON_TAG);
let value = Value::String(reason.label().into());
let bytes = encode_field(scratch, tag, &value)?;
insert(&mut fields, tag, FieldBytes::Encoded(bytes));
}
Ok(fields)
}
fn check_name(name: &[u8]) -> io::Result<()> {
let valid = (1..=MAX_NAME_LENGTH).contains(&name.len())
&& name != b"*"
&& name.iter().all(|&b| b.is_ascii_graphic() && b != b'@');
if valid {
Ok(())
} else {
Err(invalid_input("invalid read name"))
}
}
fn region_bin(start: usize, span: usize) -> u16 {
const LEVELS: [(u32, usize); 5] = [(14, 4681), (17, 585), (20, 73), (23, 9), (26, 1)];
let beg = start - 1;
let end = if span == 0 { beg } else { beg + span - 1 };
let bin = LEVELS
.iter()
.find(|&&(shift, _)| beg >> shift == end >> shift)
.map_or(0, |&(shift, first)| first + (beg >> shift));
bin as u16
}
fn cigar_lengths(cigar: &[u8]) -> io::Result<(usize, usize)> {
let mut span = 0;
let mut read_len = 0;
for op in cigar.as_chunks::<4>().0 {
let n = u32::from_le_bytes(*op);
let len = (n >> 4) as usize;
match n & 0x0f {
0 | 7 | 8 => {
span += len;
read_len += len;
},
2 | 3 => span += len,
1 | 4 => read_len += len,
5 | 6 => {},
_ => return Err(invalid_data("invalid CIGAR operation")),
}
}
Ok((span, read_len))
}
pub(super) fn push_packed_bases(dst: &mut Vec<u8>, packed: &[u8], start: usize, end: usize) {
let n = end - start;
if n == 0 {
return;
}
let src = &packed[start / 2..end.div_ceil(2)];
if start.is_multiple_of(2) {
dst.extend_from_slice(src);
if !n.is_multiple_of(2)
&& let Some(last) = dst.last_mut()
{
*last &= 0xf0;
}
} else {
dst.extend(src.windows(2).map(|w| (w[0] << 4) | (w[1] >> 4)));
if !n.is_multiple_of(2) {
dst.push(src[src.len() - 1] << 4);
}
}
}
fn encoded_index(index: Option<usize>) -> io::Result<i32> {
index.map_or(Ok(-1), |i| {
i32::try_from(i).map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))
})
}
pub(super) fn build_record(src: &bam::Record, mut edit: RecordEdit<'_>) -> io::Result<Vec<u8>> {
let sequence = src.sequence();
let orig_len = sequence.len();
let (start, end) = (edit.start, edit.end);
if start > end || end > orig_len {
return Err(invalid_input("output window exceeds the read"));
}
let base_count = end - start;
let data = src.data();
let aux = data.as_bytes();
let mut scratch = Vec::new();
let fields = edit_fields(aux, orig_len, &mut edit, &mut scratch)?;
let name: &[u8] = match (&edit.name, src.name()) {
(Some(name), _) => name,
(None, Some(name)) => name,
(None, None) => b"*",
};
if edit.name.is_some() || src.name().is_some() {
check_name(name)?;
}
let cigar = src.cigar();
let cigar = cigar.as_bytes();
let (span, read_len) = cigar_lengths(cigar)?;
if base_count > 0 && read_len > 0 && read_len != base_count {
return Err(invalid_input("read length-sequence length mismatch"));
}
let qual = &src.quality_scores().as_bytes()[start..end];
if qual.iter().any(|&q| q > MAX_QUALITY) {
return Err(invalid_input("invalid base quality"));
}
let alignment_start = src.alignment_start().transpose()?.map(usize::from);
let bin = alignment_start.map_or(UNMAPPED_BIN, |start| region_bin(start, span));
let aux_len: usize = fields
.iter()
.map(|(_, bytes)| match bytes {
FieldBytes::Source(r) | FieldBytes::Encoded(r) => r.len(),
FieldBytes::Sliced(head, r) => head.len() + r.len(),
})
.sum();
let mut dst = Vec::with_capacity(
32 + name.len() + 1 + cigar.len() + base_count.div_ceil(2) + base_count + aux_len,
);
let reference_id = encoded_index(src.reference_sequence_id().transpose()?)?;
dst.extend_from_slice(&reference_id.to_le_bytes());
let position = encoded_index(alignment_start.map(|p| p - 1))?;
dst.extend_from_slice(&position.to_le_bytes());
dst.push((name.len() + 1) as u8);
dst.push(src.mapping_quality().map_or(0xff, u8::from));
dst.extend_from_slice(&bin.to_le_bytes());
dst.extend_from_slice(&((cigar.len() / 4) as u16).to_le_bytes());
dst.extend_from_slice(&u16::from(src.flags()).to_le_bytes());
dst.extend_from_slice(&(base_count as u32).to_le_bytes());
let mate_reference_id = encoded_index(src.mate_reference_sequence_id().transpose()?)?;
dst.extend_from_slice(&mate_reference_id.to_le_bytes());
let mate_position = encoded_index(
src.mate_alignment_start()
.transpose()?
.map(|p| usize::from(p) - 1),
)?;
dst.extend_from_slice(&mate_position.to_le_bytes());
dst.extend_from_slice(&src.template_length().to_le_bytes());
dst.extend_from_slice(name);
dst.push(0);
dst.extend_from_slice(cigar);
push_packed_bases(&mut dst, sequence.as_bytes(), start, end);
dst.extend_from_slice(qual);
for (_, bytes) in &fields {
match bytes {
FieldBytes::Source(r) => dst.extend_from_slice(&aux[r.clone()]),
FieldBytes::Sliced(head, r) => {
dst.extend_from_slice(head);
dst.extend_from_slice(&aux[r.clone()]);
},
FieldBytes::Encoded(r) => dst.extend_from_slice(&scratch[r.clone()]),
}
}
Ok(dst)
}