/**
 * Originally ported from https://github.com/zio/zio/blob/master/core/shared/src/main/scala/zio/Has.scala
 * by Michael Arnaldi and the Matechs Garage Contributors
 *
 * Copyright 2017-2020 John A. De Goes and the ZIO Contributors
 *
 * Copyright 2020 Michael Arnaldi and the Matechs Garage Contributors.
 */

import type { Option } from './Option'

import { fromNullable, None } from './Option'

/**
 * URI used in Has
 */
export declare const HasURI: unique symbol

/**
 * Has signal presence of a specific service provided via Tag in the environment
 */
export interface Has<T> {
  [HasURI]: {
    _T: () => T
  }
}

/**
 * URI used in Region
 */
export const RegionURI: unique symbol = Symbol()

/**
 * Branding sub-environments
 */
export interface Region<K, T> {
  [RegionURI]: {
    _K: () => K
    _T: () => T
  }
}

/**
 * Extract the type of a class constructor
 */
export type ConstructorType<K extends Constructor<any>> = K extends {
  prototype: infer T
}
  ? T
  : never

export type Constructor<T> = Function & { prototype: T }

/**
 * Tag Encodes capabilities of reading and writing a service T into a generic environment
 */
export interface Tag<T> {
  _tag: 'Tag'
  _T: T
  key: PropertyKey
  def: boolean
  overridable: () => Tag<T>
  fixed: () => Tag<T>
  refine: <T1 extends T>() => Tag<T1>
  read: (r: Has<T>) => T
  readOption: (r: unknown) => Option<T>
  setKey: (s: PropertyKey) => Tag<T>
  of: (_: T) => Has<T>
}

/**
 * Extract the Has type from any augumented variant
 */
export type HasTag<T> = [T] extends [Tag<infer A>] ? Has<A> : never

function makeTag<T>(def = false, key: PropertyKey = Symbol()): Tag<T> {
  return {
    _tag: 'Tag',
    _T: undefined as any,
    key,
    def,
    of: (t) => ({ [key]: t } as any),
    overridable: () => makeTag(true, key),
    fixed: () => makeTag(false, key),
    refine: () => makeTag(def, key),
    read: (r: Has<T>) => r[key],
    readOption: (r) => (typeof r === 'object' && r !== null ? fromNullable(r[key]) : None()),
    setKey: (s: PropertyKey) => makeTag(def, s)
  }
}

/**
 * Create a service entry Tag from a type and a URI
 */
export function tag<T extends Constructor<any>>(_: T): Tag<ConstructorType<T>>
export function tag<T>(): Tag<T>
export function tag(_?: any): Tag<unknown> {
  return makeTag()
}

/**
 * Get the service type of a Has
 */
export type ServiceType<T> = [T] extends [Has<infer A>] ? A : never

/**
 * Replaces the service with the required Service Entry, in the specified environment
 */
export function replaceServiceIn<T>(_: Tag<T>, f: (t: T) => T): <R>(r: R & Has<T>) => R & Has<T> {
  return (r) => ({
    ...r,
    [_.key]: f(r[_.key])
  })
}

/**
 * Replaces the service with the required Service Entry, in the specified environment
 */
export function replaceServiceIn_<R, T>(r: R & Has<T>, _: Tag<T>, f: (t: T) => T): R & Has<T> {
  return {
    ...r,
    [_.key]: f(r[_.key])
  } as any
}

/**
 * Flags the current Has to be overridable, when this is used subsequently provided
 * environments will override pre-existing. Useful to provide defaults.
 */
export function overridable<T>(h: Tag<T>): Tag<T> {
  return {
    ...h,
    def: true
  }
}

export function mergeEnvironments<T, R1>(_: Tag<T>, r: R1, t: T): R1 & Has<T> {
  return _.def && r[_.key]
    ? r
    : ({
        ...r,
        [_.key]: t
      } as any)
}

export class DerivationContext {
  readonly hasMap = new Map<Tag<any>, Tag<any>>()
  derive<T, T2>(has: Tag<T>, f: () => Tag<T2>): Tag<T2> {
    const inMap = this.hasMap.get(has)
    if (inMap) {
      return inMap
    }
    const computed = f()
    this.hasMap.set(has, computed)
    return computed
  }
}

export const isTag = (u: unknown): u is Tag<unknown> =>
  typeof u === 'object' && u != null && '_tag' in u && u['_tag'] === 'Tag'