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
	// Context carries the gRPC stream context for receive-side cancellation
	// (memory wait upper bound / disconnect).
	Context               context.Context
	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
	route.TableProvider
	// NewBatchPublisher creates a batch publisher whose timeout starts when Close seals the batch.
	NewBatchPublisher(timeout time.Duration) BatchPublisher
	NewChunkedSyncClient(node string, chunkSize uint32) (ChunkedSyncClient, error)
	// SetSelfNode stamps the publisher's own node identity onto the wire
	// (SenderNode / SenderRole / SenderTier on every SendRequest) and onto
	// the banyandb_lifecycle_migration_* metric labels. Pass "" for any
	// dimension the caller doesn't know (e.g. the lifecycle has no Role
	// enum entry; the tier is untracked when the co-located data node's
	// tier isn't known at boot time).
	SetSelfNode(name, role, tier string)
	// NewNodeSchemaStatusClient returns a client for the cluster.v1
	// NodeSchemaStatusService against the named node, sharing the underlying
	// *grpc.ClientConn from this queue client's existing connection pool.
	// The standalone local pipeline returns ErrNotImplemented so callers can
	// treat it as "no peer to probe" without a type-switch.
	NewNodeSchemaStatusClient(node string) (clusterv1.NodeSchemaStatusServiceClient, 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
	SetRouteProviders(providers map[string]route.TableProvider)
	// SetMetadataRepo enables fodc.v1.GroupLifecycleService — liaison-only
	// by design; data-node processes must not call it.
	SetMetadataRepo(repo metadata.Repo)
	// SetNodeSchemaStatusRepo enables cluster.v1.NodeSchemaStatusService —
	// per-node by design (reports the local schema cache); liaison and
	// data-node processes both call it.
	SetNodeSchemaStatusRepo(svc metadata.Service)
}

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
}