import type * as Array from "effect/Array"
import * as Effect from "effect/Effect"
import { dual } from "effect/Function"
import * as Layer from "effect/Layer"
import type * as Scope from "effect/Scope"
import type * as Types from "effect/Types"
import type * as Context from "./Context.js"
import { type EffectGenUtils } from "./utils/gen.js"

export * from "effect/Layer"

type Make<S, E = never, R = never> = DependenciesOpt & (MakeEff<S, E, R> | MakeGenNo<S> | MakeGen<S, E, R>)

type MakeEff<S, E, R> = {
  readonly make: Effect.Effect<S, E, R>
}
type MakeGen<S, E = never, R = never> = {
  readonly make: () => Generator<Effect.Effect<any, E, R>, S>
}
type MakeGenNo<S> = {
  readonly make: () => Generator<unknown, S>
}
type MakeErr<Opts> = Opts extends { make: () => any } ? EffectGenUtils.Error<Opts["make"]> : never
type MakeContext<Opts> = Opts extends { make: () => any } ? EffectGenUtils.Context<Opts["make"]> : never

type DependenciesOpt = { dependencies?: Array.NonEmptyReadonlyArray<Layer.Any> }
type Dependencies = { dependencies: Array.NonEmptyReadonlyArray<Layer.Any> }

// Local replacements for removed Effect.Service.MakeDeps* types
type MakeDepsE<Opts> = Opts extends { dependencies: ReadonlyArray<Layer.Layer<any, infer E, any>> } ? E : never
type MakeDepsOut<Opts> = Opts extends { dependencies: ReadonlyArray<Layer.Layer<infer Out, any, any>> } ? Out : never

type PackedLayers<I, Opts> =
  & Layer.Layer<
    I,
    MakeErr<Opts> | MakeDepsE<Opts>,
    Exclude<MakeContext<Opts>, Scope.Scope | MakeDepsOut<Opts>>
  >
  & {
    withoutDependencies: Layer.Layer<I, MakeErr<Opts>, Exclude<MakeContext<Opts>, Scope.Scope>>
  }

type PackedOrUnpackedLayer<I, Opts> = Opts extends Dependencies ? PackedLayers<I, Opts> & {}
  : Layer.Layer<I, MakeErr<Opts>, MakeContext<Opts>>

export const make: {
  <I, S>(
    tag: Context.Service<I, S>
  ): <Opts extends Make<Types.NoInfer<S>, any, any>>(
    options: Opts
  ) => PackedOrUnpackedLayer<I, Opts>
  <I, S, Opts extends Make<Types.NoInfer<S>, any, any>>(
    tag: Context.Service<I, S>,
    options: Opts
  ): PackedOrUnpackedLayer<I, Opts>
} = dual(2, (tag, options) => {
  const effect = options.make[Symbol.toStringTag] === "GeneratorFunction"
    ? Effect.fnUntraced(options.make)()
    : options.make
  const withoutDependencies = Layer.effect(tag, effect)
  if (options.dependencies) {
    return Object.assign(
      withoutDependencies.pipe(Layer.provide(options.dependencies)),
      { withoutDependencies }
    )
  } else {
    return withoutDependencies
  }
})