import { RateLimiter } from "@effect/experimental"
import { Effect } from "effect"

export default Effect.gen(function* () {
  // Access the `sleep` function from the RateLimiter module
  const sleep = yield* RateLimiter.makeSleep

  // Use the `sleep` function with specific rate limiting parameters.
  // This will only sleep if the rate limit has been exceeded.
  yield* sleep({
    key: "some-key",
    limit: 10,
    window: "5 seconds",
    algorithm: "fixed-window"
  })
})

declare const makeSleep: Effect.Effect<
  (options: {
    readonly algorithm?: "fixed-window" | "token-bucket" | undefined
    readonly window: Duration.DurationInput
    readonly limit: number
    readonly key: string
    readonly tokens?: number | undefined
  }) => Effect.Effect<ConsumeResult, RateLimitStoreError>,
  never,
  RateLimiter
>

import { RateLimiter } from "@effect/experimental"
import { Effect } from "effect"

Effect.gen(function* () {
  // Access the `withLimiter` function from the RateLimiter module
  const withLimiter = yield* RateLimiter.makeWithRateLimiter

  // Apply a rate limiter to an effect
  yield* Effect.log("Making a request with rate limiting").pipe(
    withLimiter({
      key: "some-key",
      limit: 10,
      onExceeded: "delay",
      window: "5 seconds",
      algorithm: "fixed-window"
    })
  )
})

declare const makeWithRateLimiter: Effect.Effect<
  (options: {
    readonly algorithm?: "fixed-window" | "token-bucket" | undefined
    readonly onExceeded?: "delay" | "fail" | undefined
    readonly window: Duration.DurationInput
    readonly limit: number
    readonly key: string
    readonly tokens?: number | undefined
  }) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | RateLimiterError, R>,
  never,
  RateLimiter
>

declare const make: Effect.Effect<RateLimiter, never, RateLimiterStore>

declare const ErrorTypeId: "~@effect/experimental/RateLimiter/RateLimiterError"

type ErrorTypeId = "~@effect/experimental/RateLimiter/RateLimiterError"

declare class RateLimitExceeded

readonly [ErrorTypeId]: "~@effect/experimental/RateLimiter/RateLimiterError"

readonly reason: "Exceeded"

declare class RateLimitStoreError

readonly [ErrorTypeId]: "~@effect/experimental/RateLimiter/RateLimiterError"

readonly reason: "StoreError"

declare const RateLimiterError: Schema.Union<[typeof RateLimitExceeded, typeof RateLimitStoreError]>

type RateLimiterError = RateLimitExceeded | RateLimitStoreError

declare const layer: Layer.Layer<RateLimiter, never, RateLimiterStore>

export interface ConsumeResult {
  /**
   * The amount of delay to wait before making the next request, when the rate
   * limiter is using the "delay" `onExceeded` strategy.
   *
   * It will be Duration.zero if the request is allowed immediately.
   */
  readonly delay: Duration.Duration

  /**
   * The maximum number of requests allowed in the current window.
   */
  readonly limit: number

  /**
   * The number of remaining requests in the current window.
   */
  readonly remaining: number

  /**
   * The time until the rate limit fully resets.
   */
  readonly resetAfter: Duration.Duration
}

export interface RateLimiter {
  readonly [TypeId]: TypeId

  readonly consume: (options: {
    readonly algorithm?: "fixed-window" | "token-bucket" | undefined
    readonly onExceeded?: "delay" | "fail" | undefined
    readonly window: Duration.DurationInput
    readonly limit: number
    readonly key: string
    readonly tokens?: number | undefined
  }) => Effect.Effect<ConsumeResult, RateLimiterError>
}

declare class RateLimiterStore

declare const layerStoreMemory: Layer.Layer<RateLimiterStore, never, never>

declare const RateLimiter: Context.Tag<RateLimiter, RateLimiter>

declare const TypeId: "~@effect/experimental/RateLimiter"

type TypeId = "~@effect/experimental/RateLimiter"