export * from "vitest"

export type API = V.TestAPI<{}>

export interface Methods<R = never> extends MethodsNonLive<R> {
  readonly live: Vitest.Tester<R>
  readonly scopedLive: Vitest.Tester<Scope.Scope | R>
}

export interface MethodsNonLive<R = never> extends API {
  readonly effect: Vitest.Tester<TestServices.TestServices | R>
  readonly flakyTest: <A, E, R2>(
    self: Effect.Effect<A, E, R2>,
    timeout?: Duration.DurationInput
  ) => Effect.Effect<A, never, R2>
  readonly scoped: Vitest.Tester<TestServices.TestServices | Scope.Scope | R>
  readonly layer: <R2, E>(
    layer: Layer.Layer<R2, E, R>,
    options?: {
      readonly timeout?: Duration.DurationInput
    }
  ) => {
    (f: (it: Vitest.MethodsNonLive<R | R2>) => void): void
    (name: string, f: (it: Vitest.MethodsNonLive<R | R2>) => void): void
  }

  /**
   * @since 1.0.0
   */
  readonly prop: <const Arbs extends Arbitraries>(
    name: string,
    arbitraries: Arbs,
    self: (
      properties: { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> },
      ctx: V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext
    ) => void,
    timeout?:
      | number
      | (V.TestOptions & {
          fastCheck?: FC.Parameters<{
            [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
          }>
        })
  ) => void
}

export interface Test<R> {
  <A, E>(
    name: string,
    self: TestFunction<A, E, R, [V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext]>,
    timeout?: number | V.TestOptions
  ): void
}

export interface TestFunction<A, E, R, TestArgs extends Array<any>> {
  (...args: TestArgs): Effect.Effect<A, E, R>
}

export interface Tester<R> extends Vitest.Test<R> {
  skip: Vitest.Test<R>
  skipIf: (condition: unknown) => Vitest.Test<R>
  runIf: (condition: unknown) => Vitest.Test<R>
  only: Vitest.Test<R>
  each: <T>(
    cases: ReadonlyArray<T>
  ) => <A, E>(name: string, self: TestFunction<A, E, R, Array<T>>, timeout?: number | V.TestOptions) => void
  fails: Vitest.Test<R>

  /**
   * @since 1.0.0
   */
  prop: <const Arbs extends Arbitraries, A, E>(
    name: string,
    arbitraries: Arbs,
    self: TestFunction<
      A,
      E,
      R,
      [
        { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> },
        V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext
      ]
    >,
    timeout?:
      | number
      | (V.TestOptions & {
          fastCheck?: FC.Parameters<{
            [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
          }>
        })
  ) => void
}

export type Arbitraries =
  | Array<Schema.Schema.Any | FC.Arbitrary<any>>
  | { [K in string]: Schema.Schema.Any | FC.Arbitrary<any> }

export declare const addEqualityTesters: () => void

export declare const describeWrapped: (name: string, f: (it: Vitest.Methods) => void) => V.SuiteCollector

export declare const effect: Vitest.Tester<TestServices.TestServices>

export declare const flakyTest: <A, E, R>(self: Effect.Effect<A, E, R>, timeout?: any) => Effect.Effect<A, never, R>

export declare const it: Vitest.Methods<never>

export declare const layer: <R, E>(
  layer_: Layer.Layer<R, E>,
  options?: { readonly memoMap?: Layer.MemoMap; readonly timeout?: Duration.DurationInput }
) => {
  (f: (it: Vitest.MethodsNonLive<R>) => void): void
  (name: string, f: (it: Vitest.MethodsNonLive<R>) => void): void
}

import { expect, layer } from "@effect/vitest"
import { Context, Effect, Layer } from "effect"

class Foo extends Context.Tag("Foo")<Foo, "foo">() {
  static Live = Layer.succeed(Foo, "foo")
}

class Bar extends Context.Tag("Bar")<Bar, "bar">() {
  static Live = Layer.effect(
    Bar,
    Effect.map(Foo, () => "bar" as const)
  )
}

layer(Foo.Live)("layer", (it) => {
  it.effect("adds context", () =>
    Effect.gen(function* () {
      const foo = yield* Foo
      expect(foo).toEqual("foo")
    })
  )

  it.layer(Bar.Live)("nested", (it) => {
    it.effect("adds context", () =>
      Effect.gen(function* () {
        const foo = yield* Foo
        const bar = yield* Bar
        expect(foo).toEqual("foo")
        expect(bar).toEqual("bar")
      })
    )
  })
})

export declare const live: Vitest.Tester<never>

export declare const makeMethods: (it: V.TestAPI) => Vitest.Methods

export declare const prop: <const Arbs extends Vitest.Arbitraries>(
  name: string,
  arbitraries: Arbs,
  self: (
    properties: { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> },
    ctx: V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext
  ) => void,
  timeout?:
    | number
    | (V.TestOptions & {
        fastCheck?: FC.Parameters<{
          [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
        }>
      })
) => void

export declare const scoped: Vitest.Tester<any>

export declare const scopedLive: Vitest.Tester<Scope.Scope>