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 = Promise<unknown> | void;
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;

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 = {}> {
	public subcommands: Record<string, Subcommand> = {};

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

	subcommand<O extends Record<string, CommandOption<any, any>>>(
		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;
		},
	): this {
		this.subcommands[name] = new Subcommand(name, config);
		return this;
	}
}

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

	constructor(
		public name: string,
		public description: string,
		public middlewares: Middleware<any, any, any>[] = [],
		public errorHandlers: ErrorHandler<any, any>[] = [],
		public config?: {
			integrationTypes?: IntegrationType[];
			contexts?: InteractionContextType[];
		},
	) {}

	subcommand<O extends Record<string, CommandOption<any, any>>>(
		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;
		},
	): this {
		this.subcommands[name] = new Subcommand(name, config);
		return this;
	}

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

export class Command<Ctx = any> {
	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;
		},
		public middlewares: Middleware<any, any, any>[] = [],
		public errorHandlers: ErrorHandler<any, any>[] = [],
	) {}
}

export class ContextMenuCommand<
	Ctx = any,
	I extends UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction = any,
> {
	constructor(
		public name: string,
		public type: "user" | "message",
		public run: (interaction: I, ctx: Ctx) => Promise<unknown> | unknown,
		public middlewares: Middleware<any, any, any>[] = [],
		public errorHandlers: ErrorHandler<any, any>[] = [],
		public config?: {
			integrationTypes?: IntegrationType[];
			contexts?: InteractionContextType[];
			onError?: ErrorHandler<I, Ctx>;
		},
	) {}
}

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

	use<NewCtx extends Record<string, any>>(
		mw: (interaction: BaseInteraction, ctx: Ctx) => Promise<NewCtx | void> | NewCtx | void,
	): CommandBuilder<Ctx & NewCtx> {
		return new CommandBuilder<Ctx & NewCtx>([...this.middlewares, mw], this.errorHandlers);
	}

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

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

	command(
		name: string,
		config: {
			description: string;
			integrationTypes?: IntegrationType[];
			contexts?: InteractionContextType[];
		},
	): SubcommandGroupBuilder<Ctx>;

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

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

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

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

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

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

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

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