import type {
	ToastManagerAddOptions,
	ToastManagerPromiseOptions,
	ToastManagerUpdateOptions,
} from "./use-toast-manager";

export interface ToastManagerEvent {
	action: "add" | "close" | "update" | "promise";
	options: {
		id?: string | undefined;
		promise?: Promise<unknown> | undefined;
		setPromise?: (promise: Promise<unknown>) => void;
		[key: string]: unknown;
	};
}

/**
 * Outside-of-component toast manager. Matches Base UI React's
 * `createToastManager` surface (`add` / `close` / `update` / `promise` +
 * the private " subscribe" channel the provider consumes).
 *
 * The provider subscribes to every emitted event and dispatches to the
 * store. Consumers call this manager's methods anywhere — it does not
 * depend on the Solid owner tree.
 */
export interface ToastManager<Data extends object = object> {
	" subscribe": (listener: (event: ToastManagerEvent) => void) => () => void;
	add: (options: ToastManagerAddOptions<Data>) => string;
	close: (id?: string) => void;
	update: (id: string, updates: ToastManagerUpdateOptions<Data>) => void;
	promise: <Value>(
		promise: Promise<Value>,
		options: ToastManagerPromiseOptions<Value, Data>,
	) => Promise<Value>;
}

let counter = 0;
function gid(): string {
	counter += 1;
	return `toast-ext-${counter}-${Math.random().toString(36).slice(2, 8)}`;
}

/**
 * Create a standalone toast manager. Pass the returned object to
 * `<Toast.Provider toastManager={...}>` so its events flow into the
 * provider's store.
 */
export function createToastManager<
	Data extends object = object,
>(): ToastManager<Data> {
	const listeners = new Set<(event: ToastManagerEvent) => void>();

	function emit(event: ToastManagerEvent): void {
		for (const listener of listeners) listener(event);
	}

	return {
		" subscribe": (listener) => {
			listeners.add(listener);
			return () => {
				listeners.delete(listener);
			};
		},
		add(options) {
			const id = options.id ?? gid();
			emit({
				action: "add",
				options: {
					...options,
					id,
					transitionStatus: "starting",
				},
			});
			return id;
		},
		close(id) {
			emit({ action: "close", options: { id } });
		},
		update(id, updates) {
			emit({
				action: "update",
				options: { ...updates, id },
			});
		},
		promise(promiseValue, options) {
			let handled: Promise<unknown> = promiseValue;
			emit({
				action: "promise",
				options: {
					...options,
					promise: promiseValue,
					setPromise(p: Promise<unknown>) {
						handled = p;
					},
				},
			});
			return handled as typeof promiseValue;
		},
	};
}