import type * as Cache from "../Cache.js"
import type * as Clock from "../Clock.js"
import * as Context from "../Context.js"
import * as Data from "../Data.js"
import * as Duration from "../Duration.js"
import type * as Effect from "../Effect.js"
import * as Equal from "../Equal.js"
import * as Exit from "../Exit.js"
import { pipe } from "../Function.js"
import * as HashSet from "../HashSet.js"
import * as MutableHashMap from "../MutableHashMap.js"
import * as MutableQueue from "../MutableQueue.js"
import * as MutableRef from "../MutableRef.js"
import * as Option from "../Option.js"
import { pipeArguments } from "../Pipeable.js"
import * as Scope from "../Scope.js"
import type * as ScopedCache from "../ScopedCache.js"
import * as cache_ from "./cache.js"
import * as effect from "./core-effect.js"
import * as core from "./core.js"
import * as fiberRuntime from "./fiberRuntime.js"

/**
 * The `CacheState` represents the mutable state underlying the cache.
 *
 * @internal
 */
export interface CacheState<in out Key, out Value, out Error = never> {
  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
  keys: cache_.KeySet<Key> // mutable by design
  accesses: MutableQueue.MutableQueue<cache_.MapKey<Key>> // mutable by design
  updating: MutableRef.MutableRef<boolean> // mutable by design
  hits: number // mutable by design
  misses: number // mutable by design
}

/** @internal */
export const makeCacheState = <Key, Value, Error = never>(
  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
  keys: cache_.KeySet<Key>,
  accesses: MutableQueue.MutableQueue<cache_.MapKey<Key>>,
  updating: MutableRef.MutableRef<boolean>,
  hits: number,
  misses: number
): CacheState<Key, Value, Error> => ({
  map,
  keys,
  accesses,
  updating,
  hits,
  misses
})

/**
 * Constructs an initial cache state.
 *
 * @internal
 */
export const initialCacheState = <Key, Value, Error = never>(): CacheState<Key, Value, Error> =>
  makeCacheState(
    MutableHashMap.empty(),
    cache_.makeKeySet(),
    MutableQueue.unbounded(),
    MutableRef.make(false),
    0,
    0
  )

/**
 * A `MapValue` represents a value in the cache. A value may either be
 * `Pending` with a `Promise` that will contain the result of computing the
 * lookup function, when it is available, or `Complete` with an `Exit` value
 * that contains the result of computing the lookup function.
 *
 * @internal
 */
export type MapValue<Key, Value, Error> =
  | Complete<Key, Value, Error>
  | Pending<Key, Value, Error>
  | Refreshing<Key, Value, Error>

/** @internal */
export interface Complete<out Key, out Value, out Error> {
  readonly _tag: "Complete"
  readonly key: cache_.MapKey<Key>
  readonly exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>
  readonly ownerCount: MutableRef.MutableRef<number>
  readonly entryStats: Cache.EntryStats
  readonly timeToLive: number
}

/** @internal */
export interface Pending<out Key, out Value, out Error> {
  readonly _tag: "Pending"
  readonly key: cache_.MapKey<Key>
  readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
}

/** @internal */
export interface Refreshing<out Key, out Value, out Error> {
  readonly _tag: "Refreshing"
  readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
  readonly complete: Complete<Key, Value, Error>
}

/** @internal */
export const complete = <Key, Value, Error = never>(
  key: cache_.MapKey<Key>,
  exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
  ownerCount: MutableRef.MutableRef<number>,
  entryStats: Cache.EntryStats,
  timeToLive: number
): Complete<Key, Value, Error> =>
  Data.struct({
    _tag: "Complete",
    key,
    exit,
    ownerCount,
    entryStats,
    timeToLive
  })

/** @internal */
export const pending = <Key, Value, Error = never>(
  key: cache_.MapKey<Key>,
  scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
): Pending<Key, Value, Error> =>
  Data.struct({
    _tag: "Pending",
    key,
    scoped
  })

/** @internal */
export const refreshing = <Key, Value, Error = never>(
  scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>,
  complete: Complete<Key, Value, Error>
): Refreshing<Key, Value, Error> =>
  Data.struct({
    _tag: "Refreshing",
    scoped,
    complete
  })

/** @internal */
export const toScoped = <Key, Value, Error = never>(
  self: Complete<Key, Value, Error>
): Effect.Effect<Value, Error, Scope.Scope> =>
  Exit.matchEffect(self.exit, {
    onFailure: (cause) => core.failCause(cause),
    onSuccess: ([value]) =>
      fiberRuntime.acquireRelease(
        core.as(core.sync(() => MutableRef.incrementAndGet(self.ownerCount)), value),
        () => releaseOwner(self)
      )
  })

/** @internal */
export const releaseOwner = <Key, Value, Error = never>(
  self: Complete<Key, Value, Error>
): Effect.Effect<void> =>
  Exit.matchEffect(self.exit, {
    onFailure: () => core.void,
    onSuccess: ([, finalizer]) =>
      core.flatMap(
        core.sync(() => MutableRef.decrementAndGet(self.ownerCount)),
        (numOwner) => effect.when(finalizer(Exit.void), () => numOwner === 0)
      )
  })

/** @internal */
const ScopedCacheSymbolKey = "effect/ScopedCache"

/** @internal */
export const ScopedCacheTypeId: ScopedCache.ScopedCacheTypeId = Symbol.for(
  ScopedCacheSymbolKey
) as ScopedCache.ScopedCacheTypeId

const scopedCacheVariance = {
  /* c8 ignore next */
  _Key: (_: unknown) => _,
  /* c8 ignore next */
  _Error: (_: never) => _,
  /* c8 ignore next */
  _Value: (_: never) => _
}

class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value>
  implements ScopedCache.ScopedCache<Key, Value, Error>
{
  readonly [ScopedCacheTypeId] = scopedCacheVariance
  readonly cacheState: CacheState<Key, Value, Error>
  constructor(
    readonly capacity: number,
    readonly scopedLookup: ScopedCache.Lookup<Key, Value, Error, Environment>,
    readonly clock: Clock.Clock,
    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration,
    readonly context: Context.Context<Environment>
  ) {
    this.cacheState = initialCacheState()
  }

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

  get cacheStats(): Effect.Effect<Cache.CacheStats> {
    return core.sync(() =>
      cache_.makeCacheStats({
        hits: this.cacheState.hits,
        misses: this.cacheState.misses,
        size: MutableHashMap.size(this.cacheState.map)
      })
    )
  }

  getOption(key: Key): Effect.Effect<Option.Option<Value>, Error, Scope.Scope> {
    return core.suspend(() =>
      Option.match(MutableHashMap.get(this.cacheState.map, key), {
        onNone: () => effect.succeedNone,
        onSome: (value) => core.flatten(this.resolveMapValue(value))
      })
    )
  }

  getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>, never, Scope.Scope> {
    return core.suspend(() =>
      Option.match(MutableHashMap.get(this.cacheState.map, key), {
        onNone: () => effect.succeedNone,
        onSome: (value) =>
          core.flatten(this.resolveMapValue(value, true)) as Effect.Effect<Option.Option<Value>, never, Scope.Scope>
      })
    )
  }

  contains(key: Key): Effect.Effect<boolean> {
    return core.sync(() => MutableHashMap.has(this.cacheState.map, key))
  }

  entryStats(key: Key): Effect.Effect<Option.Option<Cache.EntryStats>> {
    return core.sync(() => {
      const value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
      if (value === undefined) {
        return Option.none()
      }
      switch (value._tag) {
        case "Complete": {
          return Option.some(cache_.makeEntryStats(value.entryStats.loadedMillis))
        }
        case "Pending": {
          return Option.none()
        }
        case "Refreshing": {
          return Option.some(cache_.makeEntryStats(value.complete.entryStats.loadedMillis))
        }
      }
    })
  }

  get(key: Key): Effect.Effect<Value, Error, Scope.Scope> {
    return pipe(
      this.lookupValueOf(key),
      effect.memoize,
      core.flatMap((lookupValue) =>
        core.suspend(() => {
          let k: cache_.MapKey<Key> | undefined = undefined
          let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
          if (value === undefined) {
            k = cache_.makeMapKey(key)
            if (MutableHashMap.has(this.cacheState.map, key)) {
              value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
            } else {
              MutableHashMap.set(this.cacheState.map, key, pending(k, lookupValue))
            }
          }
          if (value === undefined) {
            this.trackMiss()
            return core.zipRight(
              this.ensureMapSizeNotExceeded(k!),
              lookupValue
            )
          }

          return core.map(
            this.resolveMapValue(value),
            core.flatMap(Option.match({
              onNone: () => {
                const val = value as Complete<Key, Value, Error>
                const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
                if (Equal.equals(current, value)) {
                  MutableHashMap.remove(this.cacheState.map, key)
                }
                return pipe(
                  this.ensureMapSizeNotExceeded(val.key),
                  core.zipRight(releaseOwner(val)),
                  core.zipRight(this.get(key))
                )
              },
              onSome: core.succeed
            }))
          )
        })
      ),
      core.flatten
    )
  }

  invalidate(key: Key): Effect.Effect<void> {
    return core.suspend(() => {
      if (MutableHashMap.has(this.cacheState.map, key)) {
        const mapValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))!
        MutableHashMap.remove(this.cacheState.map, key)
        switch (mapValue._tag) {
          case "Complete": {
            return releaseOwner(mapValue)
          }
          case "Pending": {
            return core.void
          }
          case "Refreshing": {
            return releaseOwner(mapValue.complete)
          }
        }
      }
      return core.void
    })
  }

  get invalidateAll(): Effect.Effect<void> {
    return fiberRuntime.forEachConcurrentDiscard(
      HashSet.fromIterable(Array.from(this.cacheState.map).map(([key]) => key)),
      (key) => this.invalidate(key),
      false,
      false
    )
  }

  refresh(key: Key): Effect.Effect<void, Error> {
    return pipe(
      this.lookupValueOf(key),
      effect.memoize,
      core.flatMap((scoped) => {
        let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
        let newKey: cache_.MapKey<Key> | undefined = undefined
        if (value === undefined) {
          newKey = cache_.makeMapKey(key)
          if (MutableHashMap.has(this.cacheState.map, key)) {
            value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
          } else {
            MutableHashMap.set(this.cacheState.map, key, pending(newKey, scoped))
          }
        }
        let finalScoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
        if (value === undefined) {
          finalScoped = core.zipRight(
            this.ensureMapSizeNotExceeded(newKey!),
            scoped
          )
        } else {
          switch (value._tag) {
            case "Complete": {
              if (this.hasExpired(value.timeToLive)) {
                finalScoped = core.succeed(this.get(key))
              } else {
                const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
                if (Equal.equals(current, value)) {
                  const mapValue = refreshing(scoped, value)
                  MutableHashMap.set(this.cacheState.map, key, mapValue)
                  finalScoped = scoped
                } else {
                  finalScoped = core.succeed(this.get(key))
                }
              }
              break
            }
            case "Pending": {
              finalScoped = value.scoped
              break
            }
            case "Refreshing": {
              finalScoped = value.scoped
              break
            }
          }
        }
        return core.flatMap(finalScoped, (s) => fiberRuntime.scopedEffect(core.asVoid(s)))
      })
    )
  }

  get size(): Effect.Effect<number> {
    return core.sync(() => MutableHashMap.size(this.cacheState.map))
  }

  resolveMapValue(
    value: MapValue<Key, Value, Error>,
    ignorePending = false
  ): Effect.Effect<Effect.Effect<Option.Option<Value>, Error, Scope.Scope>> {
    switch (value._tag) {
      case "Complete": {
        this.trackHit()
        if (this.hasExpired(value.timeToLive)) {
          return core.succeed(effect.succeedNone)
        }
        return core.as(
          this.ensureMapSizeNotExceeded(value.key),
          effect.asSome(toScoped(value))
        )
      }
      case "Pending": {
        this.trackHit()

        if (ignorePending) {
          return core.succeed(effect.succeedNone)
        }

        return core.zipRight(
          this.ensureMapSizeNotExceeded(value.key),
          core.map(value.scoped, effect.asSome)
        )
      }
      case "Refreshing": {
        this.trackHit()
        if (this.hasExpired(value.complete.timeToLive)) {
          if (ignorePending) {
            return core.succeed(effect.succeedNone)
          }
          return core.zipRight(
            this.ensureMapSizeNotExceeded(value.complete.key),
            core.map(value.scoped, effect.asSome)
          )
        }
        return core.as(
          this.ensureMapSizeNotExceeded(value.complete.key),
          effect.asSome(toScoped(value.complete))
        )
      }
    }
  }

  lookupValueOf(key: Key): Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>> {
    return pipe(
      core.onInterrupt(
        core.flatMap(Scope.make(), (scope) =>
          pipe(
            this.scopedLookup(key),
            core.provideContext(pipe(this.context, Context.add(Scope.Scope, scope))),
            core.exit,
            core.map((exit) => [exit, ((exit) => Scope.close(scope, exit)) as Scope.Scope.Finalizer] as const)
          )),
        () => core.sync(() => MutableHashMap.remove(this.cacheState.map, key))
      ),
      core.flatMap(([exit, release]) => {
        const now = this.clock.unsafeCurrentTimeMillis()
        const expiredAt = now + Duration.toMillis(this.timeToLive(exit))
        switch (exit._tag) {
          case "Success": {
            const exitWithFinalizer: Exit.Exit<[Value, Scope.Scope.Finalizer]> = Exit.succeed([
              exit.value,
              release
            ])
            const completedResult = complete<Key, Value, Error>(
              cache_.makeMapKey(key),
              exitWithFinalizer,
              MutableRef.make(1),
              cache_.makeEntryStats(now),
              expiredAt
            )
            let previousValue: MapValue<Key, Value, Error> | undefined = undefined
            if (MutableHashMap.has(this.cacheState.map, key)) {
              previousValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
            }
            MutableHashMap.set(this.cacheState.map, key, completedResult)
            return core.sync(() =>
              core.flatten(
                core.as(
                  this.cleanMapValue(previousValue),
                  toScoped(completedResult)
                )
              )
            )
          }
          case "Failure": {
            const completedResult = complete<Key, Value, Error>(
              cache_.makeMapKey(key),
              exit as Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
              MutableRef.make(0),
              cache_.makeEntryStats(now),
              expiredAt
            )
            let previousValue: MapValue<Key, Value, Error> | undefined = undefined
            if (MutableHashMap.has(this.cacheState.map, key)) {
              previousValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
            }
            MutableHashMap.set(this.cacheState.map, key, completedResult)
            return core.zipRight(
              release(exit),
              core.sync(() =>
                core.flatten(
                  core.as(
                    this.cleanMapValue(previousValue),
                    toScoped(completedResult)
                  )
                )
              )
            )
          }
        }
      }),
      effect.memoize,
      core.flatten
    )
  }

  hasExpired(timeToLive: number): boolean {
    return this.clock.unsafeCurrentTimeMillis() > timeToLive
  }

  trackHit(): void {
    this.cacheState.hits = this.cacheState.hits + 1
  }

  trackMiss(): void {
    this.cacheState.misses = this.cacheState.misses + 1
  }

  trackAccess(key: cache_.MapKey<Key>): Array<MapValue<Key, Value, Error>> {
    const cleanedKeys: Array<MapValue<Key, Value, Error>> = []
    MutableQueue.offer(this.cacheState.accesses, key)
    if (MutableRef.compareAndSet(this.cacheState.updating, false, true)) {
      let loop = true
      while (loop) {
        const key = MutableQueue.poll(this.cacheState.accesses, MutableQueue.EmptyMutableQueue)
        if (key === MutableQueue.EmptyMutableQueue) {
          loop = false
        } else {
          this.cacheState.keys.add(key)
        }
      }
      let size = MutableHashMap.size(this.cacheState.map)
      loop = size > this.capacity
      while (loop) {
        const key = this.cacheState.keys.remove()
        if (key === undefined) {
          loop = false
        } else {
          if (MutableHashMap.has(this.cacheState.map, key.current)) {
            const removed = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key.current))!
            MutableHashMap.remove(this.cacheState.map, key.current)
            size = size - 1
            cleanedKeys.push(removed)
            loop = size > this.capacity
          }
        }
      }
      MutableRef.set(this.cacheState.updating, false)
    }
    return cleanedKeys
  }

  cleanMapValue(mapValue: MapValue<Key, Value, Error> | undefined): Effect.Effect<void> {
    if (mapValue === undefined) {
      return core.void
    }
    switch (mapValue._tag) {
      case "Complete": {
        return releaseOwner(mapValue)
      }
      case "Pending": {
        return core.void
      }
      case "Refreshing": {
        return releaseOwner(mapValue.complete)
      }
    }
  }

  ensureMapSizeNotExceeded(key: cache_.MapKey<Key>): Effect.Effect<void> {
    return fiberRuntime.forEachConcurrentDiscard(
      this.trackAccess(key),
      (cleanedMapValue) => this.cleanMapValue(cleanedMapValue),
      false,
      false
    )
  }
}

/** @internal */
export const make = <Key, Value, Error = never, Environment = never>(
  options: {
    readonly lookup: ScopedCache.Lookup<Key, Value, Error, Environment>
    readonly capacity: number
    readonly timeToLive: Duration.DurationInput
  }
): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> => {
  const timeToLive = Duration.decode(options.timeToLive)
  return makeWith({
    capacity: options.capacity,
    lookup: options.lookup,
    timeToLive: () => timeToLive
  })
}

/** @internal */
export const makeWith = <Key, Value, Error = never, Environment = never>(
  options: {
    readonly capacity: number
    readonly lookup: ScopedCache.Lookup<Key, Value, Error, Environment>
    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
  }
): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> =>
  core.flatMap(
    effect.clock,
    (clock) =>
      buildWith(
        options.capacity,
        options.lookup,
        clock,
        (exit) => Duration.decode(options.timeToLive(exit))
      )
  )

const buildWith = <Key, Value, Error = never, Environment = never>(
  capacity: number,
  scopedLookup: ScopedCache.Lookup<Key, Value, Error, Environment>,
  clock: Clock.Clock,
  timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration
): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> =>
  fiberRuntime.acquireRelease(
    core.flatMap(
      core.context<Environment>(),
      (context) =>
        core.sync(() =>
          new ScopedCacheImpl(
            capacity,
            scopedLookup,
            clock,
            timeToLive,
            context
          )
        )
    ),
    (cache) => cache.invalidateAll
  )