#Nested

import { compactLayout, findContainerAt, findFirstUnlockedAncestor, flattenLayout, getAncestors, getDescendants, gridNodeAdapter, hitTest, isDirectChildOfContained, isInsideLockedSubtree, markLockedItems, projectItemsToRoot, projectItemToRoot, renderLayoutForRect, rootPointToContainer, scaleSizeBetweenContainers, toRenderedLayout } from 'gridla'
import type { CompactOptions, CompactResult, FindContainerOptions, FlatItem, FlatLayout, FlattenOptions, GridNode, GridNodeBehavior, GridTreeAdapter } from 'gridla'

export function compactLayout<T>(
  layout: GridLayout<T>,
  options: CompactOptions = {},
): CompactResult<T>

export function findContainerAt<TNode>(
  layout: FlatLayout<TNode>,
  point: GridPoint,
  options: FindContainerOptions = {},
): FlatItem<TNode> | null

export function findFirstUnlockedAncestor<TNode>(
  layout: FlatLayout<TNode>,
  itemId: string,
): FlatItem<TNode> | undefined

export function flattenLayout<TNode = GridNode>(
  root: TNode,
  rootRect: GridRect,
  options: FlattenOptions<TNode> = {},
): FlatLayout<TNode>

export function getAncestors<TNode>(layout: FlatLayout<TNode>, itemId: string): FlatItem<TNode>[]

export function getDescendants<TNode>(
  layout: FlatLayout<TNode>,
  itemId: string,
): FlatItem<TNode>[]

export function hitTest<TNode>(
  layout: FlatLayout<TNode>,
  point: GridPoint,
): FlatItem<TNode> | null

export function isDirectChildOfContained<TNode>(
  layout: FlatLayout<TNode>,
  itemId: string,
): boolean

export function isInsideLockedSubtree<TNode>(layout: FlatLayout<TNode>, itemId: string): boolean

export function markLockedItems<TNode>(
  items: readonly GridItem[],
  layout: FlatLayout<TNode>,
): readonly GridItem[]

export function projectItemsToRoot<TNode>(
  container: FlatItem<TNode>,
  items: readonly GridItem[],
): Map<string, GridRect>

export function projectItemToRoot<TNode>(
  container: FlatItem<TNode>,
  item: GridItem,
  contextItems: readonly GridItem[],
): GridRect

export function renderLayoutForRect(
  layout: GridLayout,
  rect: GridSize,
  padding: Partial<GridPadding> | undefined,
  gap: number,
): GridLayout

export function rootPointToContainer<TNode>(
  container: FlatItem<TNode>,
  point: GridPoint,
  canvas: GridCanvas | null = container.layout?.canvas ?? null,
): GridPoint | null

export function scaleSizeBetweenContainers<TNode>(
  source: FlatItem<TNode>,
  target: FlatItem<TNode>,
  size: GridSize,
): GridSize

export function toRenderedLayout<TNode>(
  container: FlatItem<TNode>,
  items: readonly GridItem[],
): GridLayout

export const gridNodeAdapter: GridTreeAdapter<GridNode<unknown>>

export type CompactOptions = {
  /** Items that keep their height. Fixed-height items always do. */
  isRigid?: (item: GridItem) => boolean
}

export type CompactResult<T = unknown> = {
  layout: GridLayout<T>
  /** `false` when rigid heights, minimums, and gaps exceed the canvas. */
  fits: boolean
}

export type FindContainerOptions = {
  /**
   * Containers other than `sourceId` must contain the point at least this
   * far inside their edges. Keeps edge brushes from switching targets.
   */
  inset?: number
  /** Container the interaction started in; it wins without any inset. */
  sourceId?: string
}

export type FlatItem<TNode = GridNode> = {
  id: string
  /** Id of the enclosing container, or `null` for the root. */
  parentId: string | null
  /** 0 for the root, 1 for its children, and so on. */
  depth: number
  /** Rectangle in root coordinates. */
  rect: GridRect
  /** The node's item entry in its parent's authored layout. `null` for the root. */
  canonicalRect: GridRect | null
  /** The node's item entry in its parent's rendered layout. `null` for the root. */
  sizing: GridItem | null
  /**
   * For containers: the authored layout projected into `rect`. Solvers and
   * hit testing for children operate in this coordinate system.
   */
  layout: GridLayout | null
  /** The authored layout, untouched. `null` for leaves. */
  sourceLayout: GridLayout | null
  /** Gap used when projecting and solving this container's children. */
  gap: number
  node: TNode
  isContainer: boolean
  acceptsChildren: boolean
  locked: boolean
  contained: boolean
  scrollable: boolean
}

export type FlatLayout<TNode = GridNode> = {
  rootId: string
  items: readonly FlatItem<TNode>[]
  itemsById: ReadonlyMap<string, FlatItem<TNode>>
  childrenByParentId: ReadonlyMap<string | null, readonly string[]>
}

export type FlattenOptions<TNode> = {
  /** Reads your own tree shape. Defaults to the `GridNode` adapter. */
  adapter?: GridTreeAdapter<TNode>
}

export type GridNode<TData = unknown> = {
  id: string
  /** Layout of this node's children. Present on containers. */
  layout?: GridLayout
  children?: GridNode<TData>[]
  /** Gap between children in pixels. Kept fixed during projection. */
  gap?: number
  /** Rendering padding for children. Overrides `layout.canvas.padding`. */
  padding?: Partial<GridPadding>
  behavior?: GridNodeBehavior
  data?: TData
}

export type GridNodeBehavior = {
  /** Treat the node as a container even without children. Defaults to `layout !== undefined`. */
  container?: boolean
  /** Whether items may be dropped into this node. Defaults to `container`. */
  acceptsChildren?: boolean
  /** Direct children cannot leave, and outside items cannot enter. */
  contained?: boolean
  /** The subtree is a wall: nothing inside moves, nothing outside enters. */
  locked?: boolean
  /** Keeps its height during compaction (content scrolls instead). */
  scrollable?: boolean
}

export type GridTreeAdapter<TNode> = {
  getId(node: TNode): string
  getChildren(node: TNode): readonly TNode[]
  getLayout(node: TNode): GridLayout | null | undefined
  getBehavior?(node: TNode): GridNodeBehavior | undefined
  getGap?(node: TNode): number | undefined
  getPadding?(node: TNode): Partial<GridPadding> | undefined
}