Options

use broccoli_queue::queue::PublishOptions;

pub struct PublishOptions {
    /// Time-to-live for the message
    pub ttl: Option<Duration>,
    
    /// Message priority (1-5, where 1 is highest)
    pub priority: Option<u8>,
    
    /// Delay before the message is published
    pub delay: Option<Duration>,
    
    /// Scheduled time for message delivery
    pub scheduled_at: Option<OffsetDateTime>,
}

let options = PublishOptions::builder()
    .delay(Duration::seconds(30))
    .priority(1)
    .ttl(Duration::hours(24))
    .build();

queue.publish("jobs", None, &job, Some(options)).await?;

pub const fn builder() -> PublishOptionsBuilder

pub const fn ttl(mut self, duration: Duration) -> Self

PublishOptions::builder()
    .ttl(Duration::hours(1))
    .build()

pub fn priority(mut self, priority: u8) -> Self

PublishOptions::builder()
    .priority(1)  // High priority
    .build()

pub const fn delay(mut self, duration: Duration) -> Self

PublishOptions::builder()
    .delay(Duration::minutes(5))
    .build()

pub const fn schedule_at(mut self, time: OffsetDateTime) -> Self

use time::OffsetDateTime;

let tomorrow = OffsetDateTime::now_utc() + Duration::days(1);
PublishOptions::builder()
    .schedule_at(tomorrow)
    .build()

pub const fn build(self) -> PublishOptions

use broccoli_queue::queue::ConsumeOptions;

pub struct ConsumeOptions {
    /// Auto-acknowledge messages (default: false)
    pub auto_ack: Option<bool>,
    
    /// Enable fairness queue consumption (Redis only)
    pub fairness: Option<bool>,
    
    /// Wait duration between consume iterations
    pub consume_wait: Option<std::time::Duration>,
    
    /// Acknowledge after handler success (default: true)
    pub handler_ack: Option<bool>,
}

let options = ConsumeOptions::builder()
    .fairness(true)
    .auto_ack(false)
    .build();

queue.process_messages("jobs", Some(4), Some(options), handler).await?;

pub const fn auto_ack(mut self, auto_ack: bool) -> Self

pub const fn fairness(mut self, fairness: bool) -> Self

ConsumeOptions::builder()
    .fairness(true)
    .build()

pub const fn consume_wait(mut self, consume_wait: std::time::Duration) -> Self

ConsumeOptions::builder()
    .consume_wait(std::time::Duration::from_millis(10))
    .build()

pub const fn handler_ack(mut self, followup: bool) -> Self

ConsumeOptions::builder()
    .handler_ack(false)
    .build()

pub const fn build(self) -> ConsumeOptions

use broccoli_queue::queue::RetryStrategy;

pub struct RetryStrategy {
    /// Whether failed messages should be retried
    pub retry_failed: bool,
    
    /// Maximum number of retry attempts
    pub attempts: Option<u8>,
}

impl Default for RetryStrategy {
    fn default() -> Self {
        Self {
            retry_failed: true,
            attempts: Some(3),
        }
    }
}

pub const fn new() -> Self

pub const fn with_attempts(mut self, attempts: u8) -> Self

RetryStrategy::new().with_attempts(5)

pub const fn retry_failed(mut self, retry_failed: bool) -> Self

// Disable retries - failures go directly to failed queue
RetryStrategy::new().retry_failed(false)

let queue = BroccoliQueue::builder("redis://localhost:6379")
    .failed_message_retry_strategy(
        RetryStrategy::new()
            .with_attempts(5)
            .retry_failed(true)
    )
    .build()
    .await?;

#[cfg(feature = "management")]
use broccoli_queue::brokers::management::QueueStatus;

pub struct QueueStatus {
    pub pending_count: u64,
    pub processing_count: u64,
    pub failed_count: u64,
}

#[cfg(feature = "management")]
{
    let status = queue.queue_status("jobs".into(), None).await?;
    println!("Pending: {}", status.pending_count);
    println!("Processing: {}", status.processing_count);
    println!("Failed: {}", status.failed_count);
}