import type * as Cache from "../Cache.js"
import type * as Clock from "../Clock.js"
import * as Context from "../Context.js"
import * as Deferred from "../Deferred.js"
import * as Duration from "../Duration.js"
import type * as Effect from "../Effect.js"
import * as Either from "../Either.js"
import * as Equal from "../Equal.js"
import * as Exit from "../Exit.js"
import type * as FiberId from "../FiberId.js"
import { pipe } from "../Function.js"
import * as Hash from "../Hash.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 { hasProperty } from "../Predicate.js"
import * as effect from "./core-effect.js"
import * as core from "./core.js"
import * as Data from "./data.js"
import { none } from "./fiberId.js"
import * as fiberRuntime from "./fiberRuntime.js"

/**
 * 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: MapKey<Key>
  readonly exit: Exit.Exit<Value, Error>
  readonly entryStats: Cache.EntryStats
  readonly timeToLiveMillis: number
}

/** @internal */
export interface Pending<out Key, in out Value, in out Error> {
  readonly _tag: "Pending"
  readonly key: MapKey<Key>
  readonly deferred: Deferred.Deferred<Value, Error>
}

/** @internal */
export interface Refreshing<out Key, in out Value, in out Error> {
  readonly _tag: "Refreshing"
  readonly deferred: Deferred.Deferred<Value, Error>
  readonly complete: Complete<Key, Value, Error>
}

/** @internal */
export const complete = <Key, Value, Error>(
  key: MapKey<Key>,
  exit: Exit.Exit<Value, Error>,
  entryStats: Cache.EntryStats,
  timeToLiveMillis: number
): MapValue<Key, Value, Error> =>
  Data.struct({
    _tag: "Complete" as const,
    key,
    exit,
    entryStats,
    timeToLiveMillis
  })

/** @internal */
export const pending = <Key, Value, Error>(
  key: MapKey<Key>,
  deferred: Deferred.Deferred<Value, Error>
): MapValue<Key, Value, Error> =>
  Data.struct({
    _tag: "Pending" as const,
    key,
    deferred
  })

/** @internal */
export const refreshing = <Key, Value, Error>(
  deferred: Deferred.Deferred<Value, Error>,
  complete: Complete<Key, Value, Error>
): MapValue<Key, Value, Error> =>
  Data.struct({
    _tag: "Refreshing" as const,
    deferred,
    complete
  })

/** @internal */
export const MapKeyTypeId = Symbol.for("effect/Cache/MapKey")

/** @internal */
export type MapKeyTypeId = typeof MapKeyTypeId

/**
 * A `MapKey` represents a key in the cache. It contains mutable references
 * to the previous key and next key in the `KeySet` to support an efficient
 * implementation of a sorted set of keys.
 *
 * @internal
 */
export interface MapKey<out K> extends Equal.Equal {
  readonly [MapKeyTypeId]: MapKeyTypeId
  readonly current: K
  previous: MapKey<K> | undefined // mutable by design
  next: MapKey<K> | undefined // mutable by design
}

class MapKeyImpl<out K> implements MapKey<K> {
  readonly [MapKeyTypeId]: MapKeyTypeId = MapKeyTypeId
  previous: MapKey<K> | undefined = undefined
  next: MapKey<K> | undefined = undefined
  constructor(readonly current: K) {}
  [Hash.symbol](): number {
    return pipe(
      Hash.hash(this.current),
      Hash.combine(Hash.hash(this.previous)),
      Hash.combine(Hash.hash(this.next)),
      Hash.cached(this)
    )
  }
  [Equal.symbol](that: unknown): boolean {
    if (this === that) {
      return true
    }
    return isMapKey(that) &&
      Equal.equals(this.current, that.current) &&
      Equal.equals(this.previous, that.previous) &&
      Equal.equals(this.next, that.next)
  }
}

/** @internal */
export const makeMapKey = <K>(current: K): MapKey<K> => new MapKeyImpl(current)

/** @internal */
export const isMapKey = (u: unknown): u is MapKey<unknown> => hasProperty(u, MapKeyTypeId)

/**
 * A `KeySet` is a sorted set of keys in the cache ordered by last access.
 * For efficiency, the set is implemented in terms of a doubly linked list
 * and is not safe for concurrent access.
 *
 * @internal
 */
export interface KeySet<in out K> {
  head: MapKey<K> | undefined // mutable by design
  tail: MapKey<K> | undefined // mutable by design
  /**
   * Adds the specified key to the set.
   */
  add(key: MapKey<K>): void
  /**
   * Removes the lowest priority key from the set.
   */
  remove(): MapKey<K> | undefined
}

class KeySetImpl<in out K> implements KeySet<K> {
  head: MapKey<K> | undefined = undefined
  tail: MapKey<K> | undefined = undefined
  add(key: MapKey<K>): void {
    if (key !== this.tail) {
      if (this.tail === undefined) {
        this.head = key
        this.tail = key
      } else {
        const previous = key.previous
        const next = key.next
        if (next !== undefined) {
          key.next = undefined
          if (previous !== undefined) {
            previous.next = next
            next.previous = previous
          } else {
            this.head = next
            this.head.previous = undefined
          }
        }
        this.tail.next = key
        key.previous = this.tail
        this.tail = key
      }
    }
  }
  remove(): MapKey<K> | undefined {
    const key = this.head
    if (key !== undefined) {
      const next = key.next
      if (next !== undefined) {
        key.next = undefined
        this.head = next
        this.head.previous = undefined
      } else {
        this.head = undefined
        this.tail = undefined
      }
    }
    return key
  }
}

/** @internal */
export const makeKeySet = <K>(): KeySet<K> => new KeySetImpl<K>()

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

/**
 * Constructs a new `CacheState` from the specified values.
 *
 * @internal
 */
export const makeCacheState = <Key, Value, Error>(
  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
  keys: KeySet<Key>,
  accesses: MutableQueue.MutableQueue<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>(): CacheState<Key, Value, Error> =>
  makeCacheState(
    MutableHashMap.empty(),
    makeKeySet(),
    MutableQueue.unbounded(),
    MutableRef.make(false),
    0,
    0
  )

/** @internal */
const CacheSymbolKey = "effect/Cache"

/** @internal */
export const CacheTypeId: Cache.CacheTypeId = Symbol.for(
  CacheSymbolKey
) as Cache.CacheTypeId

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

/** @internal */
const ConsumerCacheSymbolKey = "effect/ConsumerCache"

/** @internal */
export const ConsumerCacheTypeId: Cache.ConsumerCacheTypeId = Symbol.for(
  ConsumerCacheSymbolKey
) as Cache.ConsumerCacheTypeId

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

/** @internal */
export const makeCacheStats = (
  options: {
    readonly hits: number
    readonly misses: number
    readonly size: number
  }
): Cache.CacheStats => options

/** @internal */
export const makeEntryStats = (loadedMillis: number): Cache.EntryStats => ({
  loadedMillis
})

class CacheImpl<in out Key, in out Value, in out Error> implements Cache.Cache<Key, Value, Error> {
  readonly [CacheTypeId] = cacheVariance
  readonly [ConsumerCacheTypeId] = consumerCacheVariance
  readonly cacheState: CacheState<Key, Value, Error>
  constructor(
    readonly capacity: number,
    readonly context: Context.Context<any>,
    readonly fiberId: FiberId.FiberId,
    readonly lookup: Cache.Lookup<Key, Value, Error, any>,
    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
  ) {
    this.cacheState = initialCacheState()
  }

  get(key: Key): Effect.Effect<Value, Error> {
    return core.map(this.getEither(key), Either.merge)
  }

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

  getOption(key: Key): Effect.Effect<Option.Option<Value>, Error> {
    return core.suspend(() =>
      Option.match(MutableHashMap.get(this.cacheState.map, key), {
        onNone: () => {
          const mapKey = makeMapKey(key)
          this.trackAccess(mapKey)
          this.trackMiss()
          return core.succeed(Option.none<Value>())
        },
        onSome: (value) => this.resolveMapValue(value)
      })
    )
  }

  getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>> {
    return core.suspend(() =>
      Option.match(MutableHashMap.get(this.cacheState.map, key), {
        onNone: () => {
          const mapKey = makeMapKey(key)
          this.trackAccess(mapKey)
          this.trackMiss()
          return core.succeed(Option.none<Value>())
        },
        onSome: (value) => this.resolveMapValue(value, true) as Effect.Effect<Option.Option<Value>>
      })
    )
  }

  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 option = MutableHashMap.get(this.cacheState.map, key)
      if (Option.isSome(option)) {
        switch (option.value._tag) {
          case "Complete": {
            const loaded = option.value.entryStats.loadedMillis
            return Option.some(makeEntryStats(loaded))
          }
          case "Pending": {
            return Option.none()
          }
          case "Refreshing": {
            const loaded = option.value.complete.entryStats.loadedMillis
            return Option.some(makeEntryStats(loaded))
          }
        }
      }
      return Option.none()
    })
  }

  getEither(key: Key): Effect.Effect<Either.Either<Value, Value>, Error> {
    return core.suspend((): Effect.Effect<Either.Either<Value, Value>, Error> => {
      const k = key
      let mapKey: MapKey<Key> | undefined = undefined
      let deferred: Deferred.Deferred<Value, Error> | undefined = undefined
      let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
      if (value === undefined) {
        deferred = Deferred.unsafeMake<Value, Error>(this.fiberId)
        mapKey = makeMapKey(k)
        if (MutableHashMap.has(this.cacheState.map, k)) {
          value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
        } else {
          MutableHashMap.set(this.cacheState.map, k, pending(mapKey, deferred))
        }
      }
      if (value === undefined) {
        this.trackAccess(mapKey!)
        this.trackMiss()
        return core.map(this.lookupValueOf(key, deferred!), Either.right)
      } else {
        return core.flatMap(
          this.resolveMapValue(value),
          Option.match({
            onNone: () => this.getEither(key),
            onSome: (value) => core.succeed(Either.left(value))
          })
        )
      }
    })
  }

  invalidate(key: Key): Effect.Effect<void> {
    return core.sync(() => {
      MutableHashMap.remove(this.cacheState.map, key)
    })
  }

  invalidateWhen(key: Key, when: (value: Value) => boolean): Effect.Effect<void> {
    return core.sync(() => {
      const value = MutableHashMap.get(this.cacheState.map, key)
      if (Option.isSome(value) && value.value._tag === "Complete") {
        if (value.value.exit._tag === "Success") {
          if (when(value.value.exit.value)) {
            MutableHashMap.remove(this.cacheState.map, key)
          }
        }
      }
    })
  }

  get invalidateAll(): Effect.Effect<void> {
    return core.sync(() => {
      this.cacheState.map = MutableHashMap.empty()
    })
  }

  refresh(key: Key): Effect.Effect<void, Error> {
    return effect.clockWith((clock) =>
      core.suspend(() => {
        const k = key
        const deferred: Deferred.Deferred<Value, Error> = Deferred.unsafeMake(this.fiberId)
        let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
        if (value === undefined) {
          if (MutableHashMap.has(this.cacheState.map, k)) {
            value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
          } else {
            MutableHashMap.set(this.cacheState.map, k, pending(makeMapKey(k), deferred))
          }
        }
        if (value === undefined) {
          return core.asVoid(this.lookupValueOf(key, deferred))
        } else {
          switch (value._tag) {
            case "Complete": {
              if (this.hasExpired(clock, value.timeToLiveMillis)) {
                const found = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
                if (Equal.equals(found, value)) {
                  MutableHashMap.remove(this.cacheState.map, k)
                }
                return core.asVoid(this.get(key))
              }
              // Only trigger the lookup if we're still the current value, `completedResult`
              return pipe(
                this.lookupValueOf(key, deferred),
                effect.when(() => {
                  const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
                  if (Equal.equals(current, value)) {
                    const mapValue = refreshing(deferred, value as Complete<Key, Value, Error>)
                    MutableHashMap.set(this.cacheState.map, k, mapValue)
                    return true
                  }
                  return false
                }),
                core.asVoid
              )
            }
            case "Pending": {
              return Deferred.await(value.deferred)
            }
            case "Refreshing": {
              return Deferred.await(value.deferred)
            }
          }
        }
      })
    )
  }

  set(key: Key, value: Value): Effect.Effect<void> {
    return effect.clockWith((clock) =>
      core.sync(() => {
        const now = clock.unsafeCurrentTimeMillis()
        const k = key
        const lookupResult = Exit.succeed(value)
        const mapValue = complete(
          makeMapKey(k),
          lookupResult,
          makeEntryStats(now),
          now + Duration.toMillis(Duration.decode(this.timeToLive(lookupResult)))
        )
        MutableHashMap.set(
          this.cacheState.map,
          k,
          mapValue as Complete<Key, Value, Error>
        )
      })
    )
  }

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

  get values(): Effect.Effect<Array<Value>> {
    return core.sync(() => {
      const values: Array<Value> = []
      for (const entry of this.cacheState.map) {
        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
          values.push(entry[1].exit.value)
        }
      }
      return values
    })
  }

  get entries(): Effect.Effect<Array<[Key, Value]>> {
    return core.sync(() => {
      const values: Array<[Key, Value]> = []
      for (const entry of this.cacheState.map) {
        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
          values.push([entry[0], entry[1].exit.value])
        }
      }
      return values
    })
  }

  get keys(): Effect.Effect<Array<Key>> {
    return core.sync(() => {
      const keys: Array<Key> = []
      for (const entry of this.cacheState.map) {
        if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
          keys.push(entry[0])
        }
      }
      return keys
    })
  }

  resolveMapValue(
    value: MapValue<Key, Value, Error>,
    ignorePending = false
  ): Effect.Effect<Option.Option<Value>, Error> {
    return effect.clockWith((clock) => {
      switch (value._tag) {
        case "Complete": {
          this.trackAccess(value.key)
          if (this.hasExpired(clock, value.timeToLiveMillis)) {
            MutableHashMap.remove(this.cacheState.map, value.key.current)
            return core.succeed(Option.none<Value>())
          }
          this.trackHit()
          return core.map(value.exit, Option.some)
        }
        case "Pending": {
          this.trackAccess(value.key)
          this.trackHit()
          if (ignorePending) {
            return core.succeed(Option.none<Value>())
          }
          return core.map(Deferred.await(value.deferred), Option.some)
        }
        case "Refreshing": {
          this.trackAccess(value.complete.key)
          this.trackHit()
          if (this.hasExpired(clock, value.complete.timeToLiveMillis)) {
            if (ignorePending) {
              return core.succeed(Option.none<Value>())
            }
            return core.map(Deferred.await(value.deferred), Option.some)
          }
          return core.map(value.complete.exit, Option.some)
        }
      }
    })
  }

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

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

  trackAccess(key: MapKey<Key>): void {
    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) {
          if (MutableHashMap.has(this.cacheState.map, key.current)) {
            MutableHashMap.remove(this.cacheState.map, key.current)
            size = size - 1
            loop = size > this.capacity
          }
        } else {
          loop = false
        }
      }
      MutableRef.set(this.cacheState.updating, false)
    }
  }

  hasExpired(clock: Clock.Clock, timeToLiveMillis: number): boolean {
    return clock.unsafeCurrentTimeMillis() > timeToLiveMillis
  }

  lookupValueOf(
    input: Key,
    deferred: Deferred.Deferred<Value, Error>
  ): Effect.Effect<Value, Error> {
    return effect.clockWith((clock) =>
      core.suspend(() => {
        const key = input
        return pipe(
          this.lookup(input),
          core.provideContext(this.context),
          core.exit,
          core.flatMap((exit) => {
            const now = clock.unsafeCurrentTimeMillis()
            const stats = makeEntryStats(now)
            const value = complete(
              makeMapKey(key),
              exit,
              stats,
              now + Duration.toMillis(Duration.decode(this.timeToLive(exit)))
            )
            MutableHashMap.set(this.cacheState.map, key, value)
            return core.zipRight(
              Deferred.done(deferred, exit),
              exit
            )
          }),
          core.onInterrupt(() =>
            core.zipRight(
              Deferred.interrupt(deferred),
              core.sync(() => {
                MutableHashMap.remove(this.cacheState.map, key)
              })
            )
          )
        )
      })
    )
  }
}

/** @internal */
export const make = <Key, Value, Error = never, Environment = never>(
  options: {
    readonly capacity: number
    readonly timeToLive: Duration.DurationInput
    readonly lookup: Cache.Lookup<Key, Value, Error, Environment>
  }
): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> => {
  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: Cache.Lookup<Key, Value, Error, Environment>
    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
  }
): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> =>
  core.map(
    fiberRuntime.all([core.context<Environment>(), core.fiberId]),
    ([context, fiberId]) =>
      new CacheImpl(
        options.capacity,
        context,
        fiberId,
        options.lookup,
        (exit) => Duration.decode(options.timeToLive(exit))
      )
  )

/** @internal */
export const unsafeMakeWith = <Key, Value, Error = never>(
  capacity: number,
  lookup: Cache.Lookup<Key, Value, Error>,
  timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
): Cache.Cache<Key, Value, Error> =>
  new CacheImpl<Key, Value, Error>(
    capacity,
    Context.empty() as Context.Context<any>,
    none,
    lookup,
    (exit) => Duration.decode(timeToLive(exit))
  )