import { type Accessor, createContext, useContext } from "solid-js";
import type {
	BaseUIChangeEventDetails,
	BaseUIGenericEventDetails,
	REASONS,
} from "../../internals/change-event-details";
import type { FloatingRootStore } from "../../internals/floating-ui/components/floating-root-store";
import type { UseInteractionsReturn } from "../../internals/floating-ui/hooks/use-interactions";
import type { MutableRef } from "../../internals/floating-ui/types";
import type { TransitionStatus } from "../../internals/use-transition-status/use-transition-status";
import type { ItemEqualityComparer } from "../internals/item-equality";
import type { Group } from "../internals/resolve-value-label";
import type { ComboboxSide } from "../positioner/positioner-context";

export type ComboboxRootChangeEventReason =
	| typeof REASONS.triggerPress
	| typeof REASONS.outsidePress
	| typeof REASONS.escapeKey
	| typeof REASONS.focusOut
	| typeof REASONS.listNavigation
	| typeof REASONS.inputChange
	| typeof REASONS.inputClear
	| typeof REASONS.itemPress
	| typeof REASONS.clearPress
	| typeof REASONS.inputPress
	| typeof REASONS.chipRemovePress
	| typeof REASONS.none;

export type ComboboxRootChangeEventDetails =
	BaseUIChangeEventDetails<ComboboxRootChangeEventReason>;

export type ComboboxRootHighlightEventReason = "keyboard" | "pointer" | "none";

export type ComboboxRootHighlightEventDetails = BaseUIGenericEventDetails<
	ComboboxRootHighlightEventReason,
	{ index: number }
>;

/**
 * Shared state exposed through the root context. Accessors throughout so
 * consumers don't need to guard reactive reads.
 */
export interface ComboboxRootContextValue<Value = unknown> {
	// Identity
	id: Accessor<string | undefined>;
	labelId: Accessor<string | undefined>;
	setLabelId: (id: string | undefined) => void;

	// Open state + transitions
	open: Accessor<boolean>;
	mounted: Accessor<boolean>;
	transitionStatus: Accessor<TransitionStatus>;

	// Input value + selection
	inputValue: Accessor<string>;
	setInputValue: (
		next: string,
		details: ComboboxRootChangeEventDetails,
	) => void;
	/**
	 * In single-select + `"none"` modes this is the single selected value (or
	 * `null`); in multi-select mode it's an array of selected values.
	 */
	selectedValue: Accessor<Value | Value[] | null>;
	setSelectedValue: (
		next: Value | Value[] | null,
		details: ComboboxRootChangeEventDetails,
	) => void;
	/** Selection mode — drives chip/array vs. scalar semantics. */
	selectionMode: Accessor<"none" | "single" | "multiple">;

	// Active/selected indices
	activeIndex: Accessor<number | null>;
	selectedIndex: Accessor<number | null>;
	setIndices: (options: {
		activeIndex?: number | null | undefined;
		selectedIndex?: number | null | undefined;
		type?: ComboboxRootHighlightEventReason | undefined;
	}) => void;

	// Control / flags
	disabled: Accessor<boolean>;
	readOnly: Accessor<boolean>;
	required: Accessor<boolean>;
	autoHighlightMode: Accessor<false | "input-change" | "always">;
	highlightItemOnHover: Accessor<boolean>;
	modal: Accessor<boolean>;
	loopFocus: Accessor<boolean>;
	openOnInputClick: Accessor<boolean>;
	/**
	 * Whether list items are presented as a grid. See `grid` prop on
	 * `<Combobox.Root>`.
	 */
	grid: Accessor<boolean>;
	/**
	 * Whether items are externally virtualized. See `virtualized` prop on
	 * `<Combobox.Root>`.
	 */
	virtualized: Accessor<boolean>;
	itemToStringLabel: Accessor<((item: Value) => string) | undefined>;
	itemToStringValue: Accessor<((item: Value) => string) | undefined>;
	isItemEqualToValue: Accessor<ItemEqualityComparer<Value, Value>>;

	// Items / filtering
	items: Accessor<readonly Value[] | readonly Group<Value>[] | undefined>;
	filteredItems: Accessor<readonly Value[] | readonly Group<Value>[]>;
	flatFilteredItems: Accessor<readonly Value[]>;
	query: Accessor<string>;

	// Static-children (no `items` prop) filtering. When consumers render
	// `<*.Item>` children directly (the cmdk "Command" pattern) instead of
	// passing `items`, there is no `flatFilteredItems` to drive empty-state /
	// per-item visibility. These helpers let filtering be driven by the
	// registered children instead:
	//   • `matchesQuery(value)` — whether a single item's value matches the
	//     current query (honoring `filter` / `filter={null}`, and the
	//     autocomplete `mode` static-item contract). Returns `true` when the
	//     query is empty or filtering is disabled.
	//   • `setItemVisible(token, visible)` — each item reports its live
	//     visibility keyed by a per-item token.
	//   • `visibleItemCount` — reactive count of currently-visible static
	//     children, read by `<*.Empty>` / `<*.List>`.
	// All three are inert in items-mode (visibility + empty derive from
	// `flatFilteredItems`).
	matchesQuery: (value: Value) => boolean;
	setItemVisible: (token: symbol, visible: boolean) => void;
	visibleItemCount: Accessor<number>;

	// Refs shared with parts
	listRef: MutableRef<Array<HTMLElement | null>>;
	labelsRef: MutableRef<Array<string | null>>;
	popupRef: MutableRef<HTMLElement | null>;
	inputRef: MutableRef<HTMLInputElement | null>;
	emptyRef: MutableRef<HTMLElement | null>;
	clearRef: MutableRef<HTMLButtonElement | null>;
	valuesRef: MutableRef<Value[]>;
	allValuesRef: MutableRef<Value[]>;
	/** Host ref for `<Combobox.Chips>`. Used by dismiss outside-press filter. */
	chipsContainerRef: MutableRef<HTMLDivElement | null>;

	// Elements (reactive)
	triggerElement: Accessor<HTMLElement | null>;
	setTriggerElement: (el: HTMLElement | null) => void;
	inputElement: Accessor<HTMLInputElement | null>;
	setInputElement: (el: HTMLInputElement | null) => void;
	listElement: Accessor<HTMLElement | null>;
	setListElement: (el: HTMLElement | null) => void;
	positionerElement: Accessor<HTMLElement | null>;
	setPositionerElement: (el: HTMLElement | null) => void;
	popupSide: Accessor<ComboboxSide | null>;
	setPopupSide: (side: ComboboxSide | null) => void;

	// Imperative actions + setOpen
	setOpen: (next: boolean, details: ComboboxRootChangeEventDetails) => void;
	handleSelection: (
		event: MouseEvent | PointerEvent | KeyboardEvent,
		value?: Value,
	) => void;
	forceMount: () => void;

	// Floating/interactions
	floatingRootContext: FloatingRootStore;
	interactions: UseInteractionsReturn;

	// keyboard/pointer modality ref
	keyboardActiveRef: MutableRef<boolean>;
}

export const ComboboxRootContext =
	createContext<ComboboxRootContextValue<unknown> | null>(null);

export function useComboboxRootContext<
	Value = unknown,
>(): ComboboxRootContextValue<Value>;
export function useComboboxRootContext<Value = unknown>(
	optional: true,
): ComboboxRootContextValue<Value> | null;
export function useComboboxRootContext<Value = unknown>(
	optional?: boolean,
): ComboboxRootContextValue<Value> | null {
	const ctx = useContext(ComboboxRootContext);
	if (ctx == null && !optional) {
		throw new Error(
			"Base UI: ComboboxRootContext is missing. Combobox parts must be placed within <Combobox.Root>.",
		);
	}
	return ctx as ComboboxRootContextValue<Value> | null;
}