import type { JSX } from "@solidjs/web";
import {
	type Accessor,
	createContext,
	createMemo,
	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 { defaultItemEquality } from "./utils/item-equality";

type ItemEqualityComparer<A, B> = (item: A, value: B) => boolean;

import { type ItemsInput, stringifyAsLabel } from "./utils/resolve-value-label";

/** Detect grouped items (has at least one entry with an `items` key). */
function isGroupedItems(items: unknown): boolean {
	if (!Array.isArray(items) || items.length === 0) return false;
	const first = items[0];
	return (
		typeof first === "object" &&
		first !== null &&
		"items" in first &&
		!("value" in first)
	);
}

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

export type SelectChangeReason =
	| "item-press"
	| "escape-key"
	| "outside-press"
	| "imperative";

import type { SelectValue } from "./select-root-context";

export type { SelectValue };

export interface CreateSelectOptions<
	Value = SelectValue,
	Multiple extends boolean | undefined = false,
> {
	/**
	 * Current selected value. Consumer-owned signal. Writes happen via
	 * `onValueChange` — the primitive does NOT keep an internal copy.
	 * Pass an array when `multiple: true`.
	 */
	value: MaybeAccessor<SelectValueType<Value, Multiple> | null | undefined>;
	onValueChange?: (
		value: SelectValueType<Value, Multiple> | null,
		reason: SelectChangeReason,
	) => void;

	/** Open state. Consumer-owned signal. */
	open: MaybeAccessor<boolean>;
	onOpenChange?: (open: boolean, reason: SelectChangeReason) => void;

	/** Whether multiple items may be selected. */
	multiple?: Multiple;

	disabled?: MaybeAccessor<boolean | undefined>;
	readOnly?: MaybeAccessor<boolean | undefined>;
	required?: MaybeAccessor<boolean | undefined>;

	/** Items registry — drives trigger label resolution for object values. */
	items?: MaybeAccessor<ItemsInput<Value> | undefined>;
	/** Formatter for object values (trigger display). */
	itemToStringLabel?: MaybeAccessor<((value: Value) => string) | undefined>;
	/** Formatter for object values (form submission). */
	itemToStringValue?: MaybeAccessor<((value: Value) => string) | undefined>;
	/** Custom equality comparer. Defaults to `Object.is`. */
	isItemEqualToValue?: MaybeAccessor<
		((itemValue: Value, value: Value) => boolean) | undefined
	>;
}

type SelectValueType<
	Value,
	Multiple extends boolean | undefined,
> = Multiple extends true ? Value[] : Value;

export interface SelectApi<
	Value = SelectValue,
	Multiple extends boolean | undefined = false,
> {
	/** Reactive accessor for the current selected value. */
	value: Accessor<SelectValueType<Value, Multiple> | null>;
	/** Reactive accessor for the open state. */
	open: Accessor<boolean>;

	multiple: boolean;
	disabled: Accessor<boolean>;
	readOnly: Accessor<boolean>;
	required: Accessor<boolean>;

	/** Items registry (for label resolution / group support). */
	items: Accessor<ItemsInput<Value> | undefined>;
	/** Whether the items list is grouped. */
	isGrouped: Accessor<boolean>;

	/** Check whether a given item value is currently selected. */
	isItemSelected: (item: Value) => boolean;

	/** Display label for the current value. Empty string when nothing is selected. */
	valueLabel: Accessor<string>;

	/** Pure event-emitter — fire `onValueChange`. Consumer owns the signal write. */
	setValue: (
		next: SelectValueType<Value, Multiple> | null,
		reason?: SelectChangeReason,
	) => void;
	/** Pure event-emitter — fire `onOpenChange`. */
	setOpen: (next: boolean, reason?: SelectChangeReason) => void;

	/**
	 * Context provider. Wrap a subtree to make the api discoverable via
	 * `useSelect()` without prop-drilling.
	 */
	Provider: (props: { children: JSX.Element }) => JSX.Element;
}

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

const SelectCtx = createContext<SelectApi<unknown, boolean | undefined> | null>(
	null,
);

export function useSelect<
	Value = SelectValue,
	Multiple extends boolean | undefined = false,
>(): SelectApi<Value, Multiple> {
	const ctx = useContext(SelectCtx);
	if (ctx == null) {
		throw new Error(
			"Base UI: useSelect() must be called inside a <c.Provider>.",
		);
	}
	return ctx as SelectApi<Value, Multiple>;
}

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

/**
 * Solid 2-native headless primitive for the select selection logic. Owns:
 * value / open state, isItemSelected derivation, and valueLabel. No filter
 * input (Select has no text input). DOM concerns (floating-ui positioning,
 * keyboard nav, portal, hidden form input) live in the structural
 * `<Select.Root>` wrapper that composes this primitive.
 */
export function createSelect<
	Value = SelectValue,
	Multiple extends boolean | undefined = false,
>(options: CreateSelectOptions<Value, Multiple>): SelectApi<Value, Multiple> {
	// Freeze multi-select at init — the scalar vs. array value shape cannot
	// flip after mount.
	const isMultiple = untrack(() => options.multiple === true);

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

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

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

	const itemToStringLabel = createMemo<((value: Value) => string) | undefined>(
		() => readOption(options.itemToStringLabel),
		{ name: "select.itemToStringLabel" },
	);

	const isItemEqualToValue = createMemo<ItemEqualityComparer<Value, Value>>(
		() =>
			(readOption(options.isItemEqualToValue) as
				| ItemEqualityComparer<Value, Value>
				| undefined) ??
			(defaultItemEquality as ItemEqualityComparer<Value, Value>),
		{ name: "select.isItemEqualToValue" },
	);

	// Value — reads through the consumer's accessor.
	const value = createMemo<SelectValueType<Value, Multiple> | null>(
		() => {
			const raw = readOption(options.value) as
				| SelectValueType<Value, Multiple>
				| null
				| undefined;
			if (isMultiple) {
				return (
					Array.isArray(raw) ? raw : raw == null ? [] : raw
				) as SelectValueType<Value, Multiple>;
			}
			return (raw ?? null) as SelectValueType<Value, Multiple> | null;
		},
		{ name: "select.value" },
	);

	// Open — reads through the consumer's accessor.
	const open = createMemo<boolean>(() => Boolean(readOption(options.open)), {
		name: "select.open",
	});

	// Items registry
	const items = createMemo<ItemsInput<Value> | undefined>(
		() => readOption(options.items) as ItemsInput<Value> | undefined,
		{ name: "select.items" },
	);

	const isGrouped = createMemo<boolean>(
		() => {
			const its = items();
			if (!its) return false;
			return isGroupedItems(its as unknown[]);
		},
		{ name: "select.isGrouped" },
	);

	// isItemSelected — pure derivation.
	const isItemSelected = (item: Value): boolean => {
		const sv = value();
		if (sv == null) return false;
		const comparer = isItemEqualToValue();
		if (isMultiple && Array.isArray(sv)) {
			return (sv as Value[]).some((v) => comparer(item, v));
		}
		return comparer(item, sv as Value);
	};

	// Display label for the trigger — derived from value + itemToStringLabel.
	const valueLabel = createMemo<string>(
		() => {
			const sv = value();
			if (sv == null) return "";
			if (isMultiple && Array.isArray(sv)) {
				return (sv as Value[])
					.map((v) =>
						stringifyAsLabel(
							v,
							itemToStringLabel() as ((item: unknown) => string) | undefined,
						),
					)
					.join(", ");
			}
			return stringifyAsLabel(
				sv,
				itemToStringLabel() as ((item: unknown) => string) | undefined,
			);
		},
		{ name: "select.valueLabel" },
	);

	// Pure event-emitters — runWithOwner(null, ...) escapes the reactive owner
	// so signal writes inside the callback don't trigger SIGNAL_WRITE_IN_OWNED_SCOPE.
	const setValue = (
		next: SelectValueType<Value, Multiple> | null,
		reason: SelectChangeReason = "imperative",
	): void => {
		runWithOwner(null, () => options.onValueChange?.(next, reason));
	};

	const setOpen = (
		next: boolean,
		reason: SelectChangeReason = "imperative",
	): void => {
		runWithOwner(null, () => options.onOpenChange?.(next, reason));
	};

	const api: SelectApi<Value, Multiple> = {
		value,
		open,
		multiple: isMultiple,
		disabled,
		readOnly,
		required,
		items,
		isGrouped,
		isItemSelected,
		valueLabel,
		setValue,
		setOpen,
		Provider: (props) => (
			<SelectCtx value={api as SelectApi<unknown, boolean | undefined>}>
				{props.children}
			</SelectCtx>
		),
	};

	(api as SelectApi<Value, Multiple> & Snapshottable)[SNAPSHOT_KEYS] =
		SELECT_SNAPSHOT_KEYS;

	return api;
}

const SELECT_SNAPSHOT_KEYS = snapshotKeys<SelectApi>(
	"value",
	"open",
	"disabled",
	"readOnly",
	"required",
	"valueLabel",
);