#Types

import { GRID_DATA } from 'gridla/svelte'
import type { GridActions, GridCanvasProps, GridChangeDetail, GridChangeReason, GridControllerConfig, GridInteraction, GridInteractionMode, GridItemProps, GridItemRenderProps, GridItemView, GridPreview, GridPreviewOutlineProps, GridProviderProps, GridState, GridTransferScopeProps } from 'gridla/svelte'

export const GRID_DATA: { readonly item: "data-gridla-item"; readonly dragHandle: "data-gridla-drag-handle"; readonly resizeHandle: "data-gridla-resize-handle"; readonly edge: "data-gridla-edge"; }

export type GridActions<TData = unknown> = {
  /** Replace the whole layout. */
  setLayout: (layout: GridLayout<TData>) => void
  /** Move an item programmatically. Returns whether the solver accepted it. */
  move: (itemId: string, position: GridPoint, options?: SolveOptions) => boolean
  /** Resize an item programmatically. */
  resize: (
    itemId: string,
    change: { edge: GridResizeEdge; delta: GridPoint } | { rect: Partial<GridRect> },
    options?: SolveOptions,
  ) => boolean
  /** Insert an item at a position or centered on a pointer. */
  place: (
    item: NewGridItem<TData>,
    at: { position: GridPoint } | { pointer: GridPoint },
    options?: SolveOptions,
  ) => boolean
  remove: (itemId: string) => void
  /** Patch an item's fields (constraints, policy, data). Geometry is re-clamped. */
  update: (itemId: string, patch: Partial<GridItem<TData>>) => void
  select: (itemId: string | null) => void
  /** Cancel the gesture in progress without committing. */
  cancel: () => void
  /**
   * Preview a new item (for example one dragged from a palette) centered on a
   * pointer position in canvas pixels. Returns the preview, or `null` when it
   * cannot be placed. Follow up with `commitIncoming` or `clearIncoming`.
   */
  previewIncoming: (item: GridItem<TData>, pointer: GridPoint) => GridPreview<TData> | null
  /** Commit the incoming preview into the layout. Returns whether one was committed. */
  commitIncoming: () => boolean
  /** Drop the incoming preview without committing. */
  clearIncoming: () => void
}

export type GridCanvasProps = HTMLAttributes<HTMLDivElement> & GridPointerGestureOptions & {
    children?: Snippet;
};

export type GridChangeDetail = {
  reason: GridChangeReason
  itemId?: string
  strategy?: SolveStrategy
}

export type GridChangeReason =
  | 'move'
  | 'resize'
  | 'place'
  | 'remove'
  | 'update'
  | 'transfer'
  | 'set'

export type GridControllerConfig = SolveOptions & {
  /**
   * Project the layout onto the measured canvas size. When `false`, the
   * canvas element is sized to the layout instead. 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`; Shift multiplies by 4. */
  keyboardStep: number
}

export type GridInteraction = {
  itemId: string
  mode: GridInteractionMode
  edge?: GridResizeEdge
  pointerId: number | null
  /** Where the pointer grabbed the item, relative to its top-left. */
  grabOffset: GridPoint
  /** Item rect at gesture start, in rendered canvas pixels. */
  origin: GridRect
  /** Pointer position at gesture start, in rendered canvas pixels. */
  start: GridPoint
}

export type GridInteractionMode = 'move' | 'resize'

export type GridItemProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'id'> & {
    /** Id of the item in the layout. */
    id: string;
    /**
     * `true` (default): the whole element is a drag surface. `false`: only
     * elements with `dragHandleProps` start a move.
     */
    draggable?: boolean;
    /** Edges to render built-in resize handles for. Default: none. */
    resizeEdges?: readonly GridResizeEdge[];
    /** Class for built-in resize handles. */
    resizeHandleClass?: string;
    /**
     * Position the element with `transform` (default) or with `left`/`top`.
     * Transform keeps layout work off the main thread during gestures.
     */
    positioning?: 'transform' | 'absolute';
    /** Render the cursor-tracked rect while dragging instead of the solved preview. Default `true`. */
    followPointer?: boolean;
    /** Item content. Receives the item view plus handle attribute objects. */
    children?: Snippet<[GridItemRenderProps]>;
};

export type GridItemRenderProps = GridItemView & {
    /** Spread on the element that starts a move. */
    dragHandleProps: {
        'data-gridla-drag-handle': string;
    };
    /** Attributes for a resize handle on the given edge. */
    getResizeHandleProps: (edge: GridResizeEdge) => {
        'data-gridla-resize-handle': string;
        'data-gridla-edge': GridResizeEdge;
    };
};

export type GridItemView = {
    /** Where the item is painted right now (preview-aware). */
    rect: GridRect;
    /** Where the item was before the current gesture. */
    baseRect: GridRect;
    /** Cursor-tracked rect while this item is active; `null` otherwise. */
    activeRect: GridRect | null;
    isActive: boolean;
    isSelected: boolean;
    /** True when this item moved in the preview because another item pushed it. */
    isShifted: boolean;
    /** True while the active item is being previewed in another canvas. */
    isTransferring: boolean;
    interaction: GridInteraction | null;
};

export type GridPreview<TData = unknown> = {
  layout: GridLayout<TData>
  item: GridItem<TData>
  strategy: SolveStrategy
  shiftedSiblings: boolean
  accepted: boolean
}

export type GridPreviewOutlineProps = HTMLAttributes<HTMLDivElement> & {
    positioning?: 'transform' | 'absolute';
};

export type GridProviderProps<TData = unknown> = SolveOptions & {
    /**
     * Stable id of this provider, unique within a `GridTransferScope`. Generated
     * when omitted.
     */
    id?: string;
    /**
     * Controlled layout. Bind it (`bind:layout`) to receive every accepted
     * change, or pair it with `onLayoutChange` and pass the next layout back.
     */
    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 a `GridTransferScope`. */
    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);
    /** Project the layout onto the measured canvas 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`; Shift multiplies by 4. */
    keyboardStep?: number;
    /** Controlled selection. */
    selectedId?: string | null;
    onSelectedIdChange?: (itemId: string | null) => void;
    children?: Snippet;
};

export type GridState<TData = unknown> = {
  /** The layout the controller was given (or owns). */
  source: GridLayout<TData>
  /** Measured canvas element size, or `null` until measured. */
  size: GridSize | null
  /** `source` projected onto `size`. Interactions operate on this layout. */
  layout: GridLayout<TData>
  interaction: GridInteraction | null
  /** Rect that tracks the pointer during a gesture, in rendered pixels. */
  activeRect: GridRect | null
  preview: GridPreview<TData> | null
  selectedId: string | null
  /** True while the active item is being previewed in another canvas. */
  transferring: boolean
}

export type GridTransferScopeProps = {
    children?: Snippet;
};