export declare const makeManager: Effect.Effect<PlatformWorker, never, WorkerManager>

export declare const makePool: <W>() => <I, E, O>(
  options: WorkerPool.Options<I, W>
) => Effect.Effect<Scope.Scope | WorkerManager, never, WorkerPool<I, E, O>>

export declare const makePoolLayer: <W>(
  managerLayer: Layer.Layer<never, never, WorkerManager>
) => <Tag, I, E, O>(
  tag: Context.Tag<Tag, WorkerPool<I, E, O>>,
  options: WorkerPool.Options<I, W>
) => Layer.Layer<never, never, Tag>

export declare const makePoolSerialized: <W>() => <I extends Schema.TaggedRequest.Any>(
  options: SerializedWorkerPool.Options<I, W>
) => Effect.Effect<Scope.Scope | WorkerManager, never, SerializedWorkerPool<I>>

export declare const makeSerialized: <I extends Schema.TaggedRequest.Any, W = unknown>(
  options: SerializedWorker.Options<I, W>
) => Effect.Effect<Scope.Scope | WorkerManager, WorkerError, SerializedWorker<I>>

export declare const layerManager: Layer.Layer<PlatformWorker, never, WorkerManager>

export declare const makePoolSerializedLayer: <W>(
  managerLayer: Layer.Layer<never, never, WorkerManager>
) => <Tag, I extends Schema.TaggedRequest.Any>(
  tag: Context.Tag<Tag, SerializedWorkerPool<I>>,
  options: SerializedWorkerPool.Options<I, W>
) => Layer.Layer<never, never, Tag>

export interface BackingWorker<I, O> {
  readonly fiber: Fiber.Fiber<WorkerError, never>
  readonly send: (message: I, transfers?: ReadonlyArray<unknown>) => Effect.Effect<never, WorkerError, void>
  readonly queue: Queue.Dequeue<BackingWorker.Message<O>>
}

export type Message<O> = readonly [ready: 0] | readonly [data: 1, O]

export interface PlatformWorker {
  readonly [PlatformWorkerTypeId]: PlatformWorkerTypeId
  readonly spawn: <I, O>(worker: unknown) => Effect.Effect<Scope.Scope, WorkerError, BackingWorker<I, O>>
}

export interface SerializedWorker<I extends Schema.TaggedRequest.Any> {
  readonly id: number
  readonly execute: <Req extends I>(
    message: Req
  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
    ? Stream.Stream<never, E | WorkerError | ParseResult.ParseError, A>
    : never
  readonly executeEffect: <Req extends I>(
    message: Req
  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, A>
    : never
}

export interface Options<I, W = unknown> {
  readonly spawn: (id: number) => W
  readonly permits?: number
  readonly queue?: WorkerQueue<I>
  readonly initialMessage?: LazyArg<I>
}

export interface SerializedWorkerPool<I extends Schema.TaggedRequest.Any> {
  readonly backing: Pool.Pool<WorkerError, SerializedWorker<I>>
  readonly broadcast: <Req extends I>(
    message: Req
  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer _A>
    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, void>
    : never
  readonly execute: <Req extends I>(
    message: Req
  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
    ? Stream.Stream<never, E | WorkerError | ParseResult.ParseError, A>
    : never
  readonly executeEffect: <Req extends I>(
    message: Req
  ) => Req extends Serializable.WithResult<infer _IE, infer E, infer _IA, infer A>
    ? Effect.Effect<never, E | WorkerError | ParseResult.ParseError, A>
    : never
}

export type Options<I, W = unknown> = SerializedWorker.Options<I, W> &
  (
    | {
        readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
        readonly size: number
      }
    | {
        readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
        readonly minSize: number
        readonly maxSize: number
        readonly timeToLive: Duration.DurationInput
      }
  )

export interface Worker<I, E, O> {
  readonly id: number
  readonly execute: (message: I) => Stream.Stream<never, E | WorkerError, O>
  readonly executeEffect: (message: I) => Effect.Effect<never, E | WorkerError, O>
}

export interface Options<I, W = unknown> {
  readonly spawn: (id: number) => W
  readonly encode?: (message: I) => Effect.Effect<never, WorkerError, unknown>
  readonly transfers?: (message: I) => ReadonlyArray<unknown>
  readonly permits?: number
  readonly queue?: WorkerQueue<I>
  readonly initialMessage?: LazyArg<I>
}

export type Request<I = unknown> = readonly [id: number, data: 0, I] | readonly [id: number, interrupt: 1]

export type Response<E, O = unknown> =
  | readonly [id: number, data: 0, ReadonlyArray<O>]
  | readonly [id: number, end: 1]
  | readonly [id: number, end: 1, ReadonlyArray<O>]
  | readonly [id: number, error: 2, E]
  | readonly [id: number, defect: 3, unknown]

export interface WorkerManager {
  readonly [WorkerManagerTypeId]: WorkerManagerTypeId
  readonly spawn: <I, E, O>(options: Worker.Options<I>) => Effect.Effect<Scope.Scope, WorkerError, Worker<I, E, O>>
}

export interface WorkerPool<I, E, O> {
  readonly backing: Pool.Pool<WorkerError, Worker<I, E, O>>
  readonly broadcast: (message: I) => Effect.Effect<never, E | WorkerError, void>
  readonly execute: (message: I) => Stream.Stream<never, E | WorkerError, O>
  readonly executeEffect: (message: I) => Effect.Effect<never, E | WorkerError, O>
}

export type Options<I, W = unknown> = Worker.Options<I, W> &
  (
    | {
        readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
        readonly size: number
      }
    | {
        readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
        readonly minSize: number
        readonly maxSize: number
        readonly timeToLive: Duration.DurationInput
      }
  )

export interface WorkerQueue<I> {
  readonly offer: (id: number, item: I) => Effect.Effect<never, never, void>
  readonly take: Effect.Effect<never, never, readonly [id: number, item: I]>
  readonly shutdown: Effect.Effect<never, never, void>
}

export declare const PlatformWorker: Context.Tag<PlatformWorker, PlatformWorker>

export declare const WorkerManager: Context.Tag<WorkerManager, WorkerManager>

export declare const PlatformWorkerTypeId: typeof PlatformWorkerTypeId

export type PlatformWorkerTypeId = typeof PlatformWorkerTypeId

export declare const WorkerManagerTypeId: typeof WorkerManagerTypeId

export type WorkerManagerTypeId = typeof WorkerManagerTypeId