// file: kb-lib/src/materializer/routing/core.rs
// version: 3

//! Reserved routing materializer.

/// Reserved materializer for routing observations.
#[derive(Clone, Debug, Default)]
pub struct MtRoutingMaterializer;

impl crate::MtMaterializer for crate::MtRoutingMaterializer {
    fn materializer_name(&self) -> &'static str {
        return "kb_materializer_routing";
    }

    fn materializer_version(&self) -> &'static str {
        return env!("CARGO_PKG_VERSION");
    }

    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
        return false;
    }

    fn materialize_event(
        &self,
        event: &crate::MdDecodedProtocolEvent,
    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
            signature: event.signature.clone(),
            slot: event.slot,
            decoded_family: event.event_family,
            materialized_family: crate::MdMaterializedEventFamily::Routing,
        }]);
    }
}

impl crate::MtApiEventMaterializer for crate::MtRoutingMaterializer {
    fn identity(&self) -> crate::MtApiMaterializerIdentity {
        return crate::MtApiMaterializerIdentity {
            name: "kb_materializer_routing".to_string(),
            version: env!("CARGO_PKG_VERSION").to_string(),
        };
    }

    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
        return &[];
    }

    fn transaction_policy(
        &self,
        _family: crate::MdEventFamily,
    ) -> crate::MtApiMaterializationTransactionPolicy {
        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
    }

    fn materialize(
        &self,
        _observation: &crate::DcApiDecodedObservation,
    ) -> crate::MtApiMaterializerExecutionResult {
        return crate::MtApiMaterializerExecutionResult::ignored();
    }
}