event

type AMQPChanOps interface {
	Publish(exchange, key string, mandatory, immediate bool, msg amqp.Publishing) error
	Consume(queue, consumer string, autoAck, exclusive, noLocal, noWait bool, args amqp.Table) (<-chan amqp.Delivery, error)
}

type AMQPChanSetup interface {
	ExchangeBind(destination, key, source string, noWait bool, args amqp.Table) error
	ExchangeDeclare(name, kind string, durable, autoDelete, internal, noWait bool, args amqp.Table) error
	ExchangeDeclarePassive(name, kind string, durable, autoDelete, internal, noWait bool, args amqp.Table) error
	ExchangeDelete(name string, ifUnused, noWait bool) error
	ExchangeUnbind(destination, key, source string, noWait bool, args amqp.Table) error
	QueueBind(name, key, exchange string, noWait bool, args amqp.Table) error
	QueueDeclare(name string, durable, autoDelete, exclusive, noWait bool, args amqp.Table) (amqp.Queue, error)
	QueueDeclarePassive(name string, durable, autoDelete, exclusive, noWait bool, args amqp.Table) (amqp.Queue, error)
	QueueDelete(name string, ifUnused, ifEmpty, noWait bool) (int, error)
	QueueInspect(name string) (amqp.Queue, error)
	QueueUnbind(name, key, exchange string, args amqp.Table) error
	Qos(prefetchCount, prefetchSize int, global bool) error
}

type AMQPClient interface {
	AMQPProducer
	AMQPConsumer
}

type AMQPConnectFunc func(ctx context.Context, uri string, confirms chan amqp.Confirmation, closed chan *amqp.Error) (AMQPChanOps, error)

type AMQPConsumer interface {
	Consume(queue string, concurrency int, handler AMQPMessageHandler) error
	Shutdown(context.Context) error
}

type AMQPMessage struct {
	// Exchange and Key of message in the AMQP protocol.
	Exchange, Key string
	// Body is the payload of the message.
	Body interface{}
	// Persistent means whether this message should be persisted in durable
	// storage not to be lost on broker restarts.
	Persistent bool
	// Mandatory means that if the message cannot be routed to a queue, the
	// broker should return it to the sender. In other words, the broker will
	// try to put the message in at least one queue, and if there's no queue
	// bound to receive the message it will fail the publishing.
	Mandatory bool
	// ResultChan receives the result message from the publish operation. Used
	// to guarantee delivery of messages to the broker through confirmation.
	ResultChan chan<- PublishResult
	// WaitResult simplifies waiting for the result of a publish operation. If
	// true, `Publish` will only return after confirmation has been received for
	// the specific message. Cannot be specified together with a `ResultChan`.
	WaitResult bool
}

type AMQPMessageHandler func(amqp.Delivery) error

type AMQPProducer interface {
	Publish(ctx context.Context, msg AMQPMessage) error
	Shutdown(context.Context) error
}

type BindingArgs struct {
	Key      string
	Exchange string
	Args     amqp.Table
}

type ConsumeOptions struct {
	Stream string
	*StreamOptions
	*stream.ConsumerOptions
	// Whether to memorize the message offset in the stream and use it on
	// re-connections to continue from the last read message.
	MemorizeOffset bool
}

type Handler interface {
	HandleMessage(msg StreamMessage)
}

type PublishResult struct {
	Message AMQPMessage
	Error   error
}

type RawStreamOptions struct {
	MaxLengthBytes      string
	MaxSegmentSizeBytes string
	MaxAge              time.Duration
}

type SimpleProducer interface {
	Publish(ctx context.Context, key string, body interface{}, persistent bool) error
}

type StreamConsumer interface {
	ConsumeChan(ctx context.Context, opts ConsumeOptions) (<-chan StreamMessage, error)
	Consume(ctx context.Context, opts ConsumeOptions, handler Handler) error
	CheckConnection() error
	Close() error
}

type StreamMessage struct {
	stream.ConsumerContext
	*streamAmqp.Message
}

type StreamOptions struct {
	stream.StreamOptions
	Bindings []BindingArgs
}