#[async_trait]
pub trait EventProvider: Send + Sync {
    /// Publish an event, returning the provider-assigned sequence number
    async fn publish(&self, event: &Event) -> Result<u64>;

    /// Create a durable subscription (survives reconnects)
    async fn subscribe_durable(
        &self, consumer_name: &str, filter_subject: &str,
    ) -> Result<Box<dyn Subscription>>;

    /// Create an ephemeral subscription
    async fn subscribe(&self, filter_subject: &str) -> Result<Box<dyn Subscription>>;

    /// Fetch historical events
    async fn history(&self, filter_subject: Option<&str>, limit: usize) -> Result<Vec<Event>>;

    /// Delete a durable subscription by consumer name
    async fn unsubscribe(&self, consumer_name: &str) -> Result<()>;

    /// Get provider info (message count, bytes, consumers)
    async fn info(&self) -> Result<ProviderInfo>;

    /// Subject prefix for this provider (e.g., "events")
    fn subject_prefix(&self) -> &str;

    /// Provider name (e.g., "nats", "memory")
    fn name(&self) -> &str;

    // Default implementations (override for provider-specific behavior):
    fn build_subject(&self, category: &str, topic: &str) -> String { ... }
    fn category_subject(&self, category: &str) -> String { ... }
    async fn publish_with_options(&self, event: &Event, opts: &PublishOptions) -> Result<u64> { ... }
    async fn subscribe_durable_with_options(...) -> Result<Box<dyn Subscription>> { ... }
    async fn subscribe_with_options(...) -> Result<Box<dyn Subscription>> { ... }
    async fn health(&self) -> Result<bool> { ... }
}

use a3s_event::MemoryProvider;

// Default configuration
let provider = MemoryProvider::default();

use a3s_event::provider::memory::{MemoryProvider, MemoryConfig};

let provider = MemoryProvider::new(MemoryConfig {
    subject_prefix: "events".to_string(),
    max_events: 100_000,
    channel_capacity: 10_000,
});

use a3s_event::{NatsProvider, NatsConfig, StorageType};

let provider = NatsProvider::connect(NatsConfig {
    url: "nats://localhost:4222".to_string(),
    stream_name: "A3S_EVENTS".to_string(),
    subject_prefix: "events".to_string(),
    storage: StorageType::File,
    max_events: 100_000,
    max_age_secs: 604_800,  // 7 days
    ..Default::default()
}).await?;

use a3s_event::PublishOptions;

let opts = PublishOptions {
    msg_id: Some("order-001".into()),
    ..Default::default()
};
bus.publish_event_with_options(&event, &opts).await?;
// Duplicate publishes with the same msg_id are ignored within the dedup window

let mut subs = bus.create_subscriber("order-processor").await?;
for sub in &mut subs {
    while let Some(pending) = sub.next_manual_ack().await? {
        match process(&pending.received.event).await {
            Ok(()) => pending.ack().await?,
            Err(_) => pending.nak().await?,  // triggers redelivery
        }
    }
}

use a3s_event::{SubscribeOptions, DeliverPolicy, SubscriptionFilter};

bus.update_subscription(SubscriptionFilter {
    subscriber_id: "replay".to_string(),
    subjects: vec!["events.orders.>".to_string()],
    durable: true,
    options: Some(SubscribeOptions {
        deliver_policy: DeliverPolicy::ByStartSequence { sequence: 100 },
        ..Default::default()
    }),
}).await?;

use a3s_event::provider::{EventProvider, Subscription, ProviderInfo};
use a3s_event::types::Event;
use a3s_event::Result;
use async_trait::async_trait;

pub struct RedisProvider { /* ... */ }

#[async_trait]
impl EventProvider for RedisProvider {
    async fn publish(&self, event: &Event) -> Result<u64> { todo!() }

    async fn subscribe_durable(
        &self, consumer_name: &str, filter_subject: &str,
    ) -> Result<Box<dyn Subscription>> { todo!() }

    async fn subscribe(&self, filter_subject: &str) -> Result<Box<dyn Subscription>> { todo!() }

    async fn history(
        &self, filter_subject: Option<&str>, limit: usize,
    ) -> Result<Vec<Event>> { todo!() }

    async fn unsubscribe(&self, consumer_name: &str) -> Result<()> { todo!() }
    async fn info(&self) -> Result<ProviderInfo> { todo!() }

    // Only subject_prefix() and name() are required.
    // build_subject() and category_subject() have default implementations.
    fn subject_prefix(&self) -> &str { "events" }
    fn name(&self) -> &str { "redis" }
}

let bus = EventBus::new(RedisProvider::new(config));
bus.publish("orders", "created", "New order", "src", payload).await?;