import type {
	ChatInputCommandInteraction,
	UserContextMenuCommandInteraction,
	MessageContextMenuCommandInteraction,
	BaseInteraction,
	ButtonInteraction,
	AnySelectMenuInteraction,
	ModalSubmitInteraction,
	LocalizationMap,
} from "discord.js";
import type { CommandOption, Option, InferOptions } from "./options";
import {
	KittenComponent,
	KittenComponentInteraction,
	type KittenComponentConfig,
} from "./components";

export const INTEGRATION_TYPES = {
	GUILD_INSTALL: 0,
	USER_INSTALL: 1,
} as const;
export const INTERACTION_CONTEXTS = {
	GUILD: 0,
	BOT_DM: 1,
	PRIVATE_CHANNEL: 2,
} as const;

export const INTEGRATION_TYPE_PRESETS = {
	ALL: Object.values(INTEGRATION_TYPES),
	GUILD_ONLY: [INTEGRATION_TYPES.GUILD_INSTALL],
	USER_ONLY: [INTEGRATION_TYPES.USER_INSTALL],
};
export const INTEGRATION_CONTEXT_PRESETS = {
	EVERYWHERE: Object.values(INTERACTION_CONTEXTS),
	GUILDS_ONLY: [INTERACTION_CONTEXTS.GUILD],
	DMS_ONLY: [INTERACTION_CONTEXTS.BOT_DM, INTERACTION_CONTEXTS.PRIVATE_CHANNEL],
};

export type CommandResultType<Res = unknown> = Promise<Res> | Res;
export type IntegrationType = (typeof INTEGRATION_TYPES)[keyof typeof INTEGRATION_TYPES];
export type InteractionContextType =
	(typeof INTERACTION_CONTEXTS)[keyof typeof INTERACTION_CONTEXTS];

/**
 * pre-execution interceptors that let you chain execution checks and pass their
 * results down as strongly-typed context.
 *
 * @throws {HaltExecution} if you wish to intentionally stop propagation.
 */
export type Middleware<I extends BaseInteraction = BaseInteraction, InCtx = any, OutCtx = any> = (
	interaction: I,
	ctx: InCtx,
) => Promise<OutCtx | void> | OutCtx | void;

/**
 * an exception handler that can catch, handle, or rethrow errors.
 * these are context-aware and will receive whatever context was successfully accumulated
 * before the exception occurred.
 */
export type ErrorHandler<I extends BaseInteraction = BaseInteraction, Ctx = any> = (
	err: unknown,
	interaction: I,
	ctx: Ctx,
) => Promise<unknown> | unknown;

/**
 * strictly-typed post-execution flow handlers.
 *
 * afterwares run sequentially inside a safe `finally` block and execute regardless
 * of whether the interaction completed cleanly, threw an exception, or was halted.
 */
export type Afterware<I extends BaseInteraction = BaseInteraction, Ctx = any, Res = unknown> = (
	interaction: I,
	ctx: Ctx,
	error: unknown | null,
	result: Res | undefined,
) => Promise<void> | void;

export interface BaseCommandConfig<I extends BaseInteraction = BaseInteraction, Ctx = any> {
	integrationTypes?: IntegrationType[];
	contexts?: InteractionContextType[];
	nameLocalizations?: LocalizationMap;
	defaultMemberPermissions?: string | number | bigint | any;
	nsfw?: boolean;
	onError?: ErrorHandler<I, Ctx>;
}

export interface LocalizedDescription {
	description: string;
	descriptionLocalizations?: LocalizationMap;
}

export interface ChatCommandConfig<
	O extends Record<string, CommandOption<any, any>>,
	Ctx = any,
	Res = unknown,
>
	extends BaseCommandConfig<ChatInputCommandInteraction, Ctx>, LocalizedDescription {
	options?: O;
	run: (
		interaction: ChatInputCommandInteraction,
		args: InferOptions<O>,
		ctx: Ctx,
	) => CommandResultType<Res>;
}

export interface ContextMenuConfig<
	I extends BaseInteraction,
	Ctx = any,
	Res = unknown,
> extends BaseCommandConfig<I, Ctx> {
	run: (interaction: I, ctx: Ctx) => CommandResultType<Res>;
}

export class Subcommand {
	constructor(
		public name: string,
		public config: ChatCommandConfig<any, any, any>,
	) {}
}

export class SubcommandGroup<Ctx = {}, Res = unknown> {
	public subcommands: Record<string, Subcommand> = {};

	constructor(
		public name: string,
		public description: string,
		public config?: {
			nameLocalizations?: LocalizationMap;
			descriptionLocalizations?: LocalizationMap;
		},
	) {}

	/**
	 * append a subcommand to this specific group.
	 */
	subcommand<O extends Record<string, CommandOption<any, any>>, R extends Res>(
		name: string,
		config: ChatCommandConfig<O, Ctx, R>,
	): this {
		this.subcommands[name] = new Subcommand(name, config);
		return this;
	}
}

export class SubcommandGroupBuilder<Ctx = {}, Res = unknown> {
	public subcommands: Record<string, Subcommand> = {};
	public groups: Record<string, SubcommandGroup<Ctx, Res>> = {};

	constructor(
		public name: string,
		public description: string,
		public middlewares: Middleware<any, any, any>[] = [],
		public errorHandlers: ErrorHandler<any, any>[] = [],
		public afterwares: Afterware<any, any, any>[] = [],
		public config?: BaseCommandConfig<ChatInputCommandInteraction, Ctx> & LocalizedDescription,
	) {}

	/**
	 * chain a loose subcommand onto this builder.
	 */
	subcommand<O extends Record<string, CommandOption<any, any>>, R extends Res>(
		name: string,
		config: ChatCommandConfig<O, Ctx, R>,
	): this {
		this.subcommands[name] = new Subcommand(name, config);
		return this;
	}

	/**
	 * define a sub-group to isolate subcommands further.
	 */
	group(
		name: string,
		config: LocalizedDescription & { nameLocalizations?: LocalizationMap },
		setup: (group: SubcommandGroup<Ctx, Res>) => void,
	): this {
		const group = new SubcommandGroup<Ctx, Res>(name, config.description, config);
		setup(group);
		this.groups[name] = group;
		return this;
	}
}

export class Command<Ctx = any, Res = unknown> {
	constructor(
		public name: string,
		public config: ChatCommandConfig<any, Ctx, Res>,
		public middlewares: Middleware<any, any, any>[] = [],
		public errorHandlers: ErrorHandler<any, any>[] = [],
		public afterwares: Afterware<any, any, any>[] = [],
	) {}
}

export class ContextMenuCommand<
	Ctx = any,
	I extends UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction = any,
	Res = unknown,
> {
	constructor(
		public name: string,
		public type: "user" | "message",
		public run: (interaction: I, ctx: Ctx) => CommandResultType<Res>,
		public middlewares: Middleware<any, any, any>[] = [],
		public errorHandlers: ErrorHandler<any, any>[] = [],
		public afterwares: Afterware<any, any, any>[] = [],
		public config?: BaseCommandConfig<I, Ctx>,
	) {}
}

/**
 * a chainable builder for creating commands, context menus, and components with shared
 * context, middleware, error handlers, and afterwares.
 */
export class CommandBuilder<Ctx = {}, Res = unknown> {
	constructor(
		private middlewares: Middleware<any, any, any>[] = [],
		private errorHandlers: ErrorHandler<any, any>[] = [],
		private afterwares: Afterware<any, any, Res>[] = [],
	) {}

	/**
	 * attach a middleware to this builder. any context returned will be merged and
	 * strictly typed for all subsequent middlewares and handlers.
	 */
	use<NewCtx extends Record<string, any>>(
		mw: (interaction: BaseInteraction, ctx: Ctx) => Promise<NewCtx | void> | NewCtx | void,
	): CommandBuilder<Ctx & NewCtx, Res> {
		return new CommandBuilder<Ctx & NewCtx, Res>(
			[...this.middlewares, mw],
			this.errorHandlers,
			this.afterwares,
		);
	}

	/**
	 * attach a builder-level error handler. if an exception is thrown inside a command
	 * or component produced by this builder, this handler will catch it.
	 */
	onError(handler: ErrorHandler<BaseInteraction, Ctx>): CommandBuilder<Ctx, Res> {
		return new CommandBuilder<Ctx, Res>(
			this.middlewares,
			[...this.errorHandlers, handler],
			this.afterwares,
		);
	}

	/**
	 * attach an afterware to this builder. these strictly enforce the return type of your commands
	 * to prevent type safety degradation.
	 *
	 * @example
	 * ```ts
	 * .after<MyResult>(async (interaction, ctx, err, result) => {
	 * 	// result is strictly typed as: MyResult | undefined
	 * })
	 * ```
	 */
	after<NewRes>(handler: Afterware<BaseInteraction, Ctx, NewRes>): CommandBuilder<Ctx, NewRes> {
		return new CommandBuilder<Ctx, NewRes>(this.middlewares, this.errorHandlers, [
			...this.afterwares,
			handler as any,
		]);
	}

	/**
	 * construct a top-level chat input command.
	 */
	command<O extends Record<string, CommandOption<any, any>>, R extends Res>(
		name: string,
		config: ChatCommandConfig<O, Ctx, R>,
	): Command<Ctx, R>;

	/**
	 * construct a subcommand group base.
	 */
	command(
		name: string,
		config: BaseCommandConfig<ChatInputCommandInteraction, Ctx> & LocalizedDescription,
	): SubcommandGroupBuilder<Ctx, Res>;

	command(name: string, config: any): any {
		if (config.run) {
			return new Command<Ctx, Res>(
				name,
				config,
				this.middlewares,
				this.errorHandlers,
				this.afterwares,
			);
		}
		return new SubcommandGroupBuilder<Ctx, Res>(
			name,
			config.description,
			this.middlewares,
			this.errorHandlers,
			this.afterwares,
			config,
		);
	}

	private createContextMenu<
		I extends UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction,
		R extends Res,
	>(name: string, type: "user" | "message", runOrConfig: any) {
		const isFn = typeof runOrConfig === "function";
		return new ContextMenuCommand<Ctx, I, R>(
			name,
			type,
			isFn ? runOrConfig : runOrConfig.run,
			this.middlewares,
			this.errorHandlers,
			this.afterwares,
			isFn ? undefined : runOrConfig,
		);
	}

	/**
	 * construct a user context menu command.
	 */
	userContextMenu<R extends Res>(
		name: string,
		runOrConfig:
			| ((interaction: UserContextMenuCommandInteraction, ctx: Ctx) => CommandResultType<R>)
			| ContextMenuConfig<UserContextMenuCommandInteraction, Ctx, R>,
	): ContextMenuCommand<Ctx, UserContextMenuCommandInteraction, R> {
		return this.createContextMenu(name, "user", runOrConfig);
	}

	/**
	 * construct a message context menu command.
	 */
	messageContextMenu<R extends Res>(
		name: string,
		runOrConfig:
			| ((interaction: MessageContextMenuCommandInteraction, ctx: Ctx) => CommandResultType<R>)
			| ContextMenuConfig<MessageContextMenuCommandInteraction, Ctx, R>,
	): ContextMenuCommand<Ctx, MessageContextMenuCommandInteraction, R> {
		return this.createContextMenu(name, "message", runOrConfig);
	}

	private createComponent<
		I extends KittenComponentInteraction,
		O extends Record<string, Option<any, any>>,
		R extends Res,
	>(name: string, config: any): KittenComponent<I, O, Ctx, R> {
		return new KittenComponent<I, O, Ctx, R>(
			name,
			config,
			this.middlewares,
			this.errorHandlers,
			this.afterwares,
		);
	}

	/**
	 * construct a reusable button component handler.
	 */
	button<O extends Record<string, Option<any, any>>, R extends Res>(
		name: string,
		config: KittenComponentConfig<ButtonInteraction, O, Ctx, R>,
	): KittenComponent<ButtonInteraction, O, Ctx, R> {
		return this.createComponent(name, config);
	}

	/**
	 * construct a reusable select menu component handler.
	 */
	selectMenu<O extends Record<string, Option<any, any>>, R extends Res>(
		name: string,
		config: KittenComponentConfig<AnySelectMenuInteraction, O, Ctx, R>,
	): KittenComponent<AnySelectMenuInteraction, O, Ctx, R> {
		return this.createComponent(name, config);
	}

	/**
	 * construct a reusable modal component handler.
	 */
	modal<O extends Record<string, Option<any, any>>, R extends Res>(
		name: string,
		config: KittenComponentConfig<ModalSubmitInteraction, O, Ctx, R>,
	): KittenComponent<ModalSubmitInteraction, O, Ctx, R> {
		return this.createComponent(name, config);
	}
}