#Controller

import { createGridController, createGridStore, observeSize, renderLayout, resolveControllerConfig } from 'gridla/interaction'
import type { GridController, GridControllerOptions, GridStore, GridStoreListener } from 'gridla/interaction'

export function createGridController<TData = unknown>(
  options: GridControllerOptions<TData> = {},
): GridController<TData>

export function createGridStore<S>(initial: S): GridStore<S>

export function observeSize(element: Element, callback: (size: GridSize) => void): () => void

export function renderLayout<TData>(
  source: GridLayout<TData>,
  size: GridSize | null,
  config: GridControllerConfig,
): GridLayout<TData>

export function resolveControllerConfig<TData>(
  options: GridControllerOptions<TData>,
): GridControllerConfig

export type GridController<TData = unknown> = {
  /** Id of this controller. Used by transfer scopes. */
  id: string
  /** State store. Subscribe to it to render. */
  store: GridStore<GridState<TData>>
  /** Imperative layout and selection API. Stable for the controller's lifetime. */
  actions: GridActions<TData>
  /** Low-level gesture API. Stable for the controller's lifetime. */
  gesture: GridGestureApi<TData>
  /** The resolved configuration currently in effect. */
  getConfig: () => GridControllerConfig
  /**
   * Replace the configuration. When a value changed, the layout is projected
   * again onto the measured size.
   */
  setConfig: (config: GridControllerConfig) => void
  /**
   * Apply changed options: callbacks, config fields, the controlled `layout`
   * and `selectedId`, and the transfer `scope`. Cheap to call on every render.
   */
  setOptions: (options: GridControllerOptions<TData>) => void
  /** Sync a controlled layout into the store (no-op when it is already current). */
  setLayout: (layout: GridLayout<TData>) => void
  /** Update the measured canvas size and project the layout onto it. */
  setSize: (size: GridSize | null) => void
  /** Unregister from the transfer scope and drop the gesture in progress. */
  destroy: () => void
}

export type GridControllerOptions<TData = unknown> = SolveOptions & {
  /**
   * Stable id of this controller, unique within a `TransferScope`. Generated
   * when omitted.
   */
  id?: string
  /**
   * Controlled layout. Pair with `onLayoutChange` and forward updates with
   * `setOptions`. Accepted changes render immediately; passing the emitted
   * layout back is a no-op, passing a different one overrides it.
   */
  layout?: GridLayout<TData>
  /** Initial layout for uncontrolled use. */
  defaultLayout?: GridLayout<TData>
  /**
   * Called with the next layout after every accepted change. The layout is
   * expressed in the canvas size it was rendered at.
   */
  onLayoutChange?: (layout: GridLayout<TData>, detail: GridChangeDetail) => void
  /** Fires with the solver strategy on every accepted interactive commit. */
  onCommit?: (detail: GridChangeDetail) => void
  /** Called when an item moves to another canvas inside the `scope`. */
  onTransferOut?: (itemId: string, targetId: string) => void
  /** Called when an item arrives from another canvas. */
  onTransferIn?: (item: GridItem<TData>, sourceId: string) => void
  /** Whether items from other canvases may be dropped here. Default `true`. */
  acceptTransfers?: boolean | ((item: GridItem<TData>, sourceId: string) => boolean)
  /** Transfer scope to register with. Items can move between controllers sharing one. */
  scope?: TransferScope | null
  /** Project the layout onto the measured size. Default `true`. */
  responsive?: boolean
  /** Minimum pointer travel before a press becomes a drag. Default `4`. */
  dragThreshold?: number
  /** Pixels moved per arrow key press. Default `8`. */
  keyboardStep?: number
  /** Controlled selection. */
  selectedId?: string | null
  onSelectedIdChange?: (itemId: string | null) => void
}

export type GridStore<S> = {
  getSnapshot: () => S
  subscribe: (listener: GridStoreListener) => () => void
  /** Replace the state. Listeners fire only when the reference changes. */
  set: (next: S | ((prev: S) => S)) => void
}

export type GridStoreListener = () => void