import type { JSX } from "@solidjs/web";
import { type Accessor, createContext, createMemo, useContext } from "solid-js";
import { createPopupCore } from "../internals/create-popup-core";
import { type MaybeAccessor, readOption } from "../internals/maybe-accessor";
import {
	SNAPSHOT_KEYS,
	type Snapshottable,
	snapshotKeys,
} from "../internals/observability/snapshot";

/**
 * Why the drawer's open state changed.
 *
 * - `"trigger-press"` — trigger was clicked or keyboard-activated.
 * - `"swipe"` — user swipe-dismissed the drawer.
 * - `"escape-key"` — Escape dismissed the drawer.
 * - `"outside-press"` — pointer pressed outside.
 * - `"close-button"` — `<Drawer.Close>` was pressed.
 * - `"close-watcher"` — Android CloseWatcher back-gesture.
 * - `"imperative"` — `dr.setOpen()` called programmatically.
 */
export type DrawerChangeReason =
	| "trigger-press"
	| "swipe"
	| "escape-key"
	| "outside-press"
	| "close-button"
	| "close-watcher"
	| "imperative";

import type {
	DrawerSnapPoint,
	DrawerSwipeDirection,
} from "./root/drawer-root-context";

export type { DrawerSnapPoint, DrawerSwipeDirection };

/**
 * Options for {@link createDrawer}.
 */
export interface CreateDrawerOptions {
	/**
	 * Open state. Consumer-owned signal.
	 */
	open: MaybeAccessor<boolean>;
	/**
	 * Whether interaction is suppressed.
	 * @default false
	 */
	disabled?: MaybeAccessor<boolean>;
	/**
	 * Modal surface kind (drawer is modal by default).
	 * @default true
	 */
	modal?: MaybeAccessor<boolean | "trap-focus">;
	/**
	 * When true, outside-press dismissal is disabled.
	 * @default false
	 */
	disablePointerDismissal?: MaybeAccessor<boolean>;
	/**
	 * Direction the drawer slides from.
	 * @default "down"
	 */
	swipeDirection?: MaybeAccessor<DrawerSwipeDirection>;
	/**
	 * Snap points list. When provided the drawer can be dragged to each point.
	 */
	snapPoints?: MaybeAccessor<DrawerSnapPoint[] | undefined>;
	/**
	 * Active snap point. Consumer-owned — pair with `onSnapPointChange`.
	 */
	snapPoint?: MaybeAccessor<DrawerSnapPoint | null | undefined>;
	/**
	 * Pre-change callback fired via `runWithOwner(null, ...)`.
	 */
	onOpenChange?: (
		open: boolean,
		event: Event,
		reason: DrawerChangeReason,
	) => void;
	/**
	 * Fires on every snap-point change request.
	 */
	onSnapPointChange?: (snapPoint: DrawerSnapPoint | null) => void;
}

/**
 * Public API returned by {@link createDrawer}.
 */
export interface DrawerApi {
	/** Reactive accessor for the current open state. */
	open: Accessor<boolean>;
	/** Whether interaction is suppressed. */
	disabled: Accessor<boolean>;
	/** Modal surface kind. */
	modal: Accessor<boolean | "trap-focus">;
	/** Whether outside-press dismissal is disabled. */
	disablePointerDismissal: Accessor<boolean>;
	/** Direction the drawer slides from. */
	swipeDirection: Accessor<DrawerSwipeDirection>;
	/** Active snap point accessor. */
	snapPoint: Accessor<DrawerSnapPoint | null | undefined>;
	/** Snap points list. */
	snapPoints: Accessor<DrawerSnapPoint[] | undefined>;

	/** Imperative open setter. */
	setOpen: (next: boolean, event?: Event, reason?: DrawerChangeReason) => void;
	/** Flip open (no-op when disabled). */
	toggle: (event?: Event, reason?: DrawerChangeReason) => void;
	/** Imperative snap-point setter. Fires `onSnapPointChange`. */
	setSnapPoint: (snapPoint: DrawerSnapPoint | null) => void;

	/** Context provider. */
	Provider: (props: { children: JSX.Element }) => JSX.Element;
}

const DrawerContext = createContext<DrawerApi | null>(null);

/**
 * Read the nearest {@link DrawerApi}. Throws unless `optional` is true.
 */
export function useDrawer(): DrawerApi;
export function useDrawer(optional: true): DrawerApi | null;
export function useDrawer(optional?: boolean): DrawerApi | null {
	const ctx = useContext(DrawerContext);
	if (ctx == null && !optional) {
		throw new Error(
			"Base UI: useDrawer() must be called inside a <dr.Provider>.",
		);
	}
	return ctx;
}

/**
 * Headless primitive for a drawer compound. Modal slide-in panel with swipe
 * dismissal and snap-point control. DOM machinery lives in `<Drawer.Root>`.
 */
export function createDrawer(options: CreateDrawerOptions): DrawerApi {
	const core = createPopupCore<DrawerChangeReason>({
		open: options.open,
		disabled: options.disabled,
		onOpenChange: options.onOpenChange,
	});

	const modal = createMemo<boolean | "trap-focus">(
		() => readOption(options.modal) ?? true,
		{ name: "drawer.modal" },
	);

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

	const swipeDirection = createMemo<DrawerSwipeDirection>(
		() =>
			(readOption(options.swipeDirection) ?? "down") as DrawerSwipeDirection,
		{ name: "drawer.swipeDirection" },
	);

	const snapPoint = createMemo<DrawerSnapPoint | null | undefined>(
		() => readOption(options.snapPoint),
		{ name: "drawer.snapPoint" },
	);

	const snapPoints = createMemo<DrawerSnapPoint[] | undefined>(
		() => readOption(options.snapPoints),
		{ name: "drawer.snapPoints" },
	);

	const setSnapPoint = (next: DrawerSnapPoint | null): void => {
		options.onSnapPointChange?.(next);
	};

	const api: DrawerApi = {
		open: core.open,
		disabled: core.disabled,
		modal,
		disablePointerDismissal,
		swipeDirection,
		snapPoint,
		snapPoints,
		setOpen: core.setOpen,
		toggle: core.toggle,
		setSnapPoint,
		Provider: (props) => (
			<DrawerContext value={api}>{props.children}</DrawerContext>
		),
	};

	(api as DrawerApi & Snapshottable)[SNAPSHOT_KEYS] = DRAWER_SNAPSHOT_KEYS;

	return api;
}

const DRAWER_SNAPSHOT_KEYS = snapshotKeys<DrawerApi>(
	"open",
	"disabled",
	"modal",
	"disablePointerDismissal",
	"swipeDirection",
	"snapPoint",
);