import {
	type AutocompleteInteraction,
	type User,
	type Attachment,
	type Role,
	type GuildBasedChannel,
	type ApplicationCommandOptionChoiceData,
	type LocalizationMap,
} from "discord.js";

export const OPTION_TYPES = {
	subcommand: 1,
	subcommandGroup: 2,
	string: 3,
	integer: 4,
	boolean: 5,
	user: 6,
	channel: 7,
	role: 8,
	mentionable: 9,
	number: 10,
	attachment: 11,
} as const;
export type OptionType = keyof typeof OPTION_TYPES;

export interface OptionChoice<T> {
	name: string;
	nameLocalizations?: LocalizationMap;
	value: T;
}

export interface OptionConfig<T> {
	required?: boolean;
	autocomplete?: AutocompleteFn<T>;
	choices?: OptionChoice<T>[];
	nameLocalizations?: LocalizationMap;
	descriptionLocalizations?: LocalizationMap;
}

export interface Option<T, Req extends boolean> extends OptionConfig<T> {
	type: OptionType;
	description?: string;
	required: Req;
	__type?: T;
}

export interface CommandOption<T, Req extends boolean> extends Option<T, Req> {
	description: string;
}

/**
 * recursively infers strict typescript types from your option schema.
 * options marked as `required: true` will be inferred as `T`, while optional
 * parameters will be inferred as `T | undefined`.
 */
export type InferOptions<O> = {
	[K in keyof O]: O[K] extends Option<infer Type, infer Required>
		? Required extends true
			? Type
			: Type | undefined
		: never;
};

/**
 * a helper function to provide dynamic autocomplete choices to the user.
 * kitten handles routing the autocomplete interaction and running this helper automatically.
 */
export type AutocompleteFn<T> = (
	interaction: AutocompleteInteraction,
	value: T,
) => Promise<ApplicationCommandOptionChoiceData[]> | ApplicationCommandOptionChoiceData[];

export interface OptionBuilder<T> {
	(description: string, config: OptionConfig<T> & { required: true }): CommandOption<T, true>;
	(description: string, config?: OptionConfig<T> & { required?: false }): CommandOption<T, false>;
	(config: OptionConfig<T> & { required: true }): Option<T, true>;
	(config?: OptionConfig<T> & { required?: false }): Option<T, false>;

	required(description: string, config?: Omit<OptionConfig<T>, "required">): CommandOption<T, true>;
	optional(
		description: string,
		config?: Omit<OptionConfig<T>, "required">,
	): CommandOption<T, false>;
}

const createOption = <T>(type: OptionType): OptionBuilder<T> => {
	const build = (
		descOrConfig?: string | OptionConfig<T>,
		configObj?: OptionConfig<T>,
		overrideReq?: boolean,
	): any => {
		const hasDesc = typeof descOrConfig === "string";
		const description = hasDesc ? descOrConfig : undefined;
		const actualConfig = hasDesc ? configObj : (descOrConfig as OptionConfig<T>);

		return {
			type,
			description,
			required: overrideReq ?? actualConfig?.required ?? false,
			autocomplete: actualConfig?.autocomplete,
			choices: actualConfig?.choices,
			nameLocalizations: actualConfig?.nameLocalizations,
			descriptionLocalizations: actualConfig?.descriptionLocalizations,
		};
	};

	const fn: any = (doc?: any, c?: any) => build(doc, c);
	fn.required = (d: string, c?: any) => build(d, c, true);
	fn.optional = (d: string, c?: any) => build(d, c, false);

	return fn as OptionBuilder<T>;
};

/**
 * definitions for command and component options. these generate type-safe parameters
 * directly inside of your interaction's `run` callback.
 *
 * @example
 * ```ts
 * options: {
 * 	user: option.user.required("the user to get information about"),
 * 	ephemeral: option.boolean.optional("whether the response should be ephemeral"),
 * }
 * ```
 */
export const option = {
	string: createOption<string>("string"),
	integer: createOption<number>("integer"),
	number: createOption<number>("number"),
	boolean: createOption<boolean>("boolean"),
	user: createOption<User>("user"),
	channel: createOption<GuildBasedChannel>("channel"),
	role: createOption<Role>("role"),
	mentionable: createOption<User | Role>("mentionable"),
	attachment: createOption<Attachment>("attachment"),
};