sequence_domain 0.2.0

use std::fmt::Display;

#[derive(Debug, PartialEq, Eq)]
pub struct SequenceValueObject {
    value: String,
}

impl SequenceValueObject {
    pub fn new(value: &str) -> Self {
        Self {
            value: value.to_string(),
        }
    }

    pub fn reverse(self) -> Self {
        Self {
            value: self.value.chars().rev().collect(),
        }
    }

    pub fn value_of(&self) -> &str {
        &self.value
    }
}

impl Display for SequenceValueObject {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", &self.value)
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        domain::{
            dna_stuff::DnaSequenceValueObject, rna_stuff::RnaSequenceValueObject, SequenceType,
        },
        shared::errors::MalformedSequence,
    };

    #[test]
    fn should_create_rna_sequence_value_object() {
        assert!(RnaSequenceValueObject::new("aucg").is_ok())
    }

    #[test]
    fn should_create_dna_sequence_value_object() {
        assert!(DnaSequenceValueObject::new("atcg").is_ok())
    }

    #[test]
    fn should_error_rna_sequence_value_object() {
        let error_rna: Result<RnaSequenceValueObject, MalformedSequence> =
            RnaSequenceValueObject::new("atcg");
        assert!(error_rna
            .as_ref()
            .is_err_and(|e| e.illegal_chars == vec!['t']));
        assert!(error_rna
            .as_ref()
            .is_err_and(|e| e.kind == SequenceType::Rna));
        assert!(error_rna.as_ref().is_err_and(
            |e| e.to_string() == format!("Illegal characters: 't' are not allowed in rna")
        ))
    }

    #[test]
    fn should_error_dna_sequence_value_object() {
        let error_dna: Result<DnaSequenceValueObject, MalformedSequence> =
            DnaSequenceValueObject::new("aucg");
        println!(
            "{:?}, {:?}",
            error_dna.as_ref().unwrap_err().illegal_chars,
            error_dna.as_ref().unwrap_err().kind
        );
        assert!(error_dna
            .as_ref()
            .is_err_and(|e| e.illegal_chars == vec!['u']));
        assert!(error_dna
            .as_ref()
            .is_err_and(|e| e.kind == SequenceType::Dna));
        assert!(error_dna.as_ref().is_err_and(
            |e| e.to_string() == format!("Illegal characters: 'u' are not allowed in dna")
        ))
    }
}