pubsub

type ConsumeConfig struct {
	// MaxRetries is the maximum number of redelivery attempts before
	// the dispatcher routes the message to the DLQ. Counted across
	// the whole subscription lifetime; broker-level redelivery counts
	// are not consulted (different adapters track them differently).
	MaxRetries int

	// AckDeadline is the per-message handler timeout. The dispatcher
	// derives a context from the parent that cancels at this deadline,
	// so a stuck handler doesn't tie up the consume loop forever.
	AckDeadline time.Duration

	// BackoffMin / BackoffMax bracket the exponential backoff between
	// retry attempts. The dispatcher computes
	//     delay = min(BackoffMax, BackoffMin * 2^(attempt-1))
	// before re-presenting the message. Zero values pick framework
	// defaults (100ms / 30s).
	BackoffMin time.Duration
	BackoffMax time.Duration
}

type Deliver func(msg Message) Disposition

type Disposition int

type InMemoryTransport struct {
	// contains filtered or unexported fields
}

type Message struct {
	Topic        string
	Subscription string

	// Payload is the raw bytes from the broker. The Subscribe wrapper
	// runs Topic[T].decode before invoking the user's handler — so
	// handlers see typed T, not bytes.
	Payload []byte

	// Attrs is the optional metadata sent by the publisher (headers,
	// content-type, idempotency key). nil when none were set.
	Attrs map[string]string

	// DeliveryAttempt is 1 on first delivery, incremented on each
	// retry. The dispatcher uses this together with cfg.MaxRetries to
	// decide retry-vs-DLQ.
	DeliveryAttempt int
}

type SubscriptionConfig struct {
	// MaxRetries is the number of redeliveries the dispatcher
	// attempts before promoting to DLQ. Default: 3.
	MaxRetries int

	// AckDeadline bounds how long a single handler call may run
	// before the dispatcher cancels its context. The handler can
	// still take longer — Go doesn't preempt — but the cancellation
	// signals downstream calls to abort. Default: 30s.
	AckDeadline time.Duration

	// BackoffMin / BackoffMax are the exponential-backoff envelope
	// between retry attempts. Defaults: 100ms / 30s.
	BackoffMin time.Duration
	BackoffMax time.Duration
}

type SubscriptionInfo struct {
	Topic         string `json:"topic"`
	Name          string `json:"name"`
	MaxRetries    int    `json:"maxRetries,omitempty"`
	AckDeadlineMs int64  `json:"ackDeadlineMs,omitempty"`
}

type Topic[T any] struct {
	// contains filtered or unexported fields
}

type TopicConfig struct {
	// Description shows up in the manifest + dashboard so operators
	// know what the topic carries without reading source.
	Description string

	// Durable, when true, instructs the transport to persist messages
	// across broker restarts. RabbitMQ: durable exchange + persistent
	// publish. In-memory: ignored (everything is in-process anyway).
	Durable bool
}

type TopicInfo struct {
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
	Durable     bool   `json:"durable,omitempty"`
	PayloadType string `json:"payloadType,omitempty"`
}

type Transport interface {
	// Publish sends payload to topic. Implementations must encode the
	// optional attrs onto the wire (RabbitMQ headers, NATS Header) so
	// subscribers see them on Message.Attrs. Returning an error fails
	// the publishing call directly — at-least-once durability is the
	// caller's responsibility (typically: retry on transient errors,
	// log + drop on permanent ones).
	Publish(ctx context.Context, topic string, payload []byte, attrs map[string]string) error

	// Consume blocks until ctx is cancelled, calling deliver for each
	// received message. The dispatcher wraps deliver with the retry +
	// DLQ logic, so adapters only need to implement the lower-level
	// "next message → ack/nack/requeue" loop.
	//
	// cfg carries the per-subscription tuning (max retries, ack
	// deadline). Adapters that don't natively support a feature
	// (e.g. in-memory has no real ack deadline) MAY ignore the
	// matching field; the dispatcher does not depend on broker-side
	// enforcement.
	Consume(ctx context.Context, topic, subscription string, cfg ConsumeConfig, deliver Deliver) error

	// Close releases adapter resources (RabbitMQ connection, in-mem
	// channels). Called from fx.Stop. Idempotent — calling on an
	// already-closed transport must not panic.
	Close() error
}