/**
 * @since 2.0.0
 */
import type * as Chunk from "./Chunk.js"
import * as internal from "./internal/stm/tPriorityQueue.js"
import type * as Option from "./Option.js"
import type * as Order from "./Order.js"
import type { Predicate } from "./Predicate.js"
import type * as SortedMap from "./SortedMap.js"
import type * as STM from "./STM.js"
import type * as TRef from "./TRef.js"
import type * as Types from "./Types.js"

/**
 * @since 2.0.0
 * @category symbols
 */
export const TPriorityQueueTypeId: unique symbol = internal.TPriorityQueueTypeId

/**
 * @since 2.0.0
 * @category symbols
 */
export type TPriorityQueueTypeId = typeof TPriorityQueueTypeId

/**
 * A `TPriorityQueue` contains values of type `A` that an `Order` is defined
 * on. Unlike a `TQueue`, `take` returns the highest priority value (the value
 * that is first in the specified ordering) as opposed to the first value
 * offered to the queue. The ordering that elements with the same priority will
 * be taken from the queue is not guaranteed.
 *
 * @since 2.0.0
 * @category models
 */
export interface TPriorityQueue<in out A> extends TPriorityQueue.Variance<A> {}
/**
 * @internal
 * @since 2.0.0
 */
export interface TPriorityQueue<in out A> {
  /** @internal */
  readonly ref: TRef.TRef<SortedMap.SortedMap<A, [A, ...Array<A>]>>
}

/**
 * @since 2.0.0
 */
export declare namespace TPriorityQueue {
  /**
   * @since 2.0.0
   * @category models
   */
  export interface Variance<in out A> {
    readonly [TPriorityQueueTypeId]: {
      readonly _A: Types.Invariant<A>
    }
  }
}

/**
 * Constructs a new empty `TPriorityQueue` with the specified `Order`.
 *
 * @since 2.0.0
 * @category constructors
 */
export const empty: <A>(order: Order.Order<A>) => STM.STM<TPriorityQueue<A>> = internal.empty

/**
 * Creates a new `TPriorityQueue` from an iterable collection of values.
 *
 * @since 2.0.0
 * @category constructors
 */
export const fromIterable: <A>(
  order: Order.Order<A>
) => (iterable: Iterable<A>) => STM.STM<TPriorityQueue<A>> = internal.fromIterable

/**
 * Checks whether the queue is empty.
 *
 * @since 2.0.0
 * @category getters
 */
export const isEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<boolean> = internal.isEmpty

/**
 * Checks whether the queue is not empty.
 *
 * @since 2.0.0
 * @category getters
 */
export const isNonEmpty: <A>(self: TPriorityQueue<A>) => STM.STM<boolean> = internal.isNonEmpty

/**
 * Makes a new `TPriorityQueue` that is initialized with specified values.
 *
 * @since 2.0.0
 * @category constructors
 */
export const make: <A>(order: Order.Order<A>) => (...elements: Array<A>) => STM.STM<TPriorityQueue<A>> = internal.make

/**
 * Offers the specified value to the queue.
 *
 * @since 2.0.0
 * @category mutations
 */
export const offer: {
  /**
   * Offers the specified value to the queue.
   *
   * @since 2.0.0
   * @category mutations
   */
  <A>(value: A): (self: TPriorityQueue<A>) => STM.STM<void>
  /**
   * Offers the specified value to the queue.
   *
   * @since 2.0.0
   * @category mutations
   */
  <A>(self: TPriorityQueue<A>, value: A): STM.STM<void>
} = internal.offer

/**
 * Offers all of the elements in the specified collection to the queue.
 *
 * @since 2.0.0
 * @category mutations
 */
export const offerAll: {
  /**
   * Offers all of the elements in the specified collection to the queue.
   *
   * @since 2.0.0
   * @category mutations
   */
  <A>(values: Iterable<A>): (self: TPriorityQueue<A>) => STM.STM<void>
  /**
   * Offers all of the elements in the specified collection to the queue.
   *
   * @since 2.0.0
   * @category mutations
   */
  <A>(self: TPriorityQueue<A>, values: Iterable<A>): STM.STM<void>
} = internal.offerAll

/**
 * Peeks at the first value in the queue without removing it, retrying until a
 * value is in the queue.
 *
 * @since 2.0.0
 * @category getters
 */
export const peek: <A>(self: TPriorityQueue<A>) => STM.STM<A> = internal.peek

/**
 * Peeks at the first value in the queue without removing it, returning `None`
 * if there is not a value in the queue.
 *
 * @since 2.0.0
 * @category getters
 */
export const peekOption: <A>(self: TPriorityQueue<A>) => STM.STM<Option.Option<A>> = internal.peekOption

/**
 * Removes all elements from the queue matching the specified predicate.
 *
 * @since 2.0.0
 * @category getters
 */
export const removeIf: {
  /**
   * Removes all elements from the queue matching the specified predicate.
   *
   * @since 2.0.0
   * @category getters
   */
  <A>(predicate: Predicate<A>): (self: TPriorityQueue<A>) => STM.STM<void>
  /**
   * Removes all elements from the queue matching the specified predicate.
   *
   * @since 2.0.0
   * @category getters
   */
  <A>(self: TPriorityQueue<A>, predicate: Predicate<A>): STM.STM<void>
} = internal.removeIf

/**
 * Retains only elements from the queue matching the specified predicate.
 *
 * @since 2.0.0
 * @category getters
 */
export const retainIf: {
  /**
   * Retains only elements from the queue matching the specified predicate.
   *
   * @since 2.0.0
   * @category getters
   */
  <A>(predicate: Predicate<A>): (self: TPriorityQueue<A>) => STM.STM<void>
  /**
   * Retains only elements from the queue matching the specified predicate.
   *
   * @since 2.0.0
   * @category getters
   */
  <A>(self: TPriorityQueue<A>, predicate: Predicate<A>): STM.STM<void>
} = internal.retainIf

/**
 * Returns the size of the queue.
 *
 * @since 2.0.0
 * @category getters
 */
export const size: <A>(self: TPriorityQueue<A>) => STM.STM<number> = internal.size

/**
 * Takes a value from the queue, retrying until a value is in the queue.
 *
 * @since 2.0.0
 * @category mutations
 */
export const take: <A>(self: TPriorityQueue<A>) => STM.STM<A> = internal.take

/**
 * Takes all values from the queue.
 *
 * @since 2.0.0
 * @category mutations
 */
export const takeAll: <A>(self: TPriorityQueue<A>) => STM.STM<Array<A>> = internal.takeAll

/**
 * Takes a value from the queue, returning `None` if there is not a value in
 * the queue.
 *
 * @since 2.0.0
 * @category mutations
 */
export const takeOption: <A>(self: TPriorityQueue<A>) => STM.STM<Option.Option<A>> = internal.takeOption

/**
 * Takes up to the specified maximum number of elements from the queue.
 *
 * @since 2.0.0
 * @category mutations
 */
export const takeUpTo: {
  /**
   * Takes up to the specified maximum number of elements from the queue.
   *
   * @since 2.0.0
   * @category mutations
   */
  (n: number): <A>(self: TPriorityQueue<A>) => STM.STM<Array<A>>
  /**
   * Takes up to the specified maximum number of elements from the queue.
   *
   * @since 2.0.0
   * @category mutations
   */
  <A>(self: TPriorityQueue<A>, n: number): STM.STM<Array<A>>
} = internal.takeUpTo

/**
 * Collects all values into a `Chunk`.
 *
 * @since 2.0.0
 * @category destructors
 */
export const toChunk: <A>(self: TPriorityQueue<A>) => STM.STM<Chunk.Chunk<A>> = internal.toChunk

/**
 * Collects all values into an array.
 *
 * @since 2.0.0
 * @category destructors
 */
export const toArray: <A>(self: TPriorityQueue<A>) => STM.STM<Array<A>> = internal.toArray