#Solvers

import { edgeAlignedSlots, moveItem, placeItem, pushAndShrinkSiblings, resizeByShrinkingNeighbors, resizeItem, scaleSizeBetweenCanvases, transferItem } from 'gridla'
import type { MoveItemInput, NewGridItem, PlaceItemInput, ResizeItemInput, SolveOptions, SolveResult, TransferItemInput, TransferResult } from 'gridla'

export function edgeAlignedSlots<T>(
  item: GridItem<T>,
  baseItems: readonly GridItem<T>[],
  bounds: GridBounds,
  gap: number,
): GridItem<T>[]

export function moveItem<T = unknown>({
  layout,
  itemId,
  position,
  options,
}: MoveItemInput<T>): SolveResult<T>

export function placeItem<T = unknown>({
  layout,
  item: input,
  position,
  pointer,
  options,
}: PlaceItemInput<T>): SolveResult<T>

export function pushAndShrinkSiblings<T>(
  active: GridItem<T>,
  baseItems: readonly GridItem<T>[],
  bounds: GridBounds,
  gap: number,
  axis: GridAxis,
  snapDistance: number,
): GridItem<T>[] | null

export function resizeByShrinkingNeighbors<T>({
  baseItems,
  gap,
  original,
  resized,
}: {
  baseItems: readonly GridItem<T>[]
  gap: number
  original: GridItem<T>
  resized: GridItem<T>
}): InternalResult<T> | null

export function resizeItem<T = unknown>({
  layout,
  itemId,
  edge,
  delta,
  rect,
  options,
}: ResizeItemInput<T>): SolveResult<T>

export function scaleSizeBetweenCanvases(
  size: GridSize,
  source: GridLayout['canvas'],
  target: GridLayout['canvas'],
): GridSize

export function transferItem<T = unknown>({
  source,
  target,
  itemId,
  pointer,
  size,
  options,
}: TransferItemInput<T>): TransferResult<T>

export type MoveItemInput<T = unknown> = {
  layout: GridLayout<T>
  itemId: string
  /** Requested top-left position in canvas coordinates. */
  position: GridPoint
  options?: SolveOptions
}

export type NewGridItem<T = unknown> = GridItemSize & {
  id: string
  x?: number
  y?: number
  policy?: GridItem<T>['policy']
  data?: T
}

export type PlaceItemInput<T = unknown> = {
  layout: GridLayout<T>
  /** Item to insert. Its `id` must not already be in the layout unless replacing it. */
  item: NewGridItem<T>
  /** Requested top-left. Overrides `item.x`/`item.y`. */
  position?: GridPoint
  /** Pointer location in canvas coordinates. The item is centered on it. */
  pointer?: GridPoint
  options?: SolveOptions
}

export type ResizeItemInput<T = unknown> = {
  layout: GridLayout<T>
  itemId: string
  /**
   * Edge or corner being dragged. Required when `delta` is used; optional
   * with `rect`, where it only informs edge snapping.
   */
  edge?: GridResizeEdge
  /** Pixel movement of the dragged edge. Ignored when `rect` is given. */
  delta?: GridPoint
  /** Requested rectangle. Missing fields default to the current values. */
  rect?: Partial<GridRect>
  options?: SolveOptions
}

export type SolveOptions = {
  /** Minimum distance kept between neighbors. Default `0`. */
  gap?: number
  /** Distance within which edges attract. Default `24`. */
  snapDistance?: number
  /**
   * When `false`, alignment snapping is skipped so the item tracks the
   * requested position exactly. Bounds, gap, and constraint rules still
   * apply. Default `true`.
   */
  snap?: boolean
  /** Receives one event per solve describing which strategy produced the result. */
  onTrace?: TraceCallback
}

export type SolveResult<T = unknown> = {
  /** `false` means the request could not be honored; `layout` then equals the input. */
  accepted: boolean
  /** The layout after the operation. */
  layout: GridLayout<T>
  /**
   * The active item as it appears in `layout`. When `accepted` is false this
   * is the rejected candidate, useful for showing where a drop would land.
   */
  item: GridItem<T>
  /** Which strategy produced this result. */
  strategy: SolveStrategy
  /** True when siblings moved or resized to make room. */
  shiftedSiblings: boolean
}

export type TransferItemInput<T = unknown> = {
  /** Layout the item currently lives in. */
  source: GridLayout<T>
  /** Layout the item is dropped into. */
  target: GridLayout<T>
  itemId: string
  /** Pointer location in the target's canvas coordinates. */
  pointer: GridPoint
  /**
   * Size the item should take in the target. Defaults to the source size
   * scaled by the ratio of the two canvases' inner areas.
   */
  size?: Partial<GridSize>
  options?: SolveOptions
}

export type TransferResult<T = unknown> = {
  accepted: boolean
  /** Source layout without the item. Equals the input when rejected. */
  source: GridLayout<T>
  /** Target layout with the item. Equals the input when rejected. */
  target: GridLayout<T>
  item: GridItem<T>
  strategy: SolveStrategy
  shiftedSiblings: boolean
}