mig-assembly 0.30.20

//! One transaction of a message, as if the message held no other.
//!
//! A UTILMD message repeats SG4, one per transaction (`IDE+24`), and the AHB
//! states its conditions per transaction: "Wenn SG4 STS+7++ZG9 vorhanden" asks
//! about the transaction the annotated field sits in. Asked of the whole
//! message, another transaction answers. A list PID (55065, 55195, …) adds an
//! SG4 of another kind, the list itself (`IDE+Z01`), which the transactions'
//! conditions do refer to ("Wenn im SG4 IDE+Z01 … STS+E01 nicht vorhanden").
//!
//! [`TransactionView`] keeps the repetition of the transaction group asked
//! about, first, and every repetition of another kind; it leaves out the other
//! repetitions of the same kind.

use crate::assembler::{AssembledGroupInstance, AssembledSegment, AssembledTree};

/// [`AssembledTree::transaction_view`]'s result.
#[derive(Debug, Clone)]
pub struct TransactionView {
    /// The message with the other transactions of the same kind left out. The
    /// transaction itself is repetition 0 of its group.
    pub tree: AssembledTree,
    /// Segment numbers (`AssembledSegment::segment_number`) of everything left
    /// out, sorted.
    pub left_out: Vec<u32>,
}

/// The kind of a repetition: its entry segment's tag and qualifier
/// (`IDE`, `24`).
fn kind(instance: &AssembledGroupInstance) -> Option<(&str, &str)> {
    let entry = instance.segments.first()?;
    let qualifier = entry
        .elements
        .first()
        .and_then(|e| e.first())
        .map_or("", String::as_str);
    Some((entry.tag.as_str(), qualifier))
}

fn segment_numbers(instance: &AssembledGroupInstance, out: &mut Vec<u32>) {
    let own = instance.segments.iter().chain(&instance.skipped_segments);
    out.extend(own.filter_map(|s: &AssembledSegment| s.segment_number));
    for group in &instance.child_groups {
        for repetition in &group.repetitions {
            segment_numbers(repetition, out);
        }
    }
}

impl AssembledTree {
    /// The message as transaction `index` of the top-level group `group_id`
    /// sees it (see the [module](crate::transaction_view)). `None` when the
    /// group has no such repetition.
    pub fn transaction_view(&self, group_id: &str, index: usize) -> Option<TransactionView> {
        let position = self.groups.iter().position(|g| g.group_id == group_id)?;
        let group = &self.groups[position];
        let own = group.repetitions.get(index)?;
        let own_kind = kind(own);
        let mut repetitions = vec![own.clone()];
        let mut left_out = Vec::new();
        for (i, repetition) in group.repetitions.iter().enumerate() {
            if i == index {
                continue;
            }
            if kind(repetition) == own_kind {
                segment_numbers(repetition, &mut left_out);
            } else {
                repetitions.push(repetition.clone());
            }
        }
        left_out.sort_unstable();
        let mut groups = Vec::with_capacity(self.groups.len());
        for (i, g) in self.groups.iter().enumerate() {
            if i == position {
                let mut view = g.clone_shallow();
                view.repetitions = std::mem::take(&mut repetitions);
                groups.push(view);
            } else {
                groups.push(g.clone());
            }
        }
        Some(TransactionView {
            tree: AssembledTree {
                segments: self.segments.clone(),
                groups,
                post_group_start: self.post_group_start,
                inter_group_segments: self.inter_group_segments.clone(),
            },
            left_out,
        })
    }
}

impl crate::assembler::AssembledGroup {
    /// The group without its repetitions.
    fn clone_shallow(&self) -> Self {
        Self {
            group_id: self.group_id.clone(),
            repetitions: Vec::new(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::assembler::AssembledGroup;

    fn seg(text: &str, number: u32) -> AssembledSegment {
        let mut parts = text.split('+');
        AssembledSegment {
            tag: parts.next().unwrap().to_string(),
            elements: parts.map(|e| vec![e.to_string()]).collect(),
            mig_number: None,
            segment_number: Some(number),
        }
    }

    fn inst(
        segments: Vec<AssembledSegment>,
        child_groups: Vec<AssembledGroup>,
    ) -> AssembledGroupInstance {
        AssembledGroupInstance {
            segments,
            child_groups,
            entry_mig_number: None,
            variant_mig_numbers: vec![],
            skipped_segments: vec![],
            skipped_positions: vec![],
        }
    }

    fn sg8(seq: &str, number: u32) -> AssembledGroup {
        AssembledGroup {
            group_id: "SG8".into(),
            repetitions: vec![inst(vec![seg(seq, number)], vec![])],
        }
    }

    /// BGM, SG2, then SG4: a list (`IDE+Z01`) and three transactions.
    fn message() -> AssembledTree {
        AssembledTree {
            segments: vec![seg("BGM+E01", 1)],
            groups: vec![
                AssembledGroup {
                    group_id: "SG2".into(),
                    repetitions: vec![inst(vec![seg("NAD+MS", 2)], vec![])],
                },
                AssembledGroup {
                    group_id: "SG4".into(),
                    repetitions: vec![
                        inst(vec![seg("IDE+Z01", 3)], vec![]),
                        inst(vec![seg("IDE+24", 4)], vec![sg8("SEQ+Z01", 5)]),
                        inst(vec![seg("IDE+24", 6)], vec![sg8("SEQ+Z02", 7)]),
                        inst(vec![seg("IDE+24", 8)], vec![sg8("SEQ+Z03", 9)]),
                    ],
                },
            ],
            post_group_start: 1,
            inter_group_segments: Default::default(),
        }
    }

    fn entries(tree: &AssembledTree) -> Vec<String> {
        tree.groups[1]
            .repetitions
            .iter()
            .map(|r| format!("{}+{}", r.segments[0].tag, r.segments[0].elements[0][0]))
            .collect()
    }

    #[test]
    fn a_transaction_sees_itself_first_and_the_list_but_no_other_transaction() {
        let view = message().transaction_view("SG4", 2).unwrap();
        assert_eq!(entries(&view.tree), ["IDE+24", "IDE+Z01"]);
        assert_eq!(
            view.tree.groups[1].repetitions[0].segments[0].segment_number,
            Some(6)
        );
        assert_eq!(view.left_out, [4, 5, 8, 9]);
        // What is not the transaction group is kept as it is.
        assert_eq!(view.tree.groups[0], message().groups[0]);
        assert_eq!(view.tree.segments, message().segments);
    }

    #[test]
    fn the_list_sees_every_transaction() {
        let view = message().transaction_view("SG4", 0).unwrap();
        assert_eq!(
            entries(&view.tree),
            ["IDE+Z01", "IDE+24", "IDE+24", "IDE+24"]
        );
        assert!(view.left_out.is_empty());
    }

    #[test]
    fn no_such_group_or_repetition_is_no_view() {
        assert!(message().transaction_view("SG5", 0).is_none());
        assert!(message().transaction_view("SG4", 4).is_none());
    }
}