import type { JSX } from "@solidjs/web";
import type { Accessor } from "solid-js";
import type { FieldValidationProps, MutableRef } from "../field-context";
import { useFieldRootContext } from "../field-context";
import { mergePropsN, type PropsLike } from "../merge-props-n";
import { ariaInvalid } from "../seed-aria-attr";
import { useFieldControlRegistration } from "../use-field-control-registration/use-field-control-registration";

export interface UseFieldControlValidationParameters {
	/** Accessor for the control's live value (checkbox `checked`, etc). */
	value: Accessor<unknown>;
	/** Accessor for the id to register under `<Field.Root>`. */
	id: Accessor<string | undefined>;
	/**
	 * Ref to the visible control element (the `<button>` that renders the
	 * checkbox UI, not the hidden input).
	 */
	controlRef: MutableRef<HTMLElement | null>;
	/** Optional explicit value getter — when the value lives on a hidden input. */
	getValue?: (() => unknown) | undefined;
	/**
	 * `false` disables registration. Threaded through to
	 * `useFieldControlRegistration` for checkbox-in-checkbox-group cases.
	 */
	enabled?: Accessor<boolean | undefined> | undefined;
}

export interface UseFieldControlValidationReturn {
	/**
	 * Adds a11y hooks (`aria-invalid`, `aria-describedby`) to a props bag.
	 * Thin wrapper around `validation.getValidationProps` from the parent
	 * field — delegates so tier-2 controls don't have to reach into the
	 * context directly.
	 */
	getValidationProps: (
		externalProps?: JSX.HTMLAttributes<HTMLElement>,
	) => JSX.HTMLAttributes<HTMLElement>;
	/**
	 * Same as {@link getValidationProps} but adds the `onInput` -> `commit`
	 * bridge expected on a native `<input>` element.
	 */
	getInputValidationProps: (
		externalProps?: JSX.InputHTMLAttributes<HTMLInputElement>,
	) => JSX.InputHTMLAttributes<HTMLInputElement>;
	/**
	 * Minimal props bag containing only the derived `aria-invalid` attribute.
	 * Useful when the caller wants to splat just the a11y flag without the
	 * aria-describedby plumbing that lives in `getValidationProps` (currently
	 * a no-op for tier-2 widgets — kept as a parity surface for when the
	 * description context lands).
	 */
	getAriaInvalidProps: () => PropsLike;
	/** Ref the native validation machinery uses to read `element.validity`. */
	inputRef: MutableRef<HTMLInputElement | null>;
	/**
	 * Imperative trigger for the validation pipeline. Calls the parent's
	 * `validation.commit(value, revalidate?)`.
	 */
	commit: FieldValidationProps["commit"];
	/**
	 * Opaque symbol used to key the control's registration — surfaced for
	 * parity with React but rarely needed by callers.
	 */
	source: symbol;
}

/**
 * Compose `<Field.Root>`'s existing `useFieldValidation` machinery with
 * per-control registration for tier-2 widgets (checkbox, switch, radio, …).
 *
 * React parity: the React port splits this work across `useRegisterFieldControl`
 * and manual use of `validation` from the field-root context. Solid's
 * version collapses the two into a single hook so tier-2 components have a
 * single call site and don't need to pull `useFieldRootContext` themselves.
 *
 * Solid 2 notes:
 *
 * - Registration uses `useFieldControlRegistration` (P4), which installs
 *   its own `onCleanup` and `useValueChanged` bridge.
 * - `getValidationProps` / `getInputValidationProps` delegate to the parent
 *   field's pre-built props-factories — they already encode the correct
 *   `aria-invalid` semantics (literal `"true"` / `undefined` per RFC 07).
 * - When there's no `<Field.Root>` above, the hook still works: the noop
 *   field context returns pass-through props factories and a noop commit.
 */
export function useFieldControlValidation(
	params: UseFieldControlValidationParameters,
): UseFieldControlValidationReturn {
	const field = useFieldRootContext();

	const { source } = useFieldControlRegistration({
		value: params.value,
		id: params.id,
		controlRef: params.controlRef,
		getValue: params.getValue,
		enabled: params.enabled,
	});

	const getValidationProps: UseFieldControlValidationReturn["getValidationProps"] =
		(externalProps) => field.validation.getValidationProps(externalProps);

	const getInputValidationProps: UseFieldControlValidationReturn["getInputValidationProps"] =
		(externalProps) => field.validation.getInputValidationProps(externalProps);

	// Minimal aria-only projection. Re-reads the underlying field state on
	// every access so consumers splatting this into a reactive proxy (e.g.
	// `mergePropsN`) see the latest value. Outside a real `<Field.Root>` the
	// noop context has `present: false`; emit `undefined` so the key doesn't
	// appear on consumers that render standalone. WAI-ARIA 1.2 treats
	// `aria-invalid="false"` as equivalent to absent, so AT behavior is
	// unchanged.
	const getAriaInvalidProps: UseFieldControlValidationReturn["getAriaInvalidProps"] =
		() =>
			mergePropsN([
				ariaInvalid(() => {
					if (!field.present) return undefined;
					return field.state().valid === false;
				}),
			]);

	return {
		getValidationProps,
		getInputValidationProps,
		getAriaInvalidProps,
		inputRef: field.validation.inputRef,
		commit: field.validation.commit,
		source,
	};
}