gsender

import {
	useCallback,
	useEffect,
	useRef,
	useState,
	useSyncExternalStore,
} from "react";

import {
	getTopicSnapshot,
	type PluginBridgeTopic,
	subscribeTopic,
	type ViewerPickEvent,
} from "./bridge.js";
import { gsender } from "./index.js";

// --- React hooks --------------------------------------------------------------
// These run in the plugin's OWN React. They mirror gSender's `useWorkspaceState`
// and `useTypedSelector` by subscribing to snapshots pushed across the bridge.

const useTopicSnapshot = <T>(topic: PluginBridgeTopic): T | undefined => {
	const subscribe = useCallback(
		(notify: () => void) => subscribeTopic(topic, notify),
		[topic],
	);

	const getSnapshot = useCallback(() => getTopicSnapshot<T>(topic), [topic]);

	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
};

/**
 * Live gSender workspace state (units, machine profile, tools, etc.).
 * Mirrors the host `useWorkspaceState` hook.
 */
export const useWorkspaceState = <T = unknown>(): T | undefined =>
	useTopicSnapshot<T>("workspace");

/**
 * The latest result from one of your parsers, re-rendering when it fires.
 *
 * Returns immediately with the cached last result if one exists, so a view that
 * mounts long after the match still shows it. Use `machine.onParsed` instead if
 * you need to observe EVERY match — this hook holds only the most recent one.
 */
export const useParsed = <T = unknown>(id: string): T | undefined => {
	const byId = useTopicSnapshot<Record<string, T>>("parser");
	return byId?.[id];
};

/**
 * Select a slice of gSender's redux state, re-rendering when it changes.
 * Mirrors the host `useTypedSelector` hook.
 *
 * @param selector Derives the value you care about from the root redux state.
 * @param equalityFn Optional; skip re-renders when the selected value is "equal".
 */
export const useTypedSelector = <Selected, State = unknown>(
	selector: (state: State) => Selected,
	equalityFn?: (a: Selected, b: Selected) => boolean,
): Selected | undefined => {
	const root = useTopicSnapshot<State>("redux");
	const lastSelected = useRef<{ value: Selected } | null>(null);

	if (root === undefined) {
		return undefined;
	}

	const nextSelected = selector(root);

	if (lastSelected.current) {
		const prev = lastSelected.current.value;
		const isSame = equalityFn
			? equalityFn(prev, nextSelected)
			: prev === nextSelected;
		if (isSame) {
			return prev;
		}
	}

	lastSelected.current = { value: nextSelected };
	return nextSelected;
};

/**
 * Arm point-picking on the host visualizer for the lifetime of the component.
 *
 * Arms on mount (unless `opts.enabled === false`) and disarms on unmount or when
 * disabled. The latest `handler` is kept in a ref, so re-renders that only change
 * the handler don't re-arm the pick.
 *
 * @param mode `'click'` (single click) or `'hold'` (press-and-hold, which also
 *   emits `hold-progress` events).
 * @param handler Called with each `ViewerPickEvent` while armed.
 * @param opts.enabled Set `false` to keep the pick disarmed (default `true`).
 * @returns `armed` (whether the host accepted the arm) and `error` (the host's
 *   rejection message, or `null`).
 */
export const useVisualizerPick = (
	mode: "click" | "hold",
	handler: (e: ViewerPickEvent) => void,
	opts?: { enabled?: boolean },
): { armed: boolean; error: string | null } => {
	const enabled = opts?.enabled !== false;

	const [armed, setArmed] = useState(false);
	const [error, setError] = useState<string | null>(null);

	// Keep the latest handler without re-arming when it changes.
	const handlerRef = useRef(handler);
	handlerRef.current = handler;

	useEffect(() => {
		if (!enabled) {
			return;
		}

		let cancelled = false;
		let dispose: (() => void) | null = null;

		gsender.viewer
			.armPick(mode, (event) => handlerRef.current(event))
			.then((disposer) => {
				if (cancelled) {
					// Unmounted/disabled before arming resolved — tear down now.
					disposer();
					return;
				}
				dispose = disposer;
				setArmed(true);
				setError(null);
			})
			.catch((err: unknown) => {
				if (cancelled) {
					return;
				}
				setArmed(false);
				setError(err instanceof Error ? err.message : String(err));
			});

		return () => {
			cancelled = true;
			setArmed(false);
			dispose?.();
		};
	}, [mode, enabled]);

	return { armed, error };
};