import {
	type Accessor,
	createRenderEffect,
	onCleanup,
	untrack,
} from "solid-js";
import type { FieldRegistration, MutableRef } from "../field-context";
import { useFieldRootContext } from "../field-context";

export interface UseFieldControlRegistrationParameters {
	/**
	 * Accessor for the control's current value. Tracked via `useValueChanged`
	 * so the registration is re-pushed whenever the value flips.
	 *
	 * Pass a plain `() => boolean` for checkbox/switch, `() => string` for
	 * radio value bindings, etc.
	 */
	value: Accessor<unknown>;
	/**
	 * Per-control id. Used as the key in `FormContext.formRef.current.fields`,
	 * and must be stable across the control's lifetime.
	 */
	id: Accessor<string | undefined>;
	/**
	 * Ref to the visible control element (the `<button role="checkbox">`,
	 * not the hidden `<input>`). `<Field.Root>` uses this for focus /
	 * scroll-into-view on submit failure.
	 */
	controlRef: MutableRef<HTMLElement | null>;
	/**
	 * Optional explicit getter. When present, the parent field will call this
	 * rather than reading the last `value` snapshot — useful when the real
	 * value lives on the hidden input element (e.g. text inputs).
	 */
	getValue?: (() => unknown) | undefined;
	/**
	 * `false` disables registration entirely (mirrors React's
	 * `useRegisterFieldControl({ enabled })`). Used by checkbox when it's a
	 * child of a `<CheckboxGroup>` that owns registration itself.
	 * @default true
	 */
	enabled?: Accessor<boolean | undefined> | undefined;
}

export interface UseFieldControlRegistrationReturn {
	/**
	 * Opaque symbol the hook uses as the registration key. Exposed for tests
	 * / advanced consumers; ordinary code can ignore it.
	 */
	source: symbol;
}

/**
 * Register a control into the surrounding `<Field.Root>`. Mirrors
 * `packages/react/src/internals/field-register-control/useRegisterFieldControl.ts`.
 *
 * Semantics:
 *
 * 1. On setup, if `enabled` is true and a `<Field.Root>` is present, push a
 *    fresh `{ controlRef, getValue, id, value }` registration keyed by a
 *    symbol allocated once per call.
 * 2. On value change (tracked via `useValueChanged`), re-push with the new
 *    value so the field root's cached `registration.value` stays accurate.
 * 3. On dispose, dispatch an `undefined` registration so the root can clean
 *    up. `<Field.Root>` uses the symbol to detect stale unregistrations.
 * 4. With no `<Field.Root>` above, `registerFieldControl` is a no-op (see
 *    `NOOP_FIELD_CONTEXT`) — the hook becomes a no-op without any branching.
 *
 * Solid 2 notes:
 *
 * - `onCleanup` is used for disposal instead of `onMount`/`useIsoLayoutEffect`
 *   return cleanups: the registration must fire during setup (synchronous
 *   with render) so a `<Field.Root>` submit attempt right after first paint
 *   sees the control.
 * - The re-register-on-value-change path uses `createRenderEffect(compute,
 *   apply)`. Compute reads `params.value()` (tracked); apply receives that
 *   value as its argument and avoids re-reading reactive state — reading in
 *   apply scope is untracked and trips `[STRICT_READ_UNTRACKED]`.
 * - `params.id()` and `params.enabled?.()` are read ONCE at setup. The docs
 *   pin both as stable across the control's lifetime; capturing them up
 *   front keeps the apply callback free of reactive reads so the diagnostic
 *   surface stays clean.
 */
export function useFieldControlRegistration(
	params: UseFieldControlRegistrationParameters,
): UseFieldControlRegistrationReturn {
	const { registerFieldControl } = useFieldRootContext();

	// One symbol per call. The field root keys off this to detect stale
	// unregistrations (e.g. if a late microtask tries to unregister after
	// the consumer already replaced the control).
	const source = Symbol("field-control");

	// Capture stable inputs at setup so `pushRegistration` can run from inside
	// an effect-apply callback without re-reading reactive state. Reads here
	// run inside the consumer component body's untrack-with-label scope; the
	// snapshot is intentional (and `params.value()` becomes reactive again
	// via the `createRenderEffect` below) so wrap in `untrack` to silence
	// `[STRICT_READ_UNTRACKED]`.
	const enabled = params.enabled
		? untrack(() => params.enabled?.() !== false)
		: true;
	if (!enabled) {
		return { source };
	}
	const id = untrack(params.id);

	function pushRegistration(value: unknown): void {
		const registration: FieldRegistration = {
			controlRef: params.controlRef,
			getValue: params.getValue,
			id,
			value,
		};
		registerFieldControl(source, registration);
	}

	// Initial registration — fires synchronously at setup. The
	// `createRenderEffect` below picks up subsequent `params.value()`
	// changes; wrap the snapshot in `untrack` to acknowledge the
	// intentional non-tracking read.
	pushRegistration(untrack(params.value));

	// Refresh registration whenever the tracked value changes. The compute
	// half tracks `value()`; apply receives the new value through its
	// argument and writes the registration without any reactive reads of its
	// own. `primed` skips the first apply (compute always fires once on
	// setup) to avoid duplicating the initial `pushRegistration` above.
	let primed = false;
	createRenderEffect(params.value, (value) => {
		if (!primed) {
			primed = true;
			return;
		}
		pushRegistration(value);
	});

	// Undo on dispose. The field root's registration dispatch handles the
	// `undefined` branch by deleting the source/id from its map.
	onCleanup(() => {
		registerFieldControl(source, undefined);
	});

	return { source };
}