/**
 * Represents an object providing methods to serialize (format) and deserialize
 * (parse) message payloads.
 *
 * @see MessageFormatter
 * @see MessageParser
 */
export interface MessageFormat<TSend, TRecv = TSend> {
	formatter: MessageFormatter<TSend>;
	parser: MessageParser<TRecv>;
}

/**
 * Serializes message payload into a binary or text format that can be sent
 * over the WebSocket.
 */
export type MessageFormatter<TSend> = (
	message: TSend,
) => string | ArrayBufferLike | Blob | ArrayBufferView;

export type RecvIgnore = typeof recvIgnoreTag;

/**
 * Parses message payload. If parser throws, the `recverror` event is
 * dispatched by the WebSocketClient. If parser returns
 * {@link recvIgnore `recvIgnore()`} special value, the message is ignored and
 * no `message` event is dispatched. Any  other value returned by the parser is
 * considered a message payload.
 */
export type MessageParser<TRecv> = (data: any) => TRecv | RecvIgnore;

export interface SendOptions<TSend> {
	ws: WebSocket;
	format: Pick<MessageFormat<TSend>, "formatter">;
}

export function send<TSend>(message: TSend, options: SendOptions<TSend>): void {
	const data = options.format.formatter(message);
	options.ws.send(data);
}

export interface RecvOptions<TRecv> {
	format: Pick<MessageFormat<TRecv>, "parser">;
}

export type RecvResult<TRecv> =
	| { type: "message"; message: TRecv }
	| { type: "ignore" }
	| { type: "error"; error: any };

export function recv<TRecv>(
	event: MessageEvent,
	options: RecvOptions<TRecv>,
): RecvResult<TRecv> {
	try {
		const message = options.format.parser(event.data);
		return message !== recvIgnoreTag ? { type: "message", message } : { type: "ignore" };
	} catch (err) {
		return { type: "error", error: err };
	}
}

const recvIgnoreTag: unique symbol = Symbol("recvIgnoreTag");

/**
 * Special value that can be returned by parser to prevent the `message` event
 * from being dispatched. Useful for creating lenient parsers that skip
 * unparseable payloads:
 *
 * ```ts
 * const parser: MessageParser<number> = (data) => {
 *   if (typeof data === 'string') {
 *     const parsed = Number.parseInt(data, 10);
 *     return Number.isFinite(parsed) ? parsed : recvIgnore();
 *   }
 *
 *   return recvIgnore();
 * }
 * ```
 */
export function recvIgnore(): typeof recvIgnoreTag {
	return recvIgnoreTag;
}