/**
 * Context plumbing for `<ContextMenu.Root>` → `<Menu.Root>` and
 * `<ContextMenu.Trigger>`. Mirrors React's
 * `packages/react/src/context-menu/root/ContextMenuRootContext.ts`.
 *
 * The ContextMenu compound is a thin wrapper around `<Menu.Root>`: it
 * captures a `(clientX, clientY)` point on `contextmenu` (or long press),
 * threads a virtual anchor into the inner menu's floating-root context,
 * and calls `setOpen(true, …)` via an `actionsRef` populated by
 * `<Menu.Root>` once it detects the outer context-menu.
 *
 * Null-sentinel context (solidify P5) — `<ContextMenu.Trigger>`
 * requires the provider, but `<Menu.Root>` optionally reads it to detect
 * the context-menu interop path and tolerates `null`.
 */
import { type Accessor, createContext, useContext } from "solid-js";
import type { MutableRef } from "../../internals/floating-ui/types";
import type { MenuRootChangeEventDetails } from "../../menu/root/menu-root-context";

/**
 * A virtual anchor element Floating UI can position against. Mirrors React's
 * `ContextMenuRootContext['anchor']` shape.
 */
export interface ContextMenuAnchor {
	getBoundingClientRect: () => DOMRect;
	contextElement?: Element;
}

export interface ContextMenuRootContextValue {
	/** Current anchor element (virtual or real — usually virtual). */
	anchor: Accessor<ContextMenuAnchor>;
	/** Setter for the anchor — called by `<ContextMenu.Trigger>` on contextmenu/long-press. */
	setAnchor: (anchor: ContextMenuAnchor) => void;

	/**
	 * Populated by `<Menu.Root>` once it detects the context-menu parent.
	 * The trigger calls `setOpen` to open the menu after updating the anchor.
	 */
	actionsRef: MutableRef<{
		setOpen: (
			nextOpen: boolean,
			eventDetails: MenuRootChangeEventDetails,
		) => void;
	} | null>;

	/** Populated by `<Menu.Root>` from the inner positioner element. */
	positionerRef: MutableRef<HTMLElement | null>;
	/** Populated when `<Menu.Backdrop>` mounts. */
	backdropRef: MutableRef<HTMLDivElement | null>;
	/** Populated when an internal (modal-gating) backdrop mounts. */
	internalBackdropRef: MutableRef<HTMLDivElement | null>;

	/**
	 * Whether the trigger's pending mouseup can still open the menu
	 * (long-press window). Shared with `<Menu.Root>` for outside-press dismissal.
	 */
	allowMouseUpTriggerRef: MutableRef<boolean>;
	/** Point captured at contextmenu — retained across the open for inset positioning. */
	initialCursorPointRef: MutableRef<{ x: number; y: number } | null>;

	/** Unique id for this context-menu root. Used by menu popup to tag `data-rootownerid`. */
	rootId: string | undefined;

	/**
	 * Whether this `<ContextMenu.Root>` is itself nested inside another
	 * `<ContextMenu.Root>`. Matches React's `'nested-context-menu'`
	 * parent-type gate (inner menu's `<Menu.Root>` reads this to route
	 * dismissal / open-behavior like a regular submenu).
	 */
	nestedInsideContextMenu: boolean;
}

export const ContextMenuRootContext =
	createContext<ContextMenuRootContextValue | null>(null);

export function useContextMenuRootContext(): ContextMenuRootContextValue;
export function useContextMenuRootContext(
	optional: true,
): ContextMenuRootContextValue | null;
export function useContextMenuRootContext(
	optional?: boolean,
): ContextMenuRootContextValue | null {
	const ctx = useContext(ContextMenuRootContext);
	if (ctx == null && !optional) {
		throw new Error(
			"Base UI: ContextMenuRootContext is missing. ContextMenu parts must be placed within <ContextMenu.Root>.",
		);
	}
	return ctx;
}