import type {
	ChatInputCommandInteraction,
	UserContextMenuCommandInteraction,
	MessageContextMenuCommandInteraction,
	BaseInteraction,
	ButtonInteraction,
	AnySelectMenuInteraction,
	ModalSubmitInteraction,
} from "discord.js";
import type { CommandOption, Option, InferOptions } from "./options";
import { KittenComponent } 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];

export type Middleware<I extends BaseInteraction = BaseInteraction, InCtx = any, OutCtx = any> = (
	interaction: I,
	ctx: InCtx,
) => Promise<OutCtx | void> | OutCtx | void;

export type ErrorHandler<I extends BaseInteraction = BaseInteraction, Ctx = any> = (
	err: unknown,
	interaction: I,
	ctx: Ctx,
) => Promise<unknown> | unknown;

// Parameterized with Res. result is Res | undefined because execution may fail/halt.
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 class Subcommand {
	constructor(
		public name: string,
		public config: {
			description: string;
			options?: Record<string, CommandOption<any, any>>;
			onError?: ErrorHandler<ChatInputCommandInteraction, any>;
			run: Function;
		},
	) {}
}

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

	constructor(
		public name: string,
		public description: string,
	) {}

	subcommand<O extends Record<string, CommandOption<any, any>>, R extends Res>(
		name: string,
		config: {
			description: string;
			options?: O;
			onError?: (
				err: unknown,
				interaction: ChatInputCommandInteraction,
				ctx: Ctx,
			) => Promise<unknown> | unknown;
			run: (
				interaction: ChatInputCommandInteraction,
				args: InferOptions<O>,
				ctx: Ctx,
			) => CommandResultType<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?: {
			integrationTypes?: IntegrationType[];
			contexts?: InteractionContextType[];
		},
	) {}

	subcommand<O extends Record<string, CommandOption<any, any>>, R extends Res>(
		name: string,
		config: {
			description: string;
			options?: O;
			onError?: (
				err: unknown,
				interaction: ChatInputCommandInteraction,
				ctx: Ctx,
			) => Promise<unknown> | unknown;
			run: (
				interaction: ChatInputCommandInteraction,
				args: InferOptions<O>,
				ctx: Ctx,
			) => CommandResultType<R>;
		},
	): this {
		this.subcommands[name] = new Subcommand(name, config);
		return this;
	}

	group(
		name: string,
		config: { description: string },
		setup: (group: SubcommandGroup<Ctx, Res>) => void,
	): this {
		const group = new SubcommandGroup<Ctx, Res>(name, config.description);
		setup(group);
		this.groups[name] = group;
		return this;
	}
}

export class Command<Ctx = any, Res = unknown> {
	constructor(
		public name: string,
		public config: {
			description: string;
			options?: Record<string, CommandOption<any, any>>;
			integrationTypes?: IntegrationType[];
			contexts?: InteractionContextType[];
			onError?: ErrorHandler<ChatInputCommandInteraction, Ctx>;
			run: (
				interaction: ChatInputCommandInteraction,
				args: any,
				ctx: Ctx,
			) => CommandResultType<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?: {
			integrationTypes?: IntegrationType[];
			contexts?: InteractionContextType[];
			onError?: ErrorHandler<I, Ctx>;
		},
	) {}
}

export class CommandBuilder<Ctx = {}, Res = unknown> {
	constructor(
		private middlewares: Middleware<any, any, any>[] = [],
		private errorHandlers: ErrorHandler<any, any>[] = [],
		private afterwares: Afterware<any, any, Res>[] = [],
	) {}

	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,
		);
	}

	onError(handler: ErrorHandler<BaseInteraction, Ctx>): CommandBuilder<Ctx, Res> {
		return new CommandBuilder<Ctx, Res>(
			this.middlewares,
			[...this.errorHandlers, handler],
			this.afterwares,
		);
	}

	// Refines the Res generic type parameter of the CommandBuilder
	after<NewRes>(handler: Afterware<BaseInteraction, Ctx, NewRes>): CommandBuilder<Ctx, NewRes> {
		return new CommandBuilder<Ctx, NewRes>(this.middlewares, this.errorHandlers, [
			...this.afterwares,
			handler as any,
		]);
	}

	command<O extends Record<string, CommandOption<any, any>>, R extends Res>(
		name: string,
		config: {
			description: string;
			options?: O;
			integrationTypes?: IntegrationType[];
			contexts?: InteractionContextType[];
			onError?: ErrorHandler<ChatInputCommandInteraction, Ctx>;
			run: (
				interaction: ChatInputCommandInteraction,
				args: InferOptions<O>,
				ctx: Ctx,
			) => CommandResultType<R>;
		},
	): Command<Ctx, R>;

	command(
		name: string,
		config: {
			description: string;
			integrationTypes?: IntegrationType[];
			contexts?: InteractionContextType[];
		},
	): 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,
			{
				integrationTypes: config.integrationTypes,
				contexts: config.contexts,
			},
		);
	}

	userContextMenu<R extends Res>(
		name: string,
		runOrConfig:
			| ((interaction: UserContextMenuCommandInteraction, ctx: Ctx) => CommandResultType<R>)
			| {
					integrationTypes?: IntegrationType[];
					contexts?: InteractionContextType[];
					onError?: ErrorHandler<UserContextMenuCommandInteraction, Ctx>;
					run: (interaction: UserContextMenuCommandInteraction, ctx: Ctx) => CommandResultType<R>;
			  },
	): ContextMenuCommand<Ctx, UserContextMenuCommandInteraction, R> {
		if (typeof runOrConfig === "function") {
			return new ContextMenuCommand<Ctx, UserContextMenuCommandInteraction, R>(
				name,
				"user",
				runOrConfig,
				this.middlewares,
				this.errorHandlers,
				this.afterwares,
			);
		}

		return new ContextMenuCommand<Ctx, UserContextMenuCommandInteraction, R>(
			name,
			"user",
			runOrConfig.run,
			this.middlewares,
			this.errorHandlers,
			this.afterwares,
			{
				integrationTypes: runOrConfig.integrationTypes,
				contexts: runOrConfig.contexts,
				onError: runOrConfig.onError,
			},
		);
	}

	messageContextMenu<R extends Res>(
		name: string,
		runOrConfig:
			| ((interaction: MessageContextMenuCommandInteraction, ctx: Ctx) => CommandResultType<R>)
			| {
					integrationTypes?: IntegrationType[];
					contexts?: InteractionContextType[];
					onError?: ErrorHandler<MessageContextMenuCommandInteraction, Ctx>;
					run: (
						interaction: MessageContextMenuCommandInteraction,
						ctx: Ctx,
					) => CommandResultType<R>;
			  },
	): ContextMenuCommand<Ctx, MessageContextMenuCommandInteraction, R> {
		if (typeof runOrConfig === "function") {
			return new ContextMenuCommand<Ctx, MessageContextMenuCommandInteraction, R>(
				name,
				"message",
				runOrConfig,
				this.middlewares,
				this.errorHandlers,
				this.afterwares,
			);
		}

		return new ContextMenuCommand<Ctx, MessageContextMenuCommandInteraction, R>(
			name,
			"message",
			runOrConfig.run,
			this.middlewares,
			this.errorHandlers,
			this.afterwares,
			{
				integrationTypes: runOrConfig.integrationTypes,
				contexts: runOrConfig.contexts,
				onError: runOrConfig.onError,
			},
		);
	}

	button<O extends Record<string, Option<any, any>>, R extends Res>(
		name: string,
		config: {
			options?: O;
			onError?: ErrorHandler<ButtonInteraction, Ctx>;
			run: (
				interaction: ButtonInteraction,
				args: InferOptions<O>,
				ctx: Ctx,
			) => CommandResultType<R>;
		},
	): KittenComponent<ButtonInteraction, O, Ctx, R> {
		return new KittenComponent<ButtonInteraction, O, Ctx, R>(
			name,
			config,
			this.middlewares,
			this.errorHandlers,
			this.afterwares,
		);
	}

	selectMenu<O extends Record<string, Option<any, any>>, R extends Res>(
		name: string,
		config: {
			options?: O;
			onError?: ErrorHandler<AnySelectMenuInteraction, Ctx>;
			run: (
				interaction: AnySelectMenuInteraction,
				args: InferOptions<O>,
				ctx: Ctx,
			) => CommandResultType<R>;
		},
	): KittenComponent<AnySelectMenuInteraction, O, Ctx, R> {
		return new KittenComponent<AnySelectMenuInteraction, O, Ctx, R>(
			name,
			config,
			this.middlewares,
			this.errorHandlers,
			this.afterwares,
		);
	}

	modal<O extends Record<string, Option<any, any>>, R extends Res>(
		name: string,
		config: {
			options?: O;
			onError?: ErrorHandler<ModalSubmitInteraction, Ctx>;
			run: (
				interaction: ModalSubmitInteraction,
				args: InferOptions<O>,
				ctx: Ctx,
			) => CommandResultType<R>;
		},
	): KittenComponent<ModalSubmitInteraction, O, Ctx, R> {
		return new KittenComponent<ModalSubmitInteraction, O, Ctx, R>(
			name,
			config,
			this.middlewares,
			this.errorHandlers,
			this.afterwares,
		);
	}
}