use std::io;
use bstr::ByteSlice;
use noodles::sam;
use noodles::sam::alignment::Record;
use noodles::sam::alignment::record::cigar::op::Kind;
use noodles::sam::alignment::record::data::field::value::Array;
use noodles::sam::alignment::record::data::field::{Tag, Value};
use crate::error::{Error, Result};
use crate::pileup::{EntryKind, record_name};
const LONGEST_OPERATOR: usize = (1 << 28) - 1;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Alignment {
start: i64,
end: i64,
leading: i64,
trailing: i64,
length: i64,
ops: Vec<(Kind, i64)>,
}
impl Alignment {
pub(crate) fn new(start: i64, ops: Vec<(Kind, i64)>) -> Self {
let span: i64 = ops
.iter()
.filter(|(kind, _)| kind.consumes_reference())
.map(|(_, len)| len)
.sum();
let soft = |op: &&(Kind, i64)| op.0 == Kind::SoftClip;
let clip = |op: &&(Kind, i64)| matches!(op.0, Kind::SoftClip | Kind::HardClip);
let leading = ops
.iter()
.take_while(clip)
.filter(soft)
.map(|op| op.1)
.sum();
let trailing = ops
.iter()
.rev()
.take_while(clip)
.filter(soft)
.map(|op| op.1)
.sum();
let length = ops
.iter()
.filter(|(kind, _)| kind.consumes_read())
.map(|(_, len)| len)
.sum();
Self {
start,
end: start + span - 1,
leading,
trailing,
length,
ops,
}
}
pub(crate) fn spans_reference(&self) -> bool {
self.end >= self.start
}
pub(crate) fn offset(&self, position: i64) -> (i64, bool) {
if position < self.start {
return (self.leading - (self.start - position), true);
}
if position > self.end {
return (
self.length - self.trailing + (position - self.end - 1),
true,
);
}
let (mut query, mut reference) = (self.leading, self.start);
for &(kind, len) in self
.ops
.iter()
.skip_while(|(kind, _)| matches!(kind, Kind::SoftClip | Kind::HardClip))
{
match kind {
Kind::Match | Kind::SequenceMatch | Kind::SequenceMismatch => {
if position < reference + len {
return (query + position - reference, true);
}
query += len;
reference += len;
}
Kind::Insertion => query += len,
Kind::Deletion | Kind::Skip => {
if position < reference + len {
return (query, false);
}
reference += len;
}
Kind::SoftClip | Kind::HardClip | Kind::Pad => {}
}
}
(query, false)
}
fn before(&self, position: i64) -> i64 {
self.offset(position).0
}
fn after(&self, position: i64) -> i64 {
let (offset, base) = self.offset(position);
self.length - offset - i64::from(base)
}
fn between(&self, from: i64, to: i64) -> i64 {
let (from, base) = self.offset(from);
self.offset(to).0 - from - i64::from(base)
}
}
pub(crate) fn parse_cigar(text: &[u8]) -> Option<Vec<(Kind, i64)>> {
let ops = sam::record::Cigar::new(text)
.iter()
.map(|op| op.ok().filter(|op| op.len() <= LONGEST_OPERATOR))
.map(|op| op.map(|op| (op.kind(), op.len() as i64)))
.collect::<Option<Vec<_>>>()?;
(!ops.is_empty()).then_some(ops)
}
pub fn five_prime_distance<R: Record + ?Sized>(
record: &R,
query_offset: usize,
) -> Result<Option<usize>> {
let length = record.cigar().read_length()?;
let reverse = record.flags()?.is_reverse_complemented();
Ok(from_five_prime(reverse, length, query_offset))
}
pub(crate) fn entry_from_five_prime(
kind: EntryKind,
reverse: bool,
length: usize,
offset: Option<usize>,
) -> Option<usize> {
match kind {
EntryKind::Base => from_five_prime(reverse, length, offset?),
EntryKind::Deletion | EntryKind::Skip => {
let next = offset.unwrap_or(length);
if reverse {
length.checked_sub(next)
} else {
(next <= length).then_some(next)
}
}
EntryKind::Insertion => None,
}
}
pub(crate) fn from_five_prime(reverse: bool, length: usize, offset: usize) -> Option<usize> {
if reverse {
length.checked_sub(offset + 1)
} else {
(offset < length).then_some(offset)
}
}
pub fn is_fr_pair<R: Record + ?Sized>(record: &R, header: &sam::Header) -> Result<bool> {
Ok(pairing(record, header)?.is_some())
}
struct Pairing {
start: i64,
mate_start: i64,
mate: Option<Alignment>,
}
fn pairing<R: Record + ?Sized>(record: &R, header: &sam::Header) -> Result<Option<Pairing>> {
let flags = record.flags()?;
let reverse = flags.is_reverse_complemented();
let (id, mate_id) = (
record.reference_sequence_id(header).transpose()?,
record.mate_reference_sequence_id(header).transpose()?,
);
if !flags.is_segmented()
|| flags.is_unmapped()
|| flags.is_mate_unmapped()
|| reverse == flags.is_mate_reverse_complemented()
|| id.is_none()
|| id != mate_id
{
return Ok(None);
}
let (Some(start), Some(mate_start)) = (
record.alignment_start().transpose()?,
record.mate_alignment_start().transpose()?,
) else {
return Ok(None);
};
let (start, mate_start) = (
usize::from(start) as i64 - 1,
usize::from(mate_start) as i64 - 1,
);
let (fr, mate) = if reverse {
let end = start + record.cigar().alignment_span()? as i64 - 1;
(mate_start <= end, None)
} else {
let mate = Alignment::new(mate_start, mate_cigar(record)?);
(start <= mate.end, Some(mate))
};
Ok(fr.then_some(Pairing {
start,
mate_start,
mate,
}))
}
fn mate_cigar<R: Record + ?Sized>(record: &R) -> Result<Vec<(Kind, i64)>> {
let Some(value) = record.data().get(&Tag::MATE_CIGAR).transpose()? else {
return Err(Error::MissingMateCigar {
name: record_name(record),
});
};
match &value {
Value::String(text) => parse_cigar(text),
_ => None,
}
.ok_or_else(|| invalid_mate_cigar(record, &value))
}
fn invalid_mate_cigar<R: Record + ?Sized>(record: &R, value: &Value<'_>) -> Error {
Error::InvalidMateCigar {
name: record_name(record),
value: value_text(value),
}
}
fn value_text(value: &Value<'_>) -> String {
fn join<T: ToString>(values: impl Iterator<Item = io::Result<T>>) -> String {
let texts: Vec<String> = values
.map(|value| value.map_or_else(|_| "?".to_owned(), |value| value.to_string()))
.collect();
texts.join(",")
}
match value {
Value::Character(character) => char::from(*character).to_string(),
Value::Int8(number) => number.to_string(),
Value::UInt8(number) => number.to_string(),
Value::Int16(number) => number.to_string(),
Value::UInt16(number) => number.to_string(),
Value::Int32(number) => number.to_string(),
Value::UInt32(number) => number.to_string(),
Value::Float(number) => number.to_string(),
Value::String(text) | Value::Hex(text) => text.to_str_lossy().into_owned(),
Value::Array(Array::Int8(values)) => join(values.iter()),
Value::Array(Array::UInt8(values)) => join(values.iter()),
Value::Array(Array::Int16(values)) => join(values.iter()),
Value::Array(Array::UInt16(values)) => join(values.iter()),
Value::Array(Array::Int32(values)) => join(values.iter()),
Value::Array(Array::UInt32(values)) => join(values.iter()),
Value::Array(Array::Float(values)) => join(values.iter()),
}
}
pub fn template_end_distance<R: Record + ?Sized>(
record: &R,
header: &sam::Header,
position: usize,
) -> Result<Option<usize>> {
Ok(ends(record, header)?.and_then(|ends| ends.distance(position)))
}
#[derive(Clone, Debug)]
pub(crate) struct Ends {
read: Alignment,
mate: Alignment,
reverse: bool,
}
impl Ends {
pub(crate) fn distance(&self, position: usize) -> Option<usize> {
usize::try_from(distance(
&self.read,
&self.mate,
self.reverse,
position as i64,
))
.ok()
}
}
pub(crate) fn ends<R: Record + ?Sized>(record: &R, header: &sam::Header) -> Result<Option<Ends>> {
let Some(pairing) = pairing(record, header)? else {
return Ok(None);
};
let mate = match pairing.mate {
Some(mate) => mate,
None => Alignment::new(pairing.mate_start, mate_cigar(record)?),
};
if !mate.spans_reference() {
let value = record
.data()
.get(&Tag::MATE_CIGAR)
.transpose()?
.unwrap_or(Value::String(b"".as_bstr()));
return Err(invalid_mate_cigar(record, &value));
}
let ops = record
.cigar()
.iter()
.map(|op| op.map(|op| (op.kind(), op.len() as i64)))
.collect::<io::Result<Vec<_>>>()?;
let read = Alignment::new(pairing.start, ops);
let reverse = record.flags()?.is_reverse_complemented();
Ok(read.spans_reference().then_some(Ends {
read,
mate,
reverse,
}))
}
pub(crate) fn distance(read: &Alignment, mate: &Alignment, reverse: bool, position: i64) -> i64 {
let (_, base) = read.offset(position);
let base = i64::from(base);
if !reverse {
if position < mate.start {
read.between(position, mate.start) + mate.length - mate.leading
} else if position <= mate.end {
mate.after(position)
} else {
mate.after(mate.end) - read.between(mate.end, position) - base
}
} else if position > mate.end {
mate.before(mate.end) + 1 + read.between(mate.end, position)
} else if position >= mate.start {
mate.before(position)
} else {
mate.leading - read.between(position, mate.start) - base
}
}