#![cfg_attr(test, allow(non_snake_case))]
mod readme_doctests;

/// This macro runs the given code block, collects any tracing Events emitted, and returns them as a
/// `Vec<tracing_assert_core::Event>`.
///
/// Invoke it with
/// ```rust
/// use tracing;
/// use tracing_assert_core::Event;
/// use tracing_assert_macros::tracing_capture_events;
///
/// fn foo() {
///     tracing::trace!("my event data!");
/// }
///
/// let events: Vec<Event> = tracing_capture_events!({foo()});
/// ```
#[macro_export]
macro_rules! tracing_capture_events {
    ( $code_under_test:block ) => {{
        let events = {
            use tracing_assert_core::{
                lazy_static::lazy_static,
                tracing_subscriber::{self, layer::SubscriberExt},
                Event, Layer, Notification,
            };

            lazy_static! {
                static ref LAYER: Layer<Notification> = Layer::new();
            }

            let subscriber = tracing_subscriber::FmtSubscriber::builder()
                .with_test_writer()
                .with_max_level(tracing::Level::TRACE)
                .pretty()
                .finish()
                .with(&*LAYER);

            tracing::subscriber::with_default(subscriber, || $code_under_test);

            let events: Vec<Event> = LAYER.drain_events();
            events
        };
        events
    }};
}

/// This macro runs the given code block, collects any tracing Events emitted, and returns the
/// Field/Value pairs carried by each event.
///
/// This utility macro is useful for callers only caring about the custom Field/Value data, and not necessarily the
/// complete `Event` object.
///
/// Use it with
/// ```rust
/// use tracing;
/// use tracing_assert_core::FieldValueMap;
/// use tracing_assert_macros::tracing_capture_event_fields;
///
/// fn foo() {
///     tracing::trace!("my event data!");
/// }
///
/// let events: Vec<FieldValueMap> = tracing_capture_event_fields!({foo()});
/// ```
#[macro_export]
macro_rules! tracing_capture_event_fields {
    ( $code_under_test:block ) => {{
        let events = {
            use tracing_assert_core::FieldValueMap;

            let events = $crate::tracing_capture_events!({ $code_under_test });
            let events: Vec<FieldValueMap> =
                events.into_iter().map(|e| e.fields().clone()).collect();
            events
        };
        events
    }};
}

#[cfg(test)]
mod tests {
    use super::*;
    use tracing_assert_core::{debug_fmt_ext::DebugFmtExt, FieldValueMap};

    #[derive(Debug)]
    pub enum MyDomainLogEvent {
        Foo,
        Bar,
    }

    #[test]
    fn tracing_capture_event_fields__captures_multiple_custom_structs_per_event() {
        // Given
        fn emit_2_complex_payload_events() {
            tracing::info_span!("outermost span").in_scope(|| {
                tracing::trace!(message1 = ?MyDomainLogEvent::Foo, message2 = ?MyDomainLogEvent::Bar);
                tracing::trace!(arbitrary_key = ?MyDomainLogEvent::Bar);
            });
        }

        // When
        let events = tracing_capture_event_fields!({
            emit_2_complex_payload_events();
        });

        // Then
        let expected_events: Vec<Vec<(String, String)>> = vec![
            vec![
                ("message1".into(), MyDomainLogEvent::Foo.debug_fmt()),
                ("message2".into(), MyDomainLogEvent::Bar.debug_fmt()),
            ],
            vec![("arbitrary_key".into(), MyDomainLogEvent::Bar.debug_fmt())],
        ];

        assert_eq!(events, expected_events);
    }

    #[test]
    fn tracing_capture_event_fields__captures_debug_repr_of_custom_event_struct() {
        // Given
        fn emit_2_complex_payload_events() {
            // Only emit one field per event. Field should be typed Domain event
            // Always use debug representation of Event type with the `?` prefix
            tracing::trace!(message = ?MyDomainLogEvent::Foo);
            // Use consistent key (e.g. "message")
            tracing::trace!(message = ?MyDomainLogEvent::Bar);
        }

        // When
        let events = tracing_capture_event_fields!({
            emit_2_complex_payload_events();
        });

        // Then
        let expected_events: Vec<Vec<(String, String)>> = vec![
            vec![("message".into(), MyDomainLogEvent::Foo.debug_fmt())],
            vec![("message".into(), MyDomainLogEvent::Bar.debug_fmt())],
        ];

        assert_eq!(events, expected_events);
    }

    #[test]
    fn tracing_capture_events__can_collect_fields_values_off_of_returned_event() {
        // Given
        fn emit_2_complex_payload_events() {
            tracing::info_span!("outermost span").in_scope(|| {
                tracing::trace!(message1 = ?MyDomainLogEvent::Foo, message2 = ?MyDomainLogEvent::Bar);
                tracing::trace!(arbitrary_key = ?MyDomainLogEvent::Bar);
            });
        }

        // When
        let events = tracing_capture_events!({
            emit_2_complex_payload_events();
        });

        // Then
        let expected_events: Vec<Vec<(String, String)>> = vec![
            vec![
                ("message1".into(), MyDomainLogEvent::Foo.debug_fmt()),
                ("message2".into(), MyDomainLogEvent::Bar.debug_fmt()),
            ],
            vec![("arbitrary_key".into(), MyDomainLogEvent::Bar.debug_fmt())],
        ];

        let events: Vec<FieldValueMap> = events.into_iter().map(|e| e.fields().clone()).collect();

        // Assert list of events come back with expected fields
        assert_eq!(events, expected_events);
    }
}