import { type Accessor, createContext, useContext } from "solid-js";
import type { TextDirection } from "../direction-provider/direction-provider-context.ts";
import type {
	BaseUIChangeEventDetails,
	REASONS,
} from "../internals/change-event-details";
import type { Orientation } from "../internals/types";

/**
 * Change-event reason namespace for `<Accordion.Root>`. Matches Base UI
 * React's union.
 */
export type AccordionRootChangeEventReason =
	| typeof REASONS.triggerPress
	| typeof REASONS.none;

export type AccordionRootChangeEventDetails =
	BaseUIChangeEventDetails<AccordionRootChangeEventReason>;

/**
 * Accordion supports a single scalar value (single-expand) or an array
 * (multi-expand). Internally we always store an array — a single-expand value
 * is represented as either `[]` or `[currentlyOpen]`. The public surface
 * follows React's convention of `Value[]`.
 */
export type AccordionValue<Value = unknown> = Value[];

/**
 * Public state surface for the root — flows through `data-*` projection.
 * Matches Base UI React's `AccordionRootState`.
 */
export interface AccordionRootState<Value = unknown> {
	/** Currently-open item values (always an array internally). */
	value: AccordionValue<Value>;
	/** Whether the accordion ignores user interaction. */
	disabled: boolean;
	/** Visual orientation — controls arrow key direction. */
	orientation: Orientation;
}

/**
 * Context shape shared across `<Accordion.Root>`, `<Accordion.Item>`,
 * `<Accordion.Trigger>` and `<Accordion.Panel>`. Accessor-heavy so descendants
 * stay reactive without re-deriving.
 *
 * `accordionItemRefs` is a plain array (owned by `<CompositeList>`) because
 * the trigger's keyboard handler reads it synchronously inside event handlers.
 */
export interface AccordionRootContextValue<Value = unknown> {
	/** Plain array of registered item elements, in DOM order. */
	accordionItemRefs: Array<HTMLElement | null>;
	/** Current text direction (threaded through for RTL arrow-key swap). */
	direction: Accessor<TextDirection>;
	/** Whether the root (and by extension every item) is disabled. */
	disabled: Accessor<boolean>;
	/**
	 * Imperative value-change entry point. Called by an item on toggle; the
	 * root applies single/multi semantics internally.
	 */
	handleValueChange: (
		newValue: unknown,
		nextOpen: boolean,
		eventDetails: AccordionRootChangeEventDetails,
	) => void;
	/** Whether panels use `hidden="until-found"`. */
	hiddenUntilFound: Accessor<boolean>;
	/** Whether panels stay mounted when closed. */
	keepMounted: Accessor<boolean>;
	/** Whether arrow navigation between triggers loops at the extents. */
	loopFocus: Accessor<boolean>;
	/** Current orientation. */
	orientation: Accessor<Orientation>;
	/** Root's projected state (for `data-*`). */
	state: Accessor<AccordionRootState<Value>>;
	/** Currently-open item values. */
	value: Accessor<AccordionValue<Value>>;
}

/**
 * Context for the accordion compound. `createContext<T | null>(null)` +
 * `== null` sentinel — Solid 2's `useContext` throws
 * `ContextNotFoundError` when the default is `undefined`, which would shadow
 * the intended Base UI error message below.
 */
export const AccordionRootContext =
	createContext<AccordionRootContextValue<unknown> | null>(null);

export function useAccordionRootContext<
	Value = unknown,
>(): AccordionRootContextValue<Value> {
	const context = useContext(AccordionRootContext);
	if (context == null) {
		throw new Error(
			"Base UI: AccordionRootContext is missing. Accordion parts must be placed within <Accordion.Root>.",
		);
	}
	return context as AccordionRootContextValue<Value>;
}