import type { JSX } from "@solidjs/web";
/**
 * `createMenu` — headless primitive for the Menu compound.
 *
 * Owns the logical state surface only:
 *  - `open` — consumer-owned signal, read through the option accessor.
 *  - `activeIndex` — keyboard-highlighted item index.
 *  - `payload` — active trigger payload (for handle-driven workflows).
 *  - `setOpen` — pure event-emitter via `runWithOwner(null, ...)`.
 *
 * All DOM concerns (FloatingTree, floating-ui interaction hooks, focus trap,
 * portal, transition) stay in `<Menu.Root>`.
 */
import {
	type Accessor,
	createContext,
	createMemo,
	createSignal,
	runWithOwner,
	untrack,
	useContext,
} from "solid-js";
import { type MaybeAccessor, readOption } from "../internals/maybe-accessor";
import {
	SNAPSHOT_KEYS,
	type Snapshottable,
	snapshotKeys,
} from "../internals/observability/snapshot";
import type {
	MenuRootChangeEventDetails,
	MenuRootChangeEventReason,
} from "./root/menu-root-context";

// ---------------------------------------------------------------------------
// Public types
// ---------------------------------------------------------------------------

export type MenuChangeReason = MenuRootChangeEventReason;

export interface CreateMenuOptions<_Payload = unknown> {
	/**
	 * Open state. Consumer-owned signal — the primitive reads through the
	 * accessor and does NOT keep an internal copy.
	 */
	open: MaybeAccessor<boolean>;
	/**
	 * Whether the menu is disabled.
	 * @default false
	 */
	disabled?: MaybeAccessor<boolean>;
	/**
	 * Whether the menu is modal (top-level only; ignored for submenus).
	 * @default true
	 */
	modal?: MaybeAccessor<boolean>;
	/**
	 * Called via `runWithOwner(null, ...)` so consumer signal writes don't
	 * trigger SIGNAL_WRITE_IN_OWNED_SCOPE.
	 */
	onOpenChange?: (open: boolean, details: MenuRootChangeEventDetails) => void;
}

export interface MenuApi<Payload = unknown> {
	/** Reactive accessor for the current open state. */
	open: Accessor<boolean>;
	/** Whether the menu is disabled. */
	disabled: Accessor<boolean>;
	/** Whether the menu is in modal mode. */
	modal: Accessor<boolean>;
	/** Keyboard-highlighted item index (null = none). */
	activeIndex: Accessor<number | null>;
	/** Current payload for handle-driven workflows. */
	payload: Accessor<Payload | undefined>;

	/**
	 * Pure event-emitter — fires `onOpenChange` via `runWithOwner(null, ...)`.
	 * The consumer owns the signal write.
	 */
	setOpen: (next: boolean, details?: MenuRootChangeEventDetails) => void;
	/** Update the highlighted item index. Internal coordination for nav hooks. */
	setActiveIndex: (index: number | null) => void;
	/** Update the active payload. Internal coordination for handle-driven flow. */
	setPayload: (payload: Payload | undefined) => void;

	/** Context provider — expose the api via `useMenu()`. */
	Provider: (props: { children: JSX.Element }) => JSX.Element;
}

// ---------------------------------------------------------------------------
// Context
// ---------------------------------------------------------------------------

const MenuApiContext = createContext<MenuApi<unknown> | null>(null);

/**
 * Read the nearest {@link MenuApi}. Throws unless `optional` is true.
 */
export function useMenu<Payload = unknown>(): MenuApi<Payload>;
export function useMenu<Payload = unknown>(
	optional: true,
): MenuApi<Payload> | null;
export function useMenu<Payload = unknown>(
	optional?: boolean,
): MenuApi<Payload> | null {
	const ctx = useContext(MenuApiContext);
	if (ctx == null && !optional) {
		throw new Error("Base UI: useMenu() must be called inside a <m.Provider>.");
	}
	return ctx as MenuApi<Payload> | null;
}

// ---------------------------------------------------------------------------
// Primitive
// ---------------------------------------------------------------------------

/**
 * Headless primitive for the Menu compound. Owns logical state — open,
 * disabled, modal, active item index, and payload. DOM concerns (floating-ui,
 * focus trap, portal, animation) live in `<Menu.Root>`.
 */
export function createMenu<Payload = unknown>(
	options: CreateMenuOptions<Payload>,
): MenuApi<Payload> {
	const open = createMemo<boolean>(() => Boolean(readOption(options.open)), {
		name: "menu.open",
	});

	const disabled = createMemo<boolean>(
		() => Boolean(readOption(options.disabled)),
		{ name: "menu.disabled" },
	);

	const modal = createMemo<boolean>(() => readOption(options.modal) ?? true, {
		name: "menu.modal",
	});

	// Internal state — not consumer-owned but privately mutable.
	const [activeIndex, setActiveIndex] = createSignal<number | null>(null, {
		ownedWrite: true,
		name: "menu.activeIndex",
	});
	const [payload, setPayload] = createSignal<Payload | undefined>(undefined, {
		ownedWrite: true,
		name: "menu.payload",
	});

	// Pure event-emitter — escapes the reactive owner so consumer signal
	// writes inside onOpenChange don't trip SIGNAL_WRITE_IN_OWNED_SCOPE.
	const setOpen = (
		next: boolean,
		details?: MenuRootChangeEventDetails,
	): void => {
		if (untrack(disabled)) return;
		const d =
			details ??
			({ reason: "none", isCanceled: false } as MenuRootChangeEventDetails);
		runWithOwner(null, () => options.onOpenChange?.(next, d));
	};

	const api: MenuApi<Payload> = {
		open,
		disabled,
		modal,
		activeIndex,
		payload: payload as Accessor<Payload | undefined>,
		setOpen,
		setActiveIndex,
		setPayload: setPayload as (payload: Payload | undefined) => void,
		Provider: (props) => (
			<MenuApiContext value={api as MenuApi<unknown>}>
				{props.children}
			</MenuApiContext>
		),
	};

	(api as MenuApi<Payload> & Snapshottable)[SNAPSHOT_KEYS] = MENU_SNAPSHOT_KEYS;

	return api;
}

const MENU_SNAPSHOT_KEYS = snapshotKeys<MenuApi>(
	"open",
	"disabled",
	"modal",
	"activeIndex",
);