utils

export type AsyncData<A, E = never> = NoData | Loading | Failure<E> | Success<A> | Optimistic<A, E>

export interface IgnoreList extends Effect.EffectUnifyIgnore {
  Effect: true
}

export interface Unify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  AsyncData: () => Unify_<A[Unify.typeSymbol]> extends AsyncData<infer E0, infer A0> | infer _
    ? AsyncData<E0, A0>
    : never
}

export type Error<T> = [T] extends [AsyncData<infer _, infer E>] ? E : never

export type Success<T> = [T] extends [AsyncData<infer A, infer _>] ? A : never

export interface Failure<out E> extends Effect.Effect<never, E, never> {
  readonly [AsyncDataTypeId]: AsyncDataTypeId

  /**
   * @since 1.18.0
   */
  readonly _tag: typeof FAILURE_TAG

  /**
   * @since 1.18.0
   */
  readonly cause: Cause.Cause<E>

  /**
   * @since 1.20.0
   */
  readonly timestamp: number // Date.now()

  /**
   * @since 1.18.0
   */
  readonly refreshing: Option.Option<Loading>

  /**
   * @since 1.18.0
   */
  readonly [Unify.typeSymbol]: unknown

  /**
   * @since 1.18.0
   */
  readonly [Unify.unifySymbol]: AsyncData.Unify<this>

  /**
   * @since 1.18.0
   */
  readonly [Unify.ignoreSymbol]: AsyncData.IgnoreList
}

export type FailureOptions = {
  readonly timestamp: number // Date.now()
  readonly refreshing: Option.Option<Loading>
}

export declare class Loading

readonly [AsyncDataTypeId]: typeof AsyncDataTypeId

readonly [Unify.typeSymbol]: unknown

readonly [Unify.unifySymbol]: AsyncData.Unify<this>

readonly [Unify.ignoreSymbol]: AsyncData.IgnoreList

export type LoadingOptions = {
  readonly timestamp: number // Date.now()
  readonly progress: Option.Option<Progress.Progress>
}

export declare class NoData

readonly [AsyncDataTypeId]: typeof AsyncDataTypeId

readonly [Unify.typeSymbol]: unknown

readonly [Unify.unifySymbol]: AsyncData.Unify<this>

readonly [Unify.ignoreSymbol]: AsyncData.IgnoreList

export interface Optimistic<A, E = never> extends Effect.Effect<never, never, A> {
  readonly [AsyncDataTypeId]: AsyncDataTypeId
  readonly _tag: "Optimistic"
  readonly value: A
  readonly timestamp: number // Date.now()
  readonly previous: AsyncData<A, E>

  readonly [Unify.typeSymbol]: unknown
  readonly [Unify.unifySymbol]: AsyncData.Unify<this>
  readonly [Unify.ignoreSymbol]: AsyncData.IgnoreList
}

export interface OptimisticOptions {
  readonly timestamp: number // Date.now()
}

export type OptionalPartial<A> = [
  {
    [K in keyof A]+?: [A[K]] extends [Option.Option<infer R>] ? R | undefined : A[K]
  }
] extends [infer R]
  ? { readonly [K in keyof R]: R[K] }
  : never

export type Refreshing<A, E> = RefreshingFailure<E> | RefreshingSuccess<A>

export interface RefreshingFailure<E> extends Failure<E> {
  readonly refreshing: Option.Some<Loading>
}

export interface RefreshingSuccess<A> extends Success<A> {
  readonly refreshing: Option.Some<Loading>
}

export interface Success<out A> extends Effect.Effect<never, never, A> {
  readonly [AsyncDataTypeId]: AsyncDataTypeId

  readonly _tag: typeof SUCCESS_TAG
  readonly value: A
  /**
   * @since 1.20.0
   */
  readonly timestamp: number // Date.now()
  readonly refreshing: Option.Option<Loading>

  readonly [Unify.typeSymbol]: unknown
  readonly [Unify.unifySymbol]: AsyncData.Unify<this>
  readonly [Unify.ignoreSymbol]: AsyncData.IgnoreList
}

export type SuccessOptions = {
  readonly timestamp: number // Date.now()
  readonly refreshing: Option.Option<Loading>
}

export declare function dataEqual<A, E>(first: AsyncData<A, E>, second: AsyncData<A, E>): boolean

export declare const done: <A, E = never>(exit: Exit.Exit<A, E>) => AsyncData<A, E>

export declare const fail: {
  <E>(error: E, options?: OptionalPartial<FailureOptions>): Failure<E>
  <A, E>(error: E, options?: OptionalPartial<FailureOptions>): AsyncData<A, E>
}

export declare const failCause: {
  <E>(cause: Cause.Cause<E>, options?: OptionalPartial<FailureOptions>): Failure<E>
  <A, E>(cause: Cause.Cause<E>, options?: OptionalPartial<FailureOptions>): AsyncData<A, E>
}

export declare const flatMap: {
  <A, E, B, E2>(
    f: (a: A, data: Success<A> | Optimistic<A, E>) => AsyncData<B, E2>
  ): (data: AsyncData<A, E>) => AsyncData<B, E | E2>
  <A, E, B, E2>(
    data: AsyncData<A, E>,
    f: (a: A, data: Success<A> | Optimistic<A, E>) => AsyncData<B, E>
  ): AsyncData<B, E | E2>
}

export declare function fromEither<A, E = never>(either: Either.Either<A, E>): Success<A> | Failure<E>

export declare function fromExit<A, E>(exit: Exit.Exit<A, E>): Success<A> | Failure<E>

export declare const getEquivalence: <A, E>(
  valueEq?: Equivalence.Equivalence<A>
) => Equivalence.Equivalence<AsyncData<A, E>>

export declare const getFailure: <A, E>(data: AsyncData<A, E>) => Option.Option<E>

export declare const getSuccess: <A, E>(data: AsyncData<A, E>) => Option.Option<A>

export declare const isAsyncData: <A, E>(u: unknown) => u is AsyncData<A, E>

export declare const isExpired: {
  (ttl: Duration.DurationInput, now?: number): <A, E>(data: AsyncData<A, E>) => boolean
  <A, E>(data: AsyncData<A, E>, ttl: Duration.DurationInput, now?: number): boolean
}

export declare const isFailure: <A, E>(data: AsyncData<A, E>) => data is Failure<E>

export declare const isLoading: <A, E>(data: AsyncData<A, E>) => data is Loading

export declare const isLoadingOrRefreshing: <A, E>(data: AsyncData<A, E>) => data is Loading | Refreshing<A, E>

export declare const isNoData: <A, E>(data: AsyncData<A, E>) => data is NoData

export declare const isOptimistic: <A, E>(data: AsyncData<A, E>) => data is Optimistic<A, E>

export declare const isRefreshing: <A, E>(data: AsyncData<A, E>) => data is Refreshing<A, E>

export declare const isSuccess: <A, E>(data: AsyncData<A, E>) => data is Success<A>

export declare const loading: {
  (options?: OptionalPartial<LoadingOptions>): Loading
  <A, E>(options?: OptionalPartial<LoadingOptions>): AsyncData<A, E>
}

export declare const map: {
  <A, B>(f: (a: A) => B): <E>(data: AsyncData<A, E>) => AsyncData<B, E>
  <A, E, B>(data: AsyncData<A, E>, f: (a: A) => B): AsyncData<B, E>
}

export declare const match: {
  <A, E, R1, R2, R3, R4, R5>(matchers: {
    NoData: (data: NoData) => R1
    Loading: (data: Loading) => R2
    Failure: (cause: Cause.Cause<E>, data: Failure<E>) => R3
    Success: (value: A, data: Success<A>) => R4
    Optimistic: (value: A, data: Optimistic<A, E>) => R5
  }): (data: AsyncData<A, E>) => Unify.Unify<R1 | R2 | R3 | R4 | R5>
  <A, E, R1, R2, R3, R4, R5>(
    data: AsyncData<A, E>,
    matchers: {
      NoData: (data: NoData) => R1
      Loading: (data: Loading) => R2
      Failure: (cause: Cause.Cause<E>, data: Failure<E>) => R3
      Success: (value: A, data: Success<A>) => R4
      Optimistic: (value: A, data: Optimistic<A, E>) => R5
    }
  ): Unify.Unify<R1 | R2 | R3 | R4 | R5>
}

export declare const noData: { (): NoData; <A, E>(): AsyncData<A, E> }

export declare const optimistic: {
  <A>(value: A, options?: OptionalPartial<OptimisticOptions>): <E>(previous: AsyncData<A, E>) => Optimistic<A, E>
  <A, E = never>(previous: AsyncData<A, E>, value: A, options?: OptionalPartial<OptimisticOptions>): Optimistic<A, E>
}

export declare const startLoading: <A, E>(
  data: AsyncData<A, E>,
  options?: OptionalPartial<LoadingOptions>
) => AsyncData<A, E>

export declare const stopLoading: <A, E>(data: AsyncData<A, E>) => AsyncData<A, E>

export declare const success: {
  <A>(value: A, options?: OptionalPartial<SuccessOptions>): Success<A>
  <A, E>(value: A, options?: OptionalPartial<SuccessOptions>): AsyncData<A, E>
}

export declare function toOption<A, E>(data: AsyncData<A, E>): Option.Option<A>

export declare function toOptionCause<A, E>(data: AsyncData<A, E>): Option.Option<Cause.Cause<E>>

export declare function toOptionError<A, E>(data: AsyncData<A, E>): Option.Option<E>