queue

type BatchPublisher interface {
	bus.Publisher
	Close() (map[string]*common.Error, error)
}

type ChunkedSyncClient interface {
	// SyncStreamingParts sends streaming parts using chunked transfer.
	SyncStreamingParts(ctx context.Context, parts []StreamingPartData) (*SyncResult, error)
	// Close releases resources associated with the client.
	Close() error
}

type ChunkedSyncFailureInjector interface {
	// BeforeSync returns whether the current SyncStreamingParts invocation should
	// short-circuit. The returned slice provides the failed parts that should be
	// reported back to the caller when a failure is injected.
	BeforeSync(parts []StreamingPartData) (bool, []FailedPart, error)
}

type ChunkedSyncHandler interface {
	// HandleFileChunk processes incoming file chunks as they arrive.
	// This method is called for each chunk of file data to enable streaming processing.
	HandleFileChunk(ctx *ChunkedSyncPartContext, chunk []byte) error

	// CreatePartHandler creates a new part handler for the given context.
	CreatePartHandler(ctx *ChunkedSyncPartContext) (PartHandler, error)
}

type ChunkedSyncPartContext struct {
	Handler               PartHandler
	Group                 string
	FileName              string
	PartType              string
	ID                    uint64
	CompressedSizeBytes   uint64
	UncompressedSizeBytes uint64
	TotalCount            uint64
	BlocksCount           uint64
	MinTimestamp          int64
	MaxTimestamp          int64
	MinKey                int64
	MaxKey                int64
	ShardID               uint32
}

type Client interface {
	run.Unit
	bus.Publisher
	bus.Broadcaster
	NewBatchPublisher(timeout time.Duration) BatchPublisher
	NewChunkedSyncClient(node string, chunkSize uint32) (ChunkedSyncClient, error)
	Register(bus.Topic, schema.EventHandler)
	OnAddOrUpdate(md schema.Metadata)
	GracefulStop()
	HealthyNodes() []string
}

type FailedPart struct {
	PartID string
	Error  string
}

type FileData struct {
	FileName string
	Data     []byte
}

type FileInfo struct {
	Reader fs.SeqReader
	Name   string
}

type PartHandler interface {
	NewPartType(ctx *ChunkedSyncPartContext) error
	FinishSync() error
	Close() error
}

type Queue interface {
	Client
	Server
	run.Service
}

type Server interface {
	run.Unit
	bus.Subscriber
	RegisterChunkedSyncHandler(topic bus.Topic, handler ChunkedSyncHandler)
	GetPort() *uint32
}

type StreamingPartData struct {
	Group                 string
	Topic                 string
	PartType              string
	Files                 []FileInfo
	ID                    uint64
	CompressedSizeBytes   uint64
	UncompressedSizeBytes uint64
	TotalCount            uint64
	BlocksCount           uint64
	MinTimestamp          int64
	MaxTimestamp          int64
	MinKey                int64
	MaxKey                int64
	ShardID               uint32
}

type SyncMetadata = clusterv1.SyncMetadata

type SyncResult struct {
	SessionID   string
	FailedParts []FailedPart
	TotalBytes  uint64
	DurationMs  int64
	ChunksCount uint32
	PartsCount  uint32
	Success     bool
}