import type { JSX } from "@solidjs/web";
import {
	type Accessor,
	createContext,
	createMemo,
	untrack,
	useContext,
} from "solid-js";
import { makeSlotRefDirective } from "../internals/make-slot-ref-directive";
import { type MaybeAccessor, readOption } from "../internals/maybe-accessor";
import { mergeRootProps } from "../internals/merge-root-props";
import {
	SNAPSHOT_KEYS,
	type Snapshottable,
	snapshotKeys,
} from "../internals/observability/snapshot";

/**
 * Why the checked state changed. Emitted on the third arg of
 * `onCheckedChange(next, event, reason)`.
 *
 * - `"trigger-press"` — click / keyboard activation that bubbles to click on
 *   the switch root, OR a change on the co-located hidden `<input>` (AT /
 *   keyboard activating the checkbox directly).
 * - `"imperative"` — programmatic `setChecked` / `toggle` with no originating
 *   DOM event.
 */
export type SwitchChangeReason = "trigger-press" | "imperative";

/**
 * Options for {@link createSwitch}. Every reactive input is
 * `MaybeAccessor<T>` — pass an accessor to make the value reactive.
 *
 * **Solid-native shape (2026-04-30).** No internal state. `checked` is
 * required and the consumer always owns the signal. The primitive is a pure
 * function from `(checked, onCheckedChange) → api`. Migration:
 * `createSwitch({ defaultChecked: false })` becomes
 * `const [checked, setChecked] = createSignal(false); createSwitch({ checked, onCheckedChange: setChecked })`.
 * See `solidify.md` §6 for rationale.
 */
export interface CreateSwitchOptions {
	/**
	 * Checked state. Consumer-owned signal — the primitive reads through
	 * the accessor and does NOT keep an internal copy. Writes happen
	 * via `onCheckedChange` (the consumer's responsibility to update their
	 * signal in response).
	 */
	checked: MaybeAccessor<boolean>;
	/**
	 * Whether interaction is suppressed.
	 * @default false
	 */
	disabled?: MaybeAccessor<boolean>;
	/**
	 * Whether the switch is read-only — focusable but not activatable.
	 * @default false
	 */
	readOnly?: MaybeAccessor<boolean>;
	/**
	 * Whether the switch must be on for form submission.
	 * @default false
	 */
	required?: MaybeAccessor<boolean>;
	/**
	 * Pre-change callback. `event.preventDefault()` is now a no-op for
	 * the primitive (the consumer's signal write is the only writer);
	 * left in the signature for parity with other event channels.
	 *
	 * Pre/post asymmetry: reading `c.checked()` inside this handler returns
	 * the OLD value (the consumer's signal write hasn't flushed yet). For
	 * post-change observation use `createEffect(c.checked, ...)`.
	 */
	onCheckedChange?: (
		checked: boolean,
		event: Event,
		reason: SwitchChangeReason,
	) => void;
}

/**
 * Public API returned by {@link createSwitch}. Flat accessors and setters at
 * the root; no `state` snapshot blob.
 */
export interface SwitchApi {
	checked: Accessor<boolean>;
	disabled: Accessor<boolean>;
	readOnly: Accessor<boolean>;
	required: Accessor<boolean>;

	/**
	 * Flip `checked`. No-op while `disabled` or `readOnly`. Same `event?` /
	 * `reason?` contract as {@link setChecked}.
	 */
	toggle: (event?: Event, reason?: SwitchChangeReason) => void;
	/**
	 * Pure event-emitter: fires `onCheckedChange(next, event, reason)`.
	 * No-op while `disabled` or `readOnly`. The consumer's signal write
	 * (in their `onCheckedChange` handler) is the only writer.
	 */
	setChecked: (
		next: boolean,
		event?: Event,
		reason?: SwitchChangeReason,
	) => void;

	/**
	 * Trigger slot — getter-bag of attributes ready for spreading onto a
	 * `<button role="switch">`.
	 */
	trigger: <U extends object | undefined = undefined>(
		userProps?: U,
	) => SwitchTriggerSlotProps & (U extends object ? U : object);

	/**
	 * Directive form of {@link trigger} — returns a `ref` callback that
	 * spreads the trigger slot bag onto the element at apply time.
	 */
	triggerRef: () => (el: HTMLButtonElement | null) => void;

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

/** Shape of attributes emitted by `c.trigger()`. */
export interface SwitchTriggerSlotProps {
	type: "button";
	role: "switch";
	"aria-checked": "true" | "false";
	"aria-readonly": "true" | undefined;
	"aria-required": "true" | undefined;
	"data-checked": "" | undefined;
	"data-unchecked": "" | undefined;
	"data-disabled": "" | undefined;
	"data-readonly": "" | undefined;
	"data-required": "" | undefined;
	onClick: (event: MouseEvent) => void;
}

const SwitchContext = createContext<SwitchApi | null>(null);

/**
 * Read the nearest {@link SwitchApi} provided by `c.Provider`. Throws when
 * used outside a Provider.
 */
export function useSwitch(): SwitchApi {
	const ctx = useContext(SwitchContext);
	if (ctx == null) {
		throw new Error(
			"Base UI: useSwitch() must be called inside a <c.Provider>.",
		);
	}
	return ctx;
}

/**
 * Solid 2.0-native compound primitive for a two-state switch. One call owns
 * logical state (checked/disabled/readOnly/required, onCheckedChange). Form
 * wiring (the hidden `<input>`, name/value, field-control validation) is the
 * `<Switch.Root>` wrapper's job — those are integration concerns layered on
 * top of this primitive.
 */
export function createSwitch(options: CreateSwitchOptions): SwitchApi {
	// `checked` reads through the consumer's accessor — no internal signal,
	// no controlled-or-internal branching. Memoized so dependents see the
	// same identity within a tracking scope.
	const checked = createMemo<boolean>(
		() => Boolean(readOption(options.checked)),
		{
			name: "switch.checked",
		},
	);

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

	// `setChecked` / `toggle` are pure event-emitters. They fire
	// `onCheckedChange(next, event, reason)`; the consumer is responsible
	// for updating their checked-signal in response. There is no internal
	// state to write — `event.preventDefault()` is now a no-op for the
	// primitive.
	const setChecked = (
		next: boolean,
		event?: Event,
		reason: SwitchChangeReason = "imperative",
	): void => {
		if (untrack(disabled) || untrack(readOnly)) return;
		const ev = event ?? new Event("checkedchange", { cancelable: true });
		options.onCheckedChange?.(next, ev, reason);
	};

	const toggle = (
		event?: Event,
		reason: SwitchChangeReason = "imperative",
	): void => {
		setChecked(!untrack(checked), event, reason);
	};

	const triggerInternal = {
		type: "button" as const,
		role: "switch" as const,
		get "aria-checked"() {
			return checked() ? ("true" as const) : ("false" as const);
		},
		get "aria-readonly"() {
			return readOnly() ? ("true" as const) : undefined;
		},
		get "aria-required"() {
			return required() ? ("true" as const) : undefined;
		},
		get "data-checked"() {
			return checked() ? "" : undefined;
		},
		get "data-unchecked"() {
			return checked() ? undefined : "";
		},
		get "data-disabled"() {
			return disabled() ? "" : undefined;
		},
		get "data-readonly"() {
			return readOnly() ? "" : undefined;
		},
		get "data-required"() {
			return required() ? "" : undefined;
		},
		onClick(event: MouseEvent) {
			if (disabled() || readOnly()) return;
			setChecked(!untrack(checked), event, "trigger-press");
		},
	};

	const trigger = <U extends object | undefined>(userProps?: U) =>
		mergeRootProps(triggerInternal, userProps) as SwitchTriggerSlotProps &
			(U extends object ? U : object);

	const triggerRef = (): ((el: HTMLButtonElement | null) => void) =>
		makeSlotRefDirective(() => trigger());

	const api: SwitchApi = {
		checked,
		disabled,
		readOnly,
		required,
		toggle,
		setChecked,
		trigger,
		triggerRef,
		Provider: (props) => (
			<SwitchContext value={api}>{props.children}</SwitchContext>
		),
	};
	(api as SwitchApi & Snapshottable)[SNAPSHOT_KEYS] = SWITCH_SNAPSHOT_KEYS;
	return api;
}

const SWITCH_SNAPSHOT_KEYS = snapshotKeys<SwitchApi>(
	"checked",
	"disabled",
	"readOnly",
	"required",
);