import { type Accessor, createContext, useContext } from "solid-js";
import type {
	BaseUIChangeEventDetails,
	BaseUIGenericEventDetails,
	REASONS,
} from "../../internals/change-event-details";
import type {
	ChangeEventCustomProperties,
	EventWithOptionalKeyState,
	IncrementValueParameters,
} from "../utils/types.ts";
import type { NumberFieldRootState } from "./number-field-root.tsx";

export type InputMode = "numeric" | "decimal" | "text";

export type NumberFieldRootChangeEventReason =
	| typeof REASONS.inputChange
	| typeof REASONS.inputClear
	| typeof REASONS.inputBlur
	| typeof REASONS.inputPaste
	| typeof REASONS.keyboard
	| typeof REASONS.incrementPress
	| typeof REASONS.decrementPress
	| typeof REASONS.wheel
	| typeof REASONS.scrub
	| typeof REASONS.none;

export type NumberFieldRootChangeEventDetails = BaseUIChangeEventDetails<
	NumberFieldRootChangeEventReason,
	ChangeEventCustomProperties
>;

export type NumberFieldRootCommitEventReason =
	| typeof REASONS.inputBlur
	| typeof REASONS.inputClear
	| typeof REASONS.keyboard
	| typeof REASONS.incrementPress
	| typeof REASONS.decrementPress
	| typeof REASONS.wheel
	| typeof REASONS.scrub
	| typeof REASONS.none;

export type NumberFieldRootCommitEventDetails =
	BaseUIGenericEventDetails<NumberFieldRootCommitEventReason>;

/**
 * Root context shared across every `<NumberField.*>` part. Every reactive
 * entry is exposed as an `Accessor<T>` so descendants can subscribe to the
 * pieces they care about without rereading the entire bag.
 *
 * Non-reactive slots (`inputRef`, `valueRef`, `hasPendingCommitRef`) are
 * plain mutable records — shared between root / input / buttons so each
 * part can read the latest committed state synchronously from event
 * handlers.
 */
export interface NumberFieldRootContextValue {
	inputRef: { current: HTMLInputElement | null };
	inputValue: Accessor<string>;
	value: Accessor<number | null>;
	minWithDefault: Accessor<number>;
	maxWithDefault: Accessor<number>;
	disabled: Accessor<boolean>;
	readOnly: Accessor<boolean>;
	id: string;
	setValue: (
		value: number | null,
		details: NumberFieldRootChangeEventDetails,
	) => boolean;
	getStepAmount: (event?: EventWithOptionalKeyState) => number | undefined;
	incrementValue: (amount: number, params: IncrementValueParameters) => boolean;
	allowInputSyncRef: { current: boolean };
	formatOptionsRef: { current: Intl.NumberFormatOptions | undefined };
	valueRef: { current: number | null };
	lastChangedValueRef: { current: number | null };
	hasPendingCommitRef: { current: boolean };
	name: Accessor<string | undefined>;
	required: Accessor<boolean>;
	invalid: Accessor<boolean>;
	inputMode: Accessor<InputMode>;
	getAllowedNonNumericKeys: () => Set<string | undefined>;
	min: Accessor<number | undefined>;
	max: Accessor<number | undefined>;
	setInputValue: (next: string) => void;
	locale: Accessor<Intl.LocalesArgument | undefined>;
	isScrubbing: Accessor<boolean>;
	setIsScrubbing: (next: boolean) => void;
	state: Accessor<NumberFieldRootState>;
	onValueCommitted: (
		value: number | null,
		eventDetails: NumberFieldRootCommitEventDetails,
	) => void;
}

/**
 * `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 NumberFieldRootContext =
	createContext<NumberFieldRootContextValue | null>(null);

export function useNumberFieldRootContext(): NumberFieldRootContextValue {
	const context = useContext(NumberFieldRootContext);
	if (context == null) {
		throw new Error(
			"Base UI: NumberFieldRootContext is missing. NumberField parts must be placed within <NumberField.Root>.",
		);
	}
	return context;
}