#![cfg_attr(test, allow(non_snake_case))]
use std::{
    collections::VecDeque,
    sync::{Arc, Mutex},
};
use tracing_core::{event, span, subscriber};
use tracing_subscriber::layer;
use visitor::FieldValueVisitor;

pub use visitor::FieldValueMap;

pub use lazy_static;
pub use tracing;
pub use tracing_subscriber;

pub mod debug_fmt_ext;
#[cfg(test)]
mod tests;
pub mod visitor;

#[derive(Default)]
pub struct Layer<T> {
    log: Arc<Mutex<VecDeque<T>>>,
}

impl<T> Layer<T> {
    pub fn new() -> Self {
        Self {
            log: Arc::new(Mutex::new(VecDeque::new())),
        }
    }

    pub fn capture(&self, entry: T) {
        let mut log = self.log.lock().expect("log mutex shouldn't be poisoned");
        log.push_back(entry);
    }
}

impl Layer<Notification> {
    pub fn drain_events(&self) -> Vec<Event> {
        let mut log = self.log.lock().expect("log mutex shouldn't be poisoned");
        let events: Vec<Event> = log
            .drain(..)
            .filter_map(|val| match val {
                Notification::Event { event, ctx: _ } => Some(event),
                _ => None,
            })
            .collect();
        events
    }
}

// potential future improvements
// - add API to encourage composing `Layer` with `tracing_subscriber::filter::EnvFilter`
// - add API to encourage composing `Layer` with `tracing_subscriber::filter::LevelFilter`
// - feature flag for integration with insta
// - feature flag for integration with proptest

pub trait LayerTransform<S> {
    fn from_new_span(
        attrs: &span::Attributes<'_>,
        id: &span::Id,
        ctx: layer::Context<'_, S>,
    ) -> Self;

    fn from_on_record(
        span: &span::Id,
        values: &span::Record<'_>,
        ctx: layer::Context<'_, S>,
    ) -> Self;

    fn from_on_follows_from(
        span: &span::Id,
        follows: &span::Id,
        ctx: layer::Context<'_, S>,
    ) -> Self;

    fn from_on_event(event: &event::Event<'_>, ctx: layer::Context<'_, S>) -> Self;

    fn from_on_enter(id: &span::Id, ctx: layer::Context<'_, S>) -> Self;

    fn from_on_exit(id: &span::Id, ctx: layer::Context<'_, S>) -> Self;

    fn from_on_close(id: span::Id, ctx: layer::Context<'_, S>) -> Self;

    fn from_on_id_change(old: &span::Id, new: &span::Id, ctx: layer::Context<'_, S>) -> Self;
}

#[derive(Debug)]
pub struct FieldSet {}

impl From<&tracing_core::field::FieldSet> for FieldSet {
    fn from(_fields: &tracing_core::field::FieldSet) -> Self {
        // Note: Is there context here worth collecting?
        // _fields contains all _keys_ passed to trace!() macro, but not the corresponding Value data.
        Self {}
    }
}

#[derive(Debug)]
pub struct ValueSet {}

impl From<&tracing_core::field::ValueSet<'_>> for ValueSet {
    fn from(_values: &tracing_core::field::ValueSet<'_>) -> Self {
        // NOTE: Is there context here worth collecting?
        // Cannot call `_values.record()` here to see actual Values themselves
        // because that method is pub(crate) in the tracing lib. Must access data through `Event::record()`.
        Self {}
    }
}

#[derive(Debug)]
#[allow(dead_code)] // Adding this because for some reason clippy is not recognizing that these fields are read in the From impl below
pub struct Metadata {
    name: String,
    target: String,
    level: tracing_core::Level,
    module_path: Option<String>,
    file: Option<String>,
    line: Option<u32>,
    fields: FieldSet,
}

impl From<&'static tracing_core::Metadata<'static>> for Metadata {
    fn from(metadata: &'static tracing_core::Metadata<'static>) -> Self {
        Self {
            name: metadata.name().to_string(),
            target: metadata.target().to_string(),
            level: *metadata.level(),
            module_path: metadata.module_path().map(ToString::to_string),
            file: metadata.file().map(ToString::to_string),
            line: metadata.line(),
            fields: metadata.fields().into(),
        }
    }
}

#[derive(Debug)]
#[allow(dead_code)] // Adding this because for some reason clippy is not recognizing that these fields are read in the From impl below
pub struct Attributes {
    metadata: Metadata,
    values: ValueSet,
    parent: Option<span::Id>,
}

impl From<&span::Attributes<'_>> for Attributes {
    fn from(attrs: &span::Attributes<'_>) -> Self {
        Self {
            metadata: attrs.metadata().into(),
            values: attrs.values().into(),
            parent: attrs.parent().map(Clone::clone),
        }
    }
}

#[derive(Debug)]
pub struct Context {}

impl<S> From<layer::Context<'_, S>> for Context {
    fn from(_ctx: layer::Context<'_, S>) -> Self {
        // TODO: gather more context
        // dbg!(ctx);

        Self {}
    }
}

#[derive(Debug)]
#[allow(dead_code)] // Adding this because for some reason clippy is not recognizing that these fields are read in the From impl below
pub struct Event {
    fields: FieldValueMap,
    metadata: Metadata,
    parent: Option<span::Id>,
}

impl Event {
    pub fn fields(&self) -> &FieldValueMap {
        &self.fields
    }
}

impl From<&event::Event<'_>> for Event {
    fn from(event: &event::Event<'_>) -> Self {
        // Visitor is mutated to capture field-value pairs from Event
        let mut visitor = FieldValueVisitor::default();
        event.record(&mut visitor);

        Self {
            fields: visitor.take_data(),
            metadata: event.metadata().into(),
            parent: event.parent().map(Clone::clone),
        }
    }
}

#[derive(Debug)]
pub struct RecordValues {}

impl From<&span::Record<'_>> for RecordValues {
    fn from(_record: &span::Record<'_>) -> Self {
        // TODO: gather more context
        Self {}
    }
}

#[derive(Debug)]
pub enum Notification {
    NewSpan {
        id: span::Id,
        attributes: Attributes,
        ctx: Context,
    },
    Record {
        id: span::Id,
        values: RecordValues,
        ctx: Context,
    },
    Enter {
        id: span::Id,
        ctx: Context,
    },
    Exit {
        id: span::Id,
        ctx: Context,
    },
    Close {
        id: span::Id,
        ctx: Context,
    },
    FollowsFrom {
        span: span::Id,
        follows: span::Id,
        ctx: Context,
    },
    Event {
        event: Event,
        ctx: Context,
    },
    IdChange {
        old: span::Id,
        new: span::Id,
        ctx: Context,
    },
}

impl<S> LayerTransform<S> for Notification {
    fn from_new_span(
        attrs: &span::Attributes<'_>,
        id: &span::Id,
        ctx: layer::Context<'_, S>,
    ) -> Self {
        Notification::NewSpan {
            id: id.clone(),
            attributes: attrs.into(),
            ctx: ctx.into(),
        }
    }

    fn from_on_record(
        span: &span::Id,
        values: &span::Record<'_>,
        ctx: layer::Context<'_, S>,
    ) -> Self {
        Notification::Record {
            id: span.clone(),
            values: values.into(),
            ctx: ctx.into(),
        }
    }

    fn from_on_follows_from(
        span: &span::Id,
        follows: &span::Id,
        ctx: layer::Context<'_, S>,
    ) -> Self {
        Notification::FollowsFrom {
            span: span.clone(),
            follows: follows.clone(),
            ctx: ctx.into(),
        }
    }

    fn from_on_event(event: &event::Event<'_>, ctx: layer::Context<'_, S>) -> Self {
        Notification::Event {
            event: event.into(),
            ctx: ctx.into(),
        }
    }

    fn from_on_enter(id: &span::Id, ctx: layer::Context<'_, S>) -> Self {
        Notification::Enter {
            id: id.clone(),
            ctx: ctx.into(),
        }
    }

    fn from_on_exit(id: &span::Id, ctx: layer::Context<'_, S>) -> Self {
        Notification::Exit {
            id: id.clone(),
            ctx: ctx.into(),
        }
    }

    fn from_on_close(id: span::Id, ctx: layer::Context<'_, S>) -> Self {
        Notification::Close {
            id,
            ctx: ctx.into(),
        }
    }

    fn from_on_id_change(old: &span::Id, new: &span::Id, ctx: layer::Context<'_, S>) -> Self {
        Notification::IdChange {
            old: old.clone(),
            new: new.clone(),
            ctx: ctx.into(),
        }
    }
}

impl<S, T> layer::Layer<S> for &'static Layer<T>
where
    S: subscriber::Subscriber,
    T: LayerTransform<S>,
{
    // TODO: consider overriding default methods to retain/manipulate context from them too.

    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: layer::Context<'_, S>) {
        self.capture(T::from_on_record(span, values, ctx))
    }

    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: layer::Context<'_, S>) {
        self.capture(T::from_on_follows_from(span, follows, ctx))
    }

    fn on_event(&self, event: &event::Event<'_>, ctx: layer::Context<'_, S>) {
        self.capture(T::from_on_event(event, ctx))
    }

    fn on_enter(&self, id: &span::Id, ctx: layer::Context<'_, S>) {
        self.capture(T::from_on_enter(id, ctx))
    }

    fn on_exit(&self, id: &span::Id, ctx: layer::Context<'_, S>) {
        self.capture(T::from_on_exit(id, ctx))
    }

    fn on_close(&self, id: span::Id, ctx: layer::Context<'_, S>) {
        self.capture(T::from_on_close(id, ctx))
    }

    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: layer::Context<'_, S>) {
        self.capture(T::from_on_id_change(old, new, ctx))
    }
}