import * as Context from "../Context.ts"
import * as Duration from "../Duration.ts"
import * as Effect from "../Effect.ts"
import * as Exit from "../Exit.ts"
import * as Fiber from "../Fiber.ts"
import { identity } from "../Function.ts"
import { pipeArguments } from "../Pipeable.ts"
import type * as RcRef from "../RcRef.ts"
import * as Scope from "../Scope.ts"
import * as Semaphore from "../Semaphore.ts"

const TypeId = "~effect/RcRef"

type State<A> = State.Empty | State.Acquired<A> | State.Closed

declare namespace State {
  interface Empty {
    readonly _tag: "Empty"
  }

  interface Acquired<A> {
    readonly _tag: "Acquired"
    readonly value: A
    readonly scope: Scope.Closeable
    fiber: Fiber.Fiber<void, never> | undefined
    refCount: number
    invalidated: boolean
  }

  interface Closed {
    readonly _tag: "Closed"
  }
}

const stateEmpty: State<never> = { _tag: "Empty" }
const stateClosed: State<never> = { _tag: "Closed" }

const variance: RcRef.RcRef.Variance<any, any> = {
  _A: identity,
  _E: identity
}

class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
  readonly [TypeId]: RcRef.RcRef.Variance<A, E> = variance

  pipe() {
    return pipeArguments(this, arguments)
  }

  state: State<A> = stateEmpty
  readonly semaphore = Semaphore.makeUnsafe(1)
  readonly acquire: Effect.Effect<A, E>
  readonly context: Context.Context<never>
  readonly scope: Scope.Scope
  readonly idleTimeToLive: Duration.Duration | undefined

  constructor(
    acquire: Effect.Effect<A, E>,
    context: Context.Context<never>,
    scope: Scope.Scope,
    idleTimeToLive: Duration.Duration | undefined
  ) {
    this.acquire = acquire
    this.context = context
    this.scope = scope
    this.idleTimeToLive = idleTimeToLive
  }
}

/** @internal */
export const make = <A, E, R>(options: {
  readonly acquire: Effect.Effect<A, E, R>
  readonly idleTimeToLive?: Duration.Input | undefined
}) =>
  Effect.withFiber<RcRef.RcRef<A, E>, never, R | Scope.Scope>((fiber) => {
    const context = fiber.context as Context.Context<R | Scope.Scope>
    const scope = Context.get(context, Scope.Scope)
    const ref = new RcRefImpl<A, E>(
      options.acquire as Effect.Effect<A, E>,
      context,
      scope,
      options.idleTimeToLive ? Duration.fromInputUnsafe(options.idleTimeToLive) : undefined
    )
    return Effect.as(
      Scope.addFinalizerExit(scope, () => {
        const close = ref.state._tag === "Acquired"
          ? Scope.close(ref.state.scope, Exit.void)
          : Effect.void
        ref.state = stateClosed
        return close
      }),
      ref
    )
  })

const getState = <A, E>(self: RcRefImpl<A, E>) =>
  Effect.uninterruptibleMask(function loop(restore): Effect.Effect<State.Acquired<A>, E> {
    switch (self.state._tag) {
      case "Closed": {
        return Effect.interrupt
      }
      case "Acquired": {
        self.state.refCount++
        return self.state.fiber
          ? Effect.as(Fiber.interrupt(self.state.fiber), self.state)
          : Effect.succeed(self.state)
      }
      case "Empty": {
        const scope = Scope.makeUnsafe()
        return self.semaphore.withPermit(
          Effect.suspend(() => {
            if (self.state._tag !== "Empty") {
              return loop(restore)
            }
            return restore(Effect.provideContext(
              self.acquire as Effect.Effect<A, E>,
              Context.add(self.context, Scope.Scope, scope)
            )).pipe(
              Effect.flatMap((value) => {
                if (self.state._tag === "Closed") {
                  return Effect.interrupt
                }
                const state: State.Acquired<A> = {
                  _tag: "Acquired",
                  value,
                  scope,
                  fiber: undefined,
                  refCount: 1,
                  invalidated: false
                }
                self.state = state
                return Effect.succeed(state)
              }),
              Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)
            )
          })
        )
      }
    }
  })

/** @internal */
export const get = Effect.fnUntraced(function*<A, E>(
  self_: RcRef.RcRef<A, E>
) {
  const self = self_ as RcRefImpl<A, E>
  const state = yield* getState(self)
  const scope = yield* Effect.scope
  const isFinite = self.idleTimeToLive !== undefined && Duration.isFinite(self.idleTimeToLive)
  yield* Scope.addFinalizerExit(scope, () => {
    state.refCount--
    if (state.refCount > 0) {
      return Effect.void
    }
    if (self.idleTimeToLive === undefined || state.invalidated) {
      if (self.state === state) {
        self.state = stateEmpty
      }
      return Scope.close(state.scope, Exit.void)
    } else if (!isFinite) {
      return Effect.void
    }
    state.fiber = Effect.sleep(self.idleTimeToLive).pipe(
      Effect.flatMap(() => {
        if (self.state === state && state.refCount === 0) {
          self.state = stateEmpty
          return Scope.close(state.scope, Exit.void)
        }
        return Effect.void
      }),
      Effect.ensuring(Effect.sync(() => {
        state.fiber = undefined
      })),
      Effect.runForkWith(self.context),
      Fiber.runIn(self.scope)
    )
    return Effect.void
  })
  return state.value
})

/** @internal */
export const invalidate = <A, E>(
  self_: RcRef.RcRef<A, E>
): Effect.Effect<void> => {
  const self = self_ as RcRefImpl<A, E>
  return Effect.uninterruptible(Effect.suspend(() => {
    if (self.state._tag !== "Acquired") {
      return Effect.void
    }
    const state = self.state
    self.state = stateEmpty
    state.invalidated = true
    if (state.refCount > 0) {
      return Effect.void
    }
    state.fiber?.interruptUnsafe()
    return Scope.close(state.scope, Exit.void)
  }))
}
