export * from "vitest"

export type API = V.TestAPI<{}>

export interface Methods<R = never> extends API {
  readonly effect: Vitest.Tester<TestServices.TestServices | R>
  readonly live: Vitest.Tester<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 scopedLive: Vitest.Tester<Scope.Scope | R>
  readonly layer: <R2, E>(
    layer: Layer.Layer<R2, E, R>,
    options?: {
      readonly timeout?: Duration.DurationInput
    }
  ) => {
    (f: (it: Vitest.Methods<R | R2>) => void): void
    (name: string, f: (it: Vitest.Methods<R | R2>) => void): void
  }

  /**
   * @since 1.0.0
   */
  readonly prop: <const S extends SchemaObj>(
    name: string,
    schemas: S,
    self: (
      schemas: { [K in keyof S]: Schema.Schema.Type<S[K]> },
      ctx: V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext
    ) => void,
    timeout?: number | V.TestOptions
  ) => 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

  /**
   * @since 1.0.0
   */
  prop: <const S extends SchemaObj, A, E>(
    name: string,
    schemas: S,
    self: TestFunction<
      A,
      E,
      R,
      [{ [K in keyof S]: Schema.Schema.Type<S[K]> }, V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext]
    >,
    timeout?: number | V.TestOptions
  ) => void
}

export type SchemaObj = Array<Schema.Schema.Any> | { [K in string]: Schema.Schema.Any }

export declare const addEqualityTesters: () => void

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.Methods<R>) => void): void; (name: string, f: (it: Vitest.Methods<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 prop: <const S extends Vitest.SchemaObj>(
  name: string,
  schemas: S,
  self: (
    schemas: { [K in keyof S]: Schema.Schema.Type<S[K]> },
    ctx: V.TaskContext<V.RunnerTestCase<{}>> & V.TestContext
  ) => void,
  timeout?: number | V.TestOptions
) => void

export declare const scoped: Vitest.Tester<any>

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