import type { RpcInfo } from './RpcServer'

export type AsyncFunction = Function & ((...args: any[]) => Promise<any>)

// Our secret tokens to recognise our messages
export const RPC_CALL = '__RPC_CALL__'
export const RPC_RESPONSE = '__RPC_RESPONSE__'

export interface RpcMessage {
	__WEBEXTENSION_RPC_MESSAGE__: typeof RPC_CALL | typeof RPC_RESPONSE,
	funcName: string,
}

export interface RpcCallMessage<F extends AsyncFunction = AsyncFunction> extends RpcMessage {
	__WEBEXTENSION_RPC_MESSAGE__: typeof RPC_CALL,
	funcName: F['name'],
	args: ReplaceRpcInfo<Parameters<F>, null>,
	addRpcInfoAsArgument: number | false,
}

export type RpcResponseMessage<F extends AsyncFunction = AsyncFunction> =
	| RpcResponseResolve<F>
	| RpcResponseReject
	| RpcResponseRpcError

interface RpcResponseMessage_base {
__WEBEXTENSION_RPC_MESSAGE__: typeof RPC_RESPONSE,
}

interface RpcResponseResolve<F extends AsyncFunction> extends RpcResponseMessage_base {
	returnValue: ReturnType<F>,
}

interface RpcResponseReject extends RpcResponseMessage_base {
	errorMessage: string,
}

interface RpcResponseRpcError extends RpcResponseMessage_base {
	rpcError: string,
}

export function isRpcCallMessage(message: any): message is RpcCallMessage {
	return !!(message && message['__WEBEXTENSION_RPC_MESSAGE__'] === RPC_CALL)
}

export function isRpcResponseMessage(message: any): message is RpcResponseMessage {
	return !!(message && message['__WEBEXTENSION_RPC_MESSAGE__'] === RPC_RESPONSE)
}

type Tail<T extends any[]> = T extends [infer _Head, ...infer Tail] ? Tail : [];

export type ReplaceRpcInfo<Params extends Parameters<AsyncFunction>, Replacement extends any> =
	Params extends [RpcInfo, ...any]
		? [Replacement, ...Tail<Params>]
		: Params