common

type BaseEngine struct {
	AccessKey    string
	AppSecretKey string
	State        engineState
	ClientID     string
	Logger       Logger
	ClientHash   string
	Ctx          context.Context
	// contains filtered or unexported fields
}

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

type BaseSubscription struct {
	EventName string
	Handlers  []EventHandler
	Mu        sync.RWMutex
	// contains filtered or unexported fields
}

type ClientConfig struct {
	AppSecretKey string
	ClientID     string
}

type ClientOption func(*ClientConfig)

type ConnectionError struct {
	Addr string
	Err  error
}

type ContinueResponse struct {
	Status    string `json:"status"`
	Action    string `json:"action"`
	EventName string `json:"eventName"`
}

type DeferResponse struct {
	Status            string    `json:"status"`
	Action            string    `json:"action"`
	EventID           string    `json:"eventId"`
	DelayMs           int64     `json:"delayMs"`
	ScheduledDelivery time.Time `json:"scheduledDelivery"`
	Timestamp         time.Time `json:"timestamp"`
}

type DiscardResponse struct {
	Status    string    `json:"status"`
	Action    string    `json:"action"`
	EventID   string    `json:"eventId"`
	Timestamp time.Time `json:"timestamp"`
}

type EnSyncError struct {
	Message string
	Type    string
	Err     error
}

type EncryptedMessage struct {
	Nonce              string `json:"nonce"`
	Ciphertext         string `json:"ciphertext"`
	EphemeralPublicKey string `json:"ephemeralPublicKey"`
}

type EncryptedSymmetric struct {
	Nonce      string `json:"nonce"`
	Ciphertext string `json:"ciphertext"`
}

type Engine interface {
	// CreateClient creates and authenticates a new client
	CreateClient(accessKey string, options ...ClientOption) error

	// Publish publishes an event to the EnSync system
	Publish(
		eventName string,
		recipients []string,
		payload map[string]interface{},
		metadata *EventMetadata,
		options *PublishOptions,
	) (string, error)

	// Subscribe subscribes to an event
	Subscribe(eventName string, options *SubscribeOptions) (Subscription, error)

	// Close closes the connection
	Close() error

	// GetClientPublicKey returns the client's public key
	GetClientPublicKey() string

	// AnalyzePayload analyzes a payload and returns metadata
	AnalyzePayload(payload map[string]interface{}) *PayloadMetadata

	// Context returns the engine's context
	Context() context.Context

	// Logger returns the engine's logger
	Logger() Logger
}

type EventHandler func(*EventPayload) error

type EventMetadata struct {
	Persist bool              `json:"persist"`
	Headers map[string]string `json:"headers"`
}

type EventPayload struct {
	EventName string                 `json:"eventName"`
	Idem      string                 `json:"idem"`
	Block     int64                  `json:"block"`
	Timestamp time.Time              `json:"timestamp"`
	Payload   map[string]interface{} `json:"payload"`
	Metadata  map[string]interface{} `json:"metadata"`
	Sender    string                 `json:"sender"`
}

type HybridEncryptedMessage struct {
	Type    string                      `json:"type"`
	Payload EncryptedSymmetric          `json:"payload"`
	Keys    map[string]EncryptedMessage `json:"keys"`
}

type Logger interface {
	Debug(msg string, keysAndValues ...interface{})
	Info(msg string, keysAndValues ...interface{})
	Warn(msg string, keysAndValues ...interface{})
	Error(msg string, keysAndValues ...interface{})
}

type Operation struct {
	Name    string
	Execute func(context.Context) error
}

type Option func(*engineConfig)

type PauseResponse struct {
	Status    string `json:"status"`
	Action    string `json:"action"`
	EventName string `json:"eventName"`
	Reason    string `json:"reason,omitempty"`
}

type PayloadMetadata struct {
	ByteSize int               `json:"byteSize"`
	Skeleton map[string]string `json:"skeleton"`
}

type PublishData struct {
	PayloadJSON     []byte
	MetadataJSON    []byte
	PayloadMetaJSON []byte
}

type PublishOptions struct {
	UseHybridEncryption bool `json:"useHybridEncryption"`
}

type SubscribeOptions struct {
	AutoAck      bool   `json:"autoAck"`
	AppSecretKey string `json:"appSecretKey"`
}

type Subscription interface {
	// AddHandler registers an event handler for this subscription
	AddHandler(handler EventHandler) func()

	// Ack acknowledges an event
	Ack(eventIdem string, block int64) error

	// Resume resumes event processing
	Resume() error

	// Pause pauses event processing
	Pause(reason string) error

	// Defer defers an event for later processing
	Defer(eventIdem string, delayMs int64, reason string) (*DeferResponse, error)

	// Discard permanently discards an event
	Discard(eventIdem string, reason string) (*DiscardResponse, error)

	// Rollback rolls back an event
	Rollback(eventIdem string, block int64) error

	// Replay requests a specific event to be sent again
	Replay(eventIdem string) (*EventPayload, error)

	// Unsubscribe unsubscribes from the event
	Unsubscribe() error
}

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

type TimeoutOption func(*timeoutConfig)