import { Effect, Fiber, ScopedCache, Scope, ServiceMap } from "effect"
import { Instance, type InstanceContext } from "@/project/instance"
import { Context } from "@/util/context"
import { InstanceRef } from "./instance-ref"
import { registerDisposer } from "./instance-registry"

const TypeId = "~opencode/InstanceState"

export interface InstanceState<A, E = never, R = never> {
  readonly [TypeId]: typeof TypeId
  readonly cache: ScopedCache.ScopedCache<string, A, E, R>
}

export namespace InstanceState {
  export const bind = <F extends (...args: any[]) => any>(fn: F): F => {
    try {
      return Instance.bind(fn)
    } catch (err) {
      if (!(err instanceof Context.NotFound)) throw err
    }
    const fiber = Fiber.getCurrent()
    const ctx = fiber ? ServiceMap.getReferenceUnsafe(fiber.services, InstanceRef) : undefined
    if (!ctx) return fn
    return ((...args: any[]) => Instance.restore(ctx, () => fn(...args))) as F
  }

  export const context = Effect.gen(function* () {
    return (yield* InstanceRef) ?? Instance.current
  })

  export const directory = Effect.map(context, (ctx) => ctx.directory)

  export const make = <A, E = never, R = never>(
    init: (ctx: InstanceContext) => Effect.Effect<A, E, R | Scope.Scope>,
  ): Effect.Effect<InstanceState<A, E, Exclude<R, Scope.Scope>>, never, R | Scope.Scope> =>
    Effect.gen(function* () {
      const cache = yield* ScopedCache.make<string, A, E, R>({
        capacity: Number.POSITIVE_INFINITY,
        lookup: () =>
          Effect.gen(function* () {
            return yield* init(yield* context)
          }),
      })

      const off = registerDisposer((directory) => Effect.runPromise(ScopedCache.invalidate(cache, directory)))
      yield* Effect.addFinalizer(() => Effect.sync(off))

      return {
        [TypeId]: TypeId,
        cache,
      }
    })

  export const get = <A, E, R>(self: InstanceState<A, E, R>) =>
    Effect.gen(function* () {
      return yield* ScopedCache.get(self.cache, yield* directory)
    })

  export const use = <A, E, R, B>(self: InstanceState<A, E, R>, select: (value: A) => B) =>
    Effect.map(get(self), select)

  export const useEffect = <A, E, R, B, E2, R2>(
    self: InstanceState<A, E, R>,
    select: (value: A) => Effect.Effect<B, E2, R2>,
  ) => Effect.flatMap(get(self), select)

  export const has = <A, E, R>(self: InstanceState<A, E, R>) =>
    Effect.gen(function* () {
      return yield* ScopedCache.has(self.cache, yield* directory)
    })

  export const invalidate = <A, E, R>(self: InstanceState<A, E, R>) =>
    Effect.gen(function* () {
      return yield* ScopedCache.invalidate(self.cache, yield* directory)
    })

  /**
   * Effect finalizers run on the fiber scheduler after the original async
   * boundary, so ALS reads like Instance.directory can be gone by then.
   */
  export const withALS = <T>(fn: () => T) => Effect.map(context, (ctx) => Instance.restore(ctx, fn))
}
