import { type Accessor, createContext, useContext } from "solid-js";
import type {
	BaseUIChangeEventDetails,
	BaseUIGenericEventDetails,
	REASONS,
} from "../internals/change-event-details";
import type { CompositeMetadata } from "../internals/composite/composite-context.ts";
import type { FieldRootState } from "../internals/field-constants";
import type { ThumbCollisionBehavior } from "../internals/slider-utils/resolve-thumb-collision.ts";
import type { Orientation } from "../internals/types";

/**
 * Custom event-details properties carried on every slider `onValueChange`.
 */
export interface SliderRootChangeEventCustomProperties {
	activeThumbIndex: number;
}

export type SliderRootChangeEventReason =
	| typeof REASONS.inputChange
	| typeof REASONS.trackPress
	| typeof REASONS.drag
	| typeof REASONS.keyboard
	| typeof REASONS.none;

export type SliderRootChangeEventDetails = BaseUIChangeEventDetails<
	SliderRootChangeEventReason,
	SliderRootChangeEventCustomProperties
>;

export type SliderRootCommitEventReason = SliderRootChangeEventReason;
export type SliderRootCommitEventDetails =
	BaseUIGenericEventDetails<SliderRootCommitEventReason>;

/**
 * State surface projected to `data-*` and visible to `class` / `style` /
 * `render` callbacks across every slider part.
 */
export interface SliderRootState extends FieldRootState {
	activeThumbIndex: number;
	disabled: boolean;
	dragging: boolean;
	max: number;
	min: number;
	minStepsBetweenValues: number;
	orientation: Orientation;
	step: number;
	values: readonly number[];
}

/**
 * Per-thumb metadata carried through the CompositeList. The `inputId` lets
 * `<Slider.Value>` build a space-separated `htmlFor` list.
 */
export interface ThumbMetadata {
	inputId: string | undefined;
}

/**
 * Two-element tuple capturing the pixel-percent position of the first and
 * last thumb relative to the control's `getBoundingClientRect()`. Each slot
 * is `undefined` until the corresponding thumb has been measured. Only used
 * when `thumbAlignment !== 'center'` — center-mode sliders derive positions
 * from value math and skip the ResizeObserver pipeline entirely.
 */
export type IndicatorPosition = readonly [
	number | undefined,
	number | undefined,
];

/**
 * Value handed down by `<Slider.Root>` to its compound parts. Reactive reads
 * are `Accessor<T>` so descendants can subscribe precisely.
 *
 * The `inset` / `renderBeforeHydration` / `indicatorPosition` /
 * `setIndicatorPosition` fields match React's edge-alignment context surface.
 * The only piece still deferred is the pre-hydration `<script>` injected by
 * React's `prehydrationScript.min.ts`.
 */
export interface SliderRootContextValue {
	active: Accessor<number>;
	lastUsedThumbIndex: Accessor<number>;
	controlRef: { current: HTMLElement | null };
	thumbRefs: { current: Array<HTMLElement | null> };
	dragging: Accessor<boolean>;
	setDragging: (next: boolean) => void;
	disabled: Accessor<boolean>;
	formatOptions: Accessor<Intl.NumberFormatOptions | undefined>;
	locale: Accessor<Intl.LocalesArgument | undefined>;
	largeStep: Accessor<number>;
	step: Accessor<number>;
	min: Accessor<number>;
	max: Accessor<number>;
	minStepsBetweenValues: Accessor<number>;
	orientation: Accessor<Orientation>;
	thumbCollisionBehavior: Accessor<ThumbCollisionBehavior>;
	form: Accessor<string | undefined>;
	name: Accessor<string | undefined>;
	values: Accessor<readonly number[]>;
	state: Accessor<SliderRootState>;
	labelId: Accessor<string | undefined>;
	rootLabelId: Accessor<string | undefined>;
	setLabelId: (id: string | undefined) => void;
	setActive: (index: number) => void;
	handleInputChange: (
		valueInput: number,
		index: number,
		event: KeyboardEvent | Event,
	) => void;
	setValue: (
		newValue: number | number[],
		details?: SliderRootChangeEventDetails,
	) => void;
	onValueCommitted: (
		value: number | readonly number[],
		details: SliderRootCommitEventDetails,
	) => void;
	registerThumbMap: (
		map: Map<Element, CompositeMetadata<ThumbMetadata> | null>,
	) => void;
	thumbMap: Accessor<Map<Element, CompositeMetadata<ThumbMetadata> | null>>;
	// Refs used by pointer-drag plumbing across parts.
	pressedInputRef: { current: HTMLInputElement | null };
	pressedThumbCenterOffsetRef: { current: number | null };
	pressedThumbIndexRef: { current: number };
	pressedValuesRef: { current: readonly number[] | null };
	lastChangedValueRef: { current: number | readonly number[] | null };
	lastChangeReasonRef: { current: SliderRootChangeEventReason };
	// Field bridge — children use these to commit validation.
	commitValidation: (value: unknown, revalidate?: boolean) => Promise<void>;
	registerFieldControlRef: (element: HTMLElement | null) => void;
	// Edge-alignment pipeline. `inset` is `true` when `thumbAlignment` is
	// `"edge"` or `"edge-client-only"`; `renderBeforeHydration` is `true` only
	// for `"edge"`. The latter is dormant until the SSR prehydration `<script>`
	// is wired but is plumbed now so SSR work is
	// purely additive.
	inset: Accessor<boolean>;
	renderBeforeHydration: Accessor<boolean>;
	indicatorPosition: Accessor<IndicatorPosition>;
	setIndicatorPosition: (
		updater: (prev: IndicatorPosition) => IndicatorPosition,
	) => void;
}

/**
 * Slider root context. `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 SliderRootContext = createContext<SliderRootContextValue | null>(
	null,
);

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