mzcore 0.2.0

//! Code to handle the XL-MOD ontology
use std::collections::HashMap;

use context_error::{
    BoxedError, Context, CreateError, FullErrorContent, StaticErrorContent, combine_error,
    combine_errors,
};
use mzcv::{
    CVError, CVFile, CVSource, CVVersion, Comment, HashBufReader, Modifier, OboIdentifier,
    OboOntology, OboStanzaType, OboValue, RelationType,
};
use thin_vec::ThinVec;

use crate::{
    chemistry::{DiagnosticIon, MolecularFormula, NeutralLoss},
    helper_functions::explain_number_error,
    ontology::{
        Ontology,
        ontology_modification::{ModData, OntologyModification},
    },
    sequence::{
        AminoAcid, CrossId, LinkerLength, LinkerSpecificity, PlacementRule, Position,
        SimpleModification, SimpleModificationInner,
    },
};

/// XL-MOD modifications
#[allow(missing_copy_implementations, missing_debug_implementations)]
pub struct XlMod {}

impl CVSource for XlMod {
    type Data = SimpleModificationInner;
    type Structure = Vec<SimpleModification>;

    fn cv_name() -> &'static str {
        "XLMOD"
    }

    fn files() -> &'static [CVFile] {
        &[CVFile {
            name: "XLMOD",
            extension: "obo",
            url: Some(
                "https://raw.githubusercontent.com/HUPO-PSI/xlmod-CV/refs/heads/main/XLMOD.obo",
            ),
            compression: mzcv::CVCompression::None,
        }]
    }

    fn static_data() -> Option<(CVVersion, Self::Structure)> {
        #[cfg(not(feature = "internal-no-data"))]
        {
            use bincode::config::Configuration;
            let cache = bincode::decode_from_slice::<(CVVersion, Self::Structure), Configuration>(
                include_bytes!("../databases/xlmod.dat"),
                Configuration::default(),
            )
            .unwrap()
            .0;
            Some(cache)
        }
        #[cfg(feature = "internal-no-data")]
        None
    }

    fn parse(
        mut reader: impl Iterator<Item = HashBufReader<Box<dyn std::io::Read>, impl sha2::Digest>>,
    ) -> Result<
        (
            CVVersion,
            Self::Structure,
            Vec<BoxedError<'static, CVError>>,
        ),
        Vec<BoxedError<'static, CVError>>,
    > {
        let reader = reader.next().unwrap();
        let mut errors = Vec::new();
        OboOntology::from_raw(reader)
            .map_err(|e| {
                vec![
                    BoxedError::small(
                        CVError::FileCouldNotBeParsed,
                        e.get_short_description(),
                        e.get_long_description(),
                    )
                    .add_contexts(e.get_contexts().iter().cloned()),
                ]
            })
            .map(|obo| {
                (
                    obo.version(),
                    {
                        let mut mods: Vec<OntologyModification> = Vec::new();

                        for obj in &obo.objects {
                            if obj.stanza_type != OboStanzaType::Term {
                                continue;
                            }
                            let id: u32 = match obj
                                .id
                                .1
                                .parse() {
                                    Ok(v) => v,
                                    Err(err) => {
                                        combine_error(&mut errors, BoxedError::new(CVError::ItemError, "Invalid XLMOD", format!("The ID is {}", explain_number_error(&err)), Context::default().lines(0, obj.id.1.to_string())));
                                        continue;
                                    }
                                };
                            let name = obj.lines["name"][0].0.clone();

                            let description = obj
                                .definition
                                .as_ref()
                                .map_or_else(Box::default, |d| d.0.clone());
                            let cross_ids = obj
                                .definition
                                .as_ref()
                                .map_or_else(ThinVec::new, |d| d.1.iter().filter(|c| !(c.0.as_ref().is_some_and(|c| c.eq_ignore_ascii_case("psi") || c.eq_ignore_ascii_case("pxi")) && c.1.eq_ignore_ascii_case("XL"))).cloned().collect());
                            let synonyms = obj
                                .synonyms
                                .iter()
                                .map(|s| (s.scope, s.synonym.clone()))
                                .collect();

                            // Get all properties from any ancestors in the tree then get all properties from this definition
                            let mut properties = Properties::default();
                            let mut stack = Vec::new();
                            stack.extend(obj.relationship.clone());

                            let is_homo_functional = obj.relationship.iter().any(|r| r.0 == RelationType::IsA && r.1 == OboIdentifier(Some("XLMOD".into()), "00005".into()));
                            while let Some((ty, id, _, _)) = stack.pop() {
                                if (ty == RelationType::IsA || is_homo_functional && ty == RelationType::Other("has_reactive_group".into())) && let Some(obj) = obo.objects.iter().find(|o| o.id == id) {
                                    combine_errors(
                                        &mut errors,
                                        parse_property_values(
                                            &obj.property_values,
                                            &mut properties,
                                            id,
                                        ),
                                    );
                                    stack.extend(obj.relationship.clone());
                                }
                            }

                            combine_errors(
                                &mut errors,
                                parse_property_values(
                                    &obj.property_values,
                                    &mut properties,
                                    obj.id.clone(),
                                ),
                            );

                            if properties.origins.0.is_empty() {
                                properties.origins.0 = vec![PlacementRule::Position(Position::Anywhere)];
                            }

                            let cross_ids = match cross_ids
                                .iter()
                                .map(|v| v.clone().try_into())
                                .collect::<Result<ThinVec<CrossId>, _>>()
                            {
                                Ok(ids) => ids,
                                Err(err) => {combine_error(&mut errors, err.convert(|_| CVError::ItemError)); continue},
                            };
                            if properties.sites == Some(2) {
                                let mut m =
                                    OntologyModification {
                                        formula: properties.formula.unwrap_or_default(),
                                        name,
                                        description,
                                        cross_ids,
                                        synonyms,
                                        id: mzcv::AccessionCode::Numeric(id),
                                        ontology: Ontology::Xlmod,
                                        obsolete: obj.obsolete,
                                        data: ModData::Linker {
                                            length: properties.length,
                                            specificities: vec![
                                                if properties.origins.1.is_empty() {
                                                    LinkerSpecificity::Symmetric {
                                                        rules: properties.origins.0,
                                                        stubs: properties.stubs,
                                                        neutral_losses: properties.neutral_losses,
                                                        diagnostic: properties.diagnostic_ions,
                                                    }
                                                } else {
                                                    LinkerSpecificity::Asymmetric {
                                                        rules: (
                                                            properties.origins.0,
                                                            properties.origins.1,
                                                        ),
                                                        stubs: properties.stubs,
                                                        neutral_losses: properties.neutral_losses,
                                                        diagnostic: properties.diagnostic_ions,
                                                    }
                                                },
                                            ],
                                        },
                                        parents: ThinVec::default(),
                                    };
                                m.add_relationships(&obj.relationship);
                                mods.push(m);
                            } else if properties.sites == Some(1) {
                                let mut m =
                                    OntologyModification {
                                        formula: properties.formula.unwrap_or_default(),
                                        name,
                                        description,
                                        cross_ids,
                                        synonyms,
                                        ontology: Ontology::Xlmod,
                                        obsolete: obj.obsolete,
                                        id: mzcv::AccessionCode::Numeric(id),
                                        data: ModData::Mod {
                                            specificities: vec![(
                                                properties.origins.0,
                                                properties.neutral_losses,
                                                properties.diagnostic_ions,
                                            )],
                                        },
                                        parents: ThinVec::default(),
                                    };
                                m.add_relationships(&obj.relationship);
                                mods.push(m);
                            } else if !properties.dna_linker && !obj.property_values.is_empty() {
                                if let Some(sites) = properties.sites {
                                    combine_error(&mut errors, BoxedError::new(
                                        CVError::ItemWarning,
                                        "Higher order cross-linker", 
                                        format!("This cross-linker links {sites} sites, but only cross-linkers with two sites are supported for now, this modification will be ignored"), 
                                        Context::default().lines(0, format!("XLMOD:{id:05}"))));
                                } else {
                                    combine_error(&mut errors, BoxedError::new(
                                        CVError::ItemWarning,
                                        "Undefined modification", 
                                        "This modification has no definition of the number of sites it links, this modification will be ignored", 
                                        Context::default().lines(0, format!("XLMOD:{id:05}"))));
                                }
                            }
                        }

                       OntologyModification::finish(mods)
                    },
                    errors,
                )
            })
    }
}

#[derive(Default)]
struct Properties {
    dna_linker: bool,
    sites: Option<u8>,
    length: LinkerLength,
    formula: Option<MolecularFormula>,
    origins: (Vec<PlacementRule>, Vec<PlacementRule>),
    diagnostic_ions: Vec<DiagnosticIon>,
    neutral_losses: Vec<NeutralLoss>,
    stubs: Vec<(MolecularFormula, MolecularFormula)>,
}

fn parse_property_values(
    property_values: &HashMap<Box<str>, Vec<(OboValue, Vec<Modifier>, Comment)>>,
    properties: &mut Properties,
    id: OboIdentifier,
) -> Vec<BoxedError<'static, CVError>> {
    let mut mass = None;
    let mut errors = Vec::new();
    for (property, value) in property_values {
        match property.as_ref() {
            "reactionSites" => {
                if value.len() > 1 {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemWarning,
                            "Multiple reaction sites",
                            "More than 1 'reactionSites` definitions for this entry",
                            Context::default().lines(0, id.to_string()),
                        ),
                    );
                }
                properties.sites = if let OboValue::Integer(n, _) = value[0].0 {
                    u8::try_from(n).map_or_else(
                        |_| {
                            combine_error(
                                &mut errors,
                                BoxedError::new(
                                    CVError::ItemError,
                                    "Out of range number of sites",
                                    "The number of sites can only be in range 0—255",
                                    Context::default().lines(0, value[0].0.to_string()).to_owned(),
                                ),
                            );
                            None
                        },
                        Some,
                    )
                } else {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemError,
                            "Invalid type",
                            "Invalid item type",
                            Context::default().lines(
                                0,
                                format!(
                                    "{id}: reactionSites: type: {}, expected: integer",
                                    value[0].0.datatype()
                                ),
                            ),
                        ),
                    );
                    None
                }
            }
            "spacerLength" => {
                for (def, ..) in value {
                    let length = if let OboValue::Float(n, ..) = def {
                        *n
                    } else {
                        combine_error(
                            &mut errors,
                            BoxedError::new(
                                CVError::ItemError,
                                "Invalid type",
                                "Invalid item type",
                                Context::default().lines(
                                    0,
                                    format!(
                                        "{id}: spacerLength: type: {}, expected: float",
                                        def.datatype()
                                    ),
                                ),
                            ),
                        );
                        0.0
                    };
                    match &mut properties.length {
                        LinkerLength::Discrete(options) => {
                            options.push(length.into());
                        }
                        l => *l = LinkerLength::Discrete(vec![length.into()]),
                    }
                }
            }
            "minSpacerLength" => {
                if value.len() > 1 {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemWarning,
                            "Multiple minSpacerLength",
                            "More than 1 'minSpacerLength` definitions for this entry",
                            Context::default().lines(0, id.to_string()),
                        ),
                    );
                }
                let length = if let OboValue::Float(n, ..) = value[0].0 {
                    n
                } else {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemError,
                            "Invalid type",
                            "Invalid item type",
                            Context::default().lines(
                                0,
                                format!(
                                    "{id}: minSpacerLength: type: {}, expected: float",
                                    value[0].0.datatype()
                                ),
                            ),
                        ),
                    );
                    0.0
                };
                match &mut properties.length {
                    LinkerLength::InclusiveRange(start, _) => {
                        *start = length.into();
                    }
                    l => {
                        *l = LinkerLength::InclusiveRange(length.into(), length.into());
                    }
                }
            }
            "maxSpacerLength" => {
                if value.len() > 1 {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemWarning,
                            "Multiple maxSpacerLength",
                            "More than 1 'maxSpacerLength` definitions for this entry",
                            Context::default().lines(0, id.to_string()),
                        ),
                    );
                }
                let length = if let OboValue::Float(n, ..) = value[0].0 {
                    n
                } else {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemError,
                            "Invalid type",
                            "Invalid item type",
                            Context::default().lines(
                                0,
                                format!(
                                    "{id}: maxSpacerLength: type: {}, expected: float",
                                    value[0].0.datatype()
                                ),
                            ),
                        ),
                    );
                    0.0
                };
                match &mut properties.length {
                    LinkerLength::InclusiveRange(_, end) => {
                        *end = length.into();
                    }
                    l => {
                        *l = LinkerLength::InclusiveRange(length.into(), length.into());
                    }
                }
            }
            "monoIsotopicMass" => {
                if value.len() > 1 {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemWarning,
                            "Multiple monoIsotopicMass",
                            "More than 1 'monoIsotopicMass` definitions for this entry",
                            Context::default().lines(0, id.to_string()),
                        ),
                    );
                }
                mass = if let OboValue::Float(n, ..) = value[0].0 {
                    Some(ordered_float::OrderedFloat(n))
                } else {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemError,
                            "Invalid type",
                            "Invalid item type",
                            Context::default().lines(
                                0,
                                format!(
                                    "{id}: monoIsotopicMass: type: {}, expected: float",
                                    value[0].0.datatype()
                                ),
                            ),
                        ),
                    );
                    None
                }
            }
            "deadEndFormula" => {
                if value.len() > 1 {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemWarning,
                            "Multiple deadEndFormula",
                            "More than 1 'deadEndFormula` definitions for this entry",
                            Context::default().lines(0, id.to_string()),
                        ),
                    );
                }
                properties.sites = Some(1);
                properties.formula = MolecularFormula::xlmod(&value[0].0.to_string())
                    .map_err(|e| {
                        combine_error(&mut errors, e.to_owned().convert(|_| CVError::ItemError));
                    })
                    .ok();
            }
            "neutralLossFormula" => {
                for (def, ..) in value {
                    match MolecularFormula::xlmod(&def.to_string()) {
                        Ok(v) => properties.neutral_losses.push(v.into()),
                        Err(err) => combine_error(
                            &mut errors,
                            err.to_owned().convert::<CVError, BoxedError<'static, CVError>>(|_| {
                                CVError::ItemError
                            }),
                        ),
                    }
                }
            }
            "bridgeFormula" => {
                if value.len() > 1 {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemWarning,
                            "Multiple bridgeFormula",
                            "More than 1 'bridgeFormula` definitions for this entry",
                            Context::default().lines(0, id.to_string()),
                        ),
                    );
                }
                properties.sites = properties.sites.or(Some(2));
                properties.formula = MolecularFormula::xlmod(&value[0].0.to_string())
                    .map_err(|e| {
                        combine_error(&mut errors, e.to_owned().convert(|_| CVError::ItemError));
                    })
                    .ok();
            }
            "specificities" => {
                // specificities: "(C,U)" xsd:string
                // specificities: "(K,N,Q,R,Protein N-term)&(E,D,Protein C-term)" xsd:string
                if value.len() > 1 {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemWarning,
                            "Multiple specificities",
                            "More than 1 'specificities` definitions for this entry",
                            Context::default().lines(0, id.to_string()),
                        ),
                    );
                }
                if let Some((l, r)) = value[0].0.to_string().split_once('&') {
                    properties.sites = properties.sites.or(Some(2));
                    properties
                        .origins
                        .0
                        .extend(l.trim_matches(['(', ')']).split(',').filter_map(|s| {
                            read_placement_rule(s.trim())
                                .map_err(|err| combine_error(&mut errors, err))
                                .ok()
                        }));
                    properties
                        .origins
                        .1
                        .extend(r.trim_matches(['(', ')']).split(',').filter_map(|s| {
                            read_placement_rule(s.trim())
                                .map_err(|err| combine_error(&mut errors, err))
                                .ok()
                        }));
                } else {
                    properties.origins.0.extend(
                        value[0].0.to_string().trim_matches(['(', ')']).split(',').filter_map(
                            |s| {
                                read_placement_rule(s.trim())
                                    .map_err(|err| combine_error(&mut errors, err))
                                    .ok()
                            },
                        ),
                    );
                }
            }
            "secondarySpecificities" => {
                // TODO: keep track that these are 'secondary' somewhere, similarly to the Unimod
                // hidden state secondarySpecificities: "(S,T,Y)" xsd:string
                if value.len() > 1 {
                    combine_error(
                        &mut errors,
                        BoxedError::new(
                            CVError::ItemWarning,
                            "Multiple secondarySpecificities",
                            "More than 1 'secondarySpecificities` definitions for this entry",
                            Context::default().lines(0, id.to_string()),
                        ),
                    );
                }
                properties.origins.0.extend(
                    value[0].0.to_string().trim_matches(['(', ')']).split(',').filter_map(|s| {
                        read_placement_rule(s.trim())
                            .map_err(|err| combine_error(&mut errors, err))
                            .ok()
                    }),
                );
            }
            "baseSpecificities" | "secondarybaseSpecificities" => {
                properties.dna_linker = true;
            }
            "reporterMass" | "CID_Fragment" => {
                // reporterMass: "555.2481" xsd:double
                // CID_Fragment: "828.5" xsd:double
                for (def, ..) in value {
                    properties.diagnostic_ions.push(DiagnosticIon(
                        MolecularFormula::with_additional_mass(
                            if let OboValue::Float(n, ..) = def {
                                *n
                            } else {
                                combine_error(
                                    &mut errors,
                                    BoxedError::new(
                                        CVError::ItemError,
                                        "Invalid type",
                                        "Invalid item type",
                                        Context::default().lines(
                                            0,
                                            format!(
                                                "{id}: {property}: type: {}, expected: float",
                                                value[0].0.datatype()
                                            ),
                                        ),
                                    ),
                                );
                                0.0
                            },
                        ),
                    ));
                }
            }
            "reporterFormula" => {
                for (def, ..) in value {
                    match MolecularFormula::xlmod(&def.to_string()) {
                        Ok(v) => properties.diagnostic_ions.push(v.into()),
                        Err(err) => combine_error(
                            &mut errors,
                            err.to_owned().convert::<CVError, BoxedError<'static, CVError>>(|_| {
                                CVError::ItemError
                            }),
                        ),
                    }
                }
            }
            "stubDefinition" | "stubFormula" => {
                // CID = H4 C3 O2 S1, -H2 -O1 : H2 C3 O1
                // ETD = -H1 :
                // TODO: Extend the stub logic to handle the techniques and neutral losses
                for (def, ..) in value {
                    if let OboValue::String(definition) = &def {
                        let (_techniques, definition) = definition.split_once('=').unwrap();
                        let (first, second) = definition.split_once(':').unwrap();
                        let mut split_first = first.split(',');
                        let mut split_second = second.split(',');
                        let formula_first =
                            split_first.next().map_or_else(MolecularFormula::default, |v| {
                                MolecularFormula::xlmod(v).unwrap()
                            });
                        let _losses_first: Vec<NeutralLoss> = split_first
                            .map(|v| MolecularFormula::xlmod(v).unwrap().into())
                            .collect();
                        let formula_second =
                            split_second.next().map_or_else(MolecularFormula::default, |v| {
                                MolecularFormula::xlmod(v).unwrap()
                            });
                        let _losses_second: Vec<NeutralLoss> = split_second
                            .map(|v| MolecularFormula::xlmod(v).unwrap().into())
                            .collect();
                        properties.stubs.push((formula_first, formula_second));
                    } else {
                        combine_error(
                            &mut errors,
                            BoxedError::new(
                                CVError::ItemError,
                                "Invalid type",
                                "Invalid item type",
                                Context::default().lines(
                                    0,
                                    format!(
                                        "{id}: {property}: type: {}, expected: string",
                                        value[0].0.datatype()
                                    ),
                                ),
                            ),
                        );
                    }
                }
            }
            _ => {} // TODO: handle: hydrophilicPEGchain?, maxAbsorption?, waveLengthRange?
        }
    }

    // Ignore the mass if a formula is set
    properties.formula = properties
        .formula
        .clone()
        .or_else(|| mass.map(|v| MolecularFormula::with_additional_mass(v.0)));

    errors
}

/// Read a placement rule
/// # Errors
/// If not a valid placement rule
fn read_placement_rule(brick: &str) -> Result<PlacementRule, BoxedError<'static, CVError>> {
    if brick.len() == 1
        && let Ok(aa) = AminoAcid::try_from(brick)
    {
        Ok(PlacementRule::AminoAcid(
            vec![aa].into(),
            Position::Anywhere,
        ))
    } else if brick.eq_ignore_ascii_case("Protein N-term") {
        Ok(PlacementRule::Position(Position::ProteinNTerm))
    } else if brick.eq_ignore_ascii_case("Protein C-term") {
        Ok(PlacementRule::Position(Position::ProteinCTerm))
    } else {
        Err(BoxedError::new(
            CVError::ItemError,
            "Invalid placement rule",
            "Placement rule has to be an amino acid, protein N-term, or protein C-term.",
            Context::default().lines(0, brick).to_owned(),
        ))
    }
}