import { type Accessor, createContext, useContext } from "solid-js";
import type {
	FieldValidationMode,
	FieldValidityData,
	MutableRef,
} from "./field-context";

/**
 * Mapping of field name → error(s). Populated by `<Form>` after server-side
 * validation or external submission feedback.
 */
export type FormErrors = Record<string, string | string[]>;

/**
 * Registration record that field controls push into `<Form>` so that `<Form>`
 * can orchestrate cross-field validation / submission.
 */
export interface FormFieldEntry {
	name: string | undefined;
	/**
	 * Imperatively validate the field's currently-registered control. Returns
	 * a Promise when the field has an async validator in flight; otherwise
	 * returns synchronously. Form-level submit awaits the Promise (when
	 * present) before reading `validityData`, so async validators
	 * (`zod.parseAsync`, async refinements, server-side checks) block submit.
	 */
	validate: (flushSync?: boolean) => Promise<void> | void;
	validityData: FieldValidityData;
	getValue: () => unknown;
	controlRef: MutableRef<HTMLElement | null>;
}

/**
 * Opaque handle held by `<Form>` so field controls have a stable place to
 * register without going through the reactive graph. The `fields` map is
 * mutated directly by field controls — do NOT put it in a signal or store.
 */
export interface FormRefState {
	fields: Map<string, FormFieldEntry>;
}

export interface FormContextValue {
	/** Ref holding the mutable fields map. */
	readonly formRef: MutableRef<FormRefState>;
	/** External errors (e.g. from server validation). */
	errors: Accessor<FormErrors>;
	/** Replace the entire errors map. */
	setErrors: (next: FormErrors) => void;
	/** Clear errors for a single field name (or the whole map if undefined). */
	clearErrors: (name: string | undefined) => void;
	/** Validation mode used when children don't override via `<Field.Root>`. */
	validationMode: Accessor<FieldValidationMode>;
	/** Whether the user has attempted a submit at least once. */
	submitAttemptedRef: MutableRef<boolean>;
	/** Marker — `true` when this context was provided by a real `<Form>`. */
	readonly present: boolean;
}

const NOOP = () => {};

/**
 * Factory for a fresh noop form context. Each call builds a new `fields`
 * map so tests (and real code paths) that imperatively mutate
 * `formRef.current.fields` can't leak state across runs via a shared
 * module-load singleton.
 *
 * `useFormContext` calls this when no `<Form>` provider is above, so every
 * consumer receives its own noop instance.
 */
export function createNoopFormContext(): FormContextValue {
	return {
		formRef: { current: { fields: new Map() } },
		errors: () => ({}),
		setErrors: NOOP,
		clearErrors: NOOP,
		validationMode: () => "onSubmit",
		submitAttemptedRef: { current: false },
		present: false,
	};
}

/**
 * Identity-only sentinel. `useFormContext` compares against this to detect
 * "no `<Form>` provider above" and return a fresh noop instead of the
 * shared default — preventing cross-call state leaks via `fields`
 * mutations. The sentinel itself is never returned from the hook.
 *
 * Exported as `NOOP_FORM_CONTEXT` for barrel / compat only; application
 * code should call `useFormContext()` and branch on `.present`.
 */
export const NOOP_FORM_CONTEXT: FormContextValue = createNoopFormContext();

/**
 * Context carrying `<Form>` state. Provided via `<FormContext value={...}>`.
 * Default value is the shared sentinel — `useFormContext` detects it by
 * identity and substitutes a fresh noop.
 */
export const FormContext = createContext<FormContextValue>(NOOP_FORM_CONTEXT);

/**
 * Read the current `<Form>` context. When unwrapped (no `<Form>` ancestor),
 * returns a fresh noop so callers that mutate `formRef.current.fields` can't
 * inadvertently share state with other roots. Callers can branch on
 * `.present` to detect "no form".
 */
export function useFormContext(): FormContextValue {
	const ctx = useContext(FormContext);
	if (ctx === NOOP_FORM_CONTEXT) {
		return createNoopFormContext();
	}
	return ctx;
}