import {
	type Client,
	type ChatInputCommandInteraction,
	type AutocompleteInteraction,
	type ButtonInteraction,
	type AnySelectMenuInteraction,
	type ModalSubmitInteraction,
	type APIApplicationCommandOption,
	type APIApplicationCommandBasicOption,
	type UserContextMenuCommandInteraction,
	type MessageContextMenuCommandInteraction,
	BaseInteraction,
	type RESTPostAPIApplicationCommandsJSONBody,
	ApplicationCommandType,
} from "discord.js";

import { HaltExecution } from "./errors";
import { type Option, type CommandOption, type InferOptions, OPTION_TYPES } from "./options";
import { KittenComponent, type KittenComponentInteraction } from "./components";
import {
	Command,
	CommandBuilder,
	SubcommandGroupBuilder,
	ContextMenuCommand,
	type IntegrationType,
	type InteractionContextType,
	CommandResultType,
} from "./commands";
import { baseLogger, type KittenLogger } from "./logger";

export interface KittenOptions {
	logger?: KittenLogger;
}

export class Kitten {
	private commands = new Map<string, Command | SubcommandGroupBuilder<any>>();
	private userContextMenus = new Map<string, ContextMenuCommand>();
	private messageContextMenus = new Map<string, ContextMenuCommand>();
	private components = new Map<string, KittenComponent<any, any, any>>();
	private logger: KittenLogger;

	constructor(
		private client: Client,
		options: KittenOptions = {},
	) {
		this.client.on("interactionCreate", this.handleInteraction.bind(this));
		this.logger = options.logger ?? baseLogger;
		this.logger.debug("kitten instance initialized.");
	}

	builder() {
		return new CommandBuilder();
	}

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

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

	command(name: string, config: any): any {
		return this.builder().command(name, config);
	}

	userContextMenu(
		name: string,
		runOrConfig:
			| ((interaction: UserContextMenuCommandInteraction) => Promise<any> | any)
			| {
					integrationTypes?: IntegrationType[];
					contexts?: InteractionContextType[];
					run: (interaction: UserContextMenuCommandInteraction) => Promise<any> | any;
			  },
	): ContextMenuCommand {
		return this.builder().userContextMenu(name, runOrConfig as any);
	}

	messageContextMenu(
		name: string,
		runOrConfig:
			| ((interaction: MessageContextMenuCommandInteraction) => Promise<any> | any)
			| {
					integrationTypes?: IntegrationType[];
					contexts?: InteractionContextType[];
					run: (interaction: MessageContextMenuCommandInteraction) => Promise<any> | any;
			  },
	): ContextMenuCommand {
		return this.builder().messageContextMenu(name, runOrConfig as any);
	}

	button<O extends Record<string, Option<any, any>>>(
		name: string,
		config: {
			options?: O;
			run: (interaction: ButtonInteraction, args: InferOptions<O>) => Promise<any> | any;
		},
	): KittenComponent<ButtonInteraction, O, {}> {
		return this.builder().button(name, config);
	}

	selectMenu<O extends Record<string, Option<any, any>>>(
		name: string,
		config: {
			options?: O;
			run: (interaction: AnySelectMenuInteraction, args: InferOptions<O>) => Promise<any> | any;
		},
	): KittenComponent<AnySelectMenuInteraction, O, {}> {
		return this.builder().selectMenu(name, config);
	}

	modal<O extends Record<string, Option<any, any>>>(
		name: string,
		config: {
			options?: O;
			run: (interaction: ModalSubmitInteraction, args: InferOptions<O>) => Promise<any> | any;
		},
	): KittenComponent<ModalSubmitInteraction, O, {}> {
		return this.builder().modal(name, config);
	}

	register(registry: {
		commands?: (Command | SubcommandGroupBuilder<any> | ContextMenuCommand)[];
		components?: KittenComponent<any, any>[];
	}) {
		registry.commands?.forEach((cmd) => {
			if (cmd instanceof ContextMenuCommand) {
				if (cmd.type === "user") {
					this.userContextMenus.set(cmd.name, cmd);
					this.logger.debug(`registered user context menu: "${cmd.name}"`);
				} else if (cmd.type === "message") {
					this.messageContextMenus.set(cmd.name, cmd);
					this.logger.debug(`registered message context menu: "${cmd.name}"`);
				}
			} else {
				this.commands.set(cmd.name, cmd);
				const subInfo = cmd instanceof SubcommandGroupBuilder ? " (subcommand group)" : "";
				this.logger.debug(`registered command: "${cmd.name}"${subInfo}`);
			}
		});
		registry.components?.forEach((comp) => {
			this.components.set(comp.name, comp);
			this.logger.debug(`registered component prefix: "${comp.name}"`);
		});
	}

	private async handleInteraction(interaction: BaseInteraction) {
		this.logger.debug(`received interaction ID: ${interaction.id}, Type: ${interaction.type}`);

		switch (true) {
			// commands
			case interaction.isChatInputCommand():
				return await this.routeCommand(interaction);
			case interaction.isAutocomplete():
				return await this.routeAutocomplete(interaction);
			case interaction.isUserContextMenuCommand():
				return await this.routeContextMenu(interaction, "user");
			case interaction.isMessageContextMenuCommand():
				return await this.routeContextMenu(interaction, "message");

			// components
			case interaction.isButton():
				return await this.routeComponent(interaction);
			case interaction.isAnySelectMenu():
				return await this.routeComponent(interaction);
			case interaction.isModalSubmit():
				return await this.routeComponent(interaction);
			default:
				this.logger.debug(`interaction ID: ${interaction.id} could not be classified or handled.`);
		}
	}

	private async routeCommand(interaction: ChatInputCommandInteraction) {
		const entry = this.commands.get(interaction.commandName);
		if (!entry) {
			this.logger.debug(`command routing aborted: "${interaction.commandName}" is not registered.`);
			return;
		}

		if (entry instanceof SubcommandGroupBuilder) {
			const groupName = interaction.options.getSubcommandGroup(false);
			const subName = interaction.options.getSubcommand(false);

			this.logger.debug(
				`routing group-based command: "${interaction.commandName}", group: ${groupName ?? "none"}, subcommand: ${subName ?? "none"}`,
			);

			if (groupName) {
				const group = entry.groups[groupName];
				if (!group) {
					this.logger.debug(
						`subcommand group "${groupName}" not found under "${interaction.commandName}".`,
					);
					return;
				}
				const subcommand = group.subcommands[subName ?? ""];
				if (!subcommand) {
					this.logger.debug(
						`subcommand "${subName}" not found in group "${groupName}" under "${interaction.commandName}".`,
					);
					return;
				}

				await this.executeWithMiddlewares(
					interaction,
					entry.middlewares,
					subcommand.config.run,
					subcommand.config.options,
				);
			} else if (subName) {
				const subcommand = entry.subcommands[subName];
				if (!subcommand) {
					this.logger.debug(
						`subcommand "${subName}" not found under "${interaction.commandName}".`,
					);
					return;
				}

				await this.executeWithMiddlewares(
					interaction,
					entry.middlewares,
					subcommand.config.run,
					subcommand.config.options,
				);
			}
		} else {
			this.logger.debug(`routing top-level chat command: "${interaction.commandName}"`);
			await this.executeWithMiddlewares(
				interaction,
				entry.middlewares,
				entry.config.run,
				entry.config.options,
			);
		}
	}

	private async routeContextMenu(
		interaction: UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction,
		type: "user" | "message",
	) {
		const entry =
			type === "user"
				? this.userContextMenus.get(interaction.commandName)
				: this.messageContextMenus.get(interaction.commandName);

		if (!entry) {
			this.logger.debug(
				`context menu routing aborted: "${interaction.commandName}" (${type}) is not registered.`,
			);
			return;
		}

		this.logger.debug(`routing context menu command: "${interaction.commandName}" (${type})`);
		await this.executeWithMiddlewares(interaction, entry.middlewares, entry.run);
	}

	private async executeWithMiddlewares(
		interaction: BaseInteraction,
		middlewares: Function[],
		run: Function,
		optionsSchema?: Record<string, Option<any, any>>,
		componentArgs?: Record<string, any>,
	) {
		try {
			let context = {};

			this.logger.debug(
				`Running ${middlewares.length} middleware(s) for interaction ${interaction.id}`,
			);

			for (let i = 0; i < middlewares.length; i++) {
				const mw = middlewares[i];
				if (!mw) continue;
				this.logger.debug(`executing middleware [${i + 1}/${middlewares.length}]`);
				const result = await mw(interaction, context);
				if (result) context = { ...context, ...result };
			}

			if (interaction.isChatInputCommand()) {
				const args = this.parseSlashOptions(interaction, optionsSchema);
				this.logger.debug(`executing command handler for "${interaction.commandName}"`, { args });
				await run(interaction, args, context);
			} else if (
				interaction.isButton() ||
				interaction.isAnySelectMenu() ||
				interaction.isModalSubmit()
			) {
				const customId = (interaction as any).customId;
				this.logger.debug(`executing component handler for custom ID: "${customId}"`, {
					componentArgs,
				});
				await run(interaction, componentArgs ?? {}, context);
			} else {
				this.logger.debug(`executing generic fallback handler for interaction ${interaction.id}`);
				await run(interaction, context);
			}
		} catch (err) {
			if (err instanceof HaltExecution) {
				this.logger.debug(`execution halted intentionally for interaction ${interaction.id}.`);
				if (
					err.replyPayload &&
					interaction.isRepliable() &&
					!interaction.replied &&
					!interaction.deferred
				) {
					const replyOptions =
						typeof err.replyPayload === "string"
							? { content: err.replyPayload, ephemeral: true }
							: err.replyPayload;
					await interaction.reply(replyOptions).catch(() => null);
				}
				return;
			}

			const isCommand = "commandName" in interaction;
			const identifier = isCommand
				? (interaction as any).commandName
				: "customId" in interaction
					? (interaction as any).customId
					: "unknown";
			const typeLabel = isCommand ? "command" : "component";

			this.logger.error(`unhandled error executing ${typeLabel} ${identifier}:`, {
				error: err instanceof Error ? err.stack : String(err),
				[typeLabel]: identifier,
				user: interaction.user.id,
			});

			if (interaction.isRepliable() && !interaction.replied && !interaction.deferred) {
				await interaction
					.reply({
						content: `an error occurred while executing this ${typeLabel}.`,
						ephemeral: true,
					})
					.catch(() => null);
			}
		}
	}

	private async routeAutocomplete(interaction: AutocompleteInteraction) {
		const entry = this.commands.get(interaction.commandName);
		if (!entry) {
			this.logger.debug(
				`autocomplete aborted: command "${interaction.commandName}" not registered.`,
			);
			return;
		}

		const focused = interaction.options.getFocused(true);
		let optionsSchema: Record<string, Option<any, any>> | undefined;

		if (entry instanceof SubcommandGroupBuilder) {
			const groupName = interaction.options.getSubcommandGroup(false);
			const subName = interaction.options.getSubcommand(false);

			if (groupName && subName)
				optionsSchema = entry.groups[groupName]?.subcommands[subName]?.config.options;
			else if (subName) optionsSchema = entry.subcommands[subName]?.config.options;
		} else {
			optionsSchema = entry.config.options;
		}

		const opt = optionsSchema?.[focused.name];
		if (opt?.autocomplete) {
			this.logger.debug(
				`handling autocomplete for command "${interaction.commandName}" option "${focused.name}" with value "${focused.value}"`,
			);
			const choices = await opt.autocomplete(interaction, focused.value);
			await interaction.respond(choices).catch(() => null);
		} else {
			this.logger.debug(
				`no autocomplete handler configured for option "${focused.name}" in command "${interaction.commandName}"`,
			);
		}
	}

	private async routeComponent(interaction: KittenComponentInteraction) {
		const [prefix] = interaction.customId.split(":");
		if (!prefix) {
			this.logger.debug(
				`component routing skipped: unable to extract prefix from customId "${interaction.customId}".`,
			);
			return;
		}

		const component = this.components.get(prefix);
		if (!component) {
			this.logger.debug(
				`component routing skipped: no component handler registered for prefix "${prefix}".`,
			);
			return;
		}

		this.logger.debug(
			`routing component for prefix "${prefix}" (customId:${interaction.customId})`,
		);
		const args = component.parseArgs(interaction.customId);
		await this.executeWithMiddlewares(
			interaction,
			component.middlewares,
			component.config.run,
			undefined,
			args,
		);
	}

	private parseSlashOptions(
		interaction: ChatInputCommandInteraction,
		optionsSchema?: Record<string, Option<any, any>>,
	): Record<string, any> {
		if (!optionsSchema) return {};
		const parsed: Record<string, any> = {};

		this.logger.debug(`parsing options for command "${interaction.commandName}"`);

		for (const [name, opt] of Object.entries(optionsSchema)) {
			switch (opt.type) {
				case "string":
					parsed[name] = interaction.options.getString(name);
					break;
				case "integer":
					parsed[name] = interaction.options.getInteger(name);
					break;
				case "number":
					parsed[name] = interaction.options.getNumber(name);
					break;
				case "boolean":
					parsed[name] = interaction.options.getBoolean(name);
					break;
				case "user":
					parsed[name] = interaction.options.getUser(name);
					break;
				case "channel":
					parsed[name] = interaction.options.getChannel(name);
					break;
				case "role":
					parsed[name] = interaction.options.getRole(name);
					break;
				case "mentionable":
					parsed[name] = interaction.options.getMentionable(name);
					break;
				case "attachment":
					parsed[name] = interaction.options.getAttachment(name);
					break;
				default:
					this.logger.debug(`skipping option "${name}" due to unmapped option type: "${opt.type}"`);
			}
		}
		return parsed;
	}

	async sync({ guildId }: { guildId?: string } = {}) {
		const payloads: RESTPostAPIApplicationCommandsJSONBody[] = [];

		// chat input commands
		for (const cmd of this.commands.values()) {
			if (cmd instanceof SubcommandGroupBuilder) {
				const subcommandOptions: APIApplicationCommandOption[] = Object.values(cmd.subcommands).map(
					(sub) => ({
						type: OPTION_TYPES.subcommand,
						name: sub.name,
						description: sub.config.description,
						options: this.transformOptionsForDiscord(sub.config.options),
					}),
				);

				const groupOptions: APIApplicationCommandOption[] = Object.values(cmd.groups).map(
					(group) => ({
						type: OPTION_TYPES.subcommandGroup,
						name: group.name,
						description: group.description,
						options: Object.values(group.subcommands).map((sub) => ({
							type: OPTION_TYPES.subcommand,
							name: sub.name,
							description: sub.config.description,
							options: this.transformOptionsForDiscord(sub.config.options),
						})),
					}),
				);

				const payload: RESTPostAPIApplicationCommandsJSONBody = {
					type: ApplicationCommandType.ChatInput,
					name: cmd.name,
					description: cmd.description,
					options: [...subcommandOptions, ...groupOptions],
				};

				if (cmd.config?.integrationTypes) payload.integration_types = cmd.config.integrationTypes;
				if (cmd.config?.contexts) payload.contexts = cmd.config.contexts;

				payloads.push(payload);
			} else {
				const payload: RESTPostAPIApplicationCommandsJSONBody = {
					type: ApplicationCommandType.ChatInput,
					name: cmd.name,
					description: cmd.config.description,
					options: this.transformOptionsForDiscord(cmd.config.options),
				};

				if (cmd.config.integrationTypes) payload.integration_types = cmd.config.integrationTypes;
				if (cmd.config.contexts) payload.contexts = cmd.config.contexts;

				payloads.push(payload);
			}
		}

		// context menus
		for (const cmd of this.userContextMenus.values()) {
			const payload: RESTPostAPIApplicationCommandsJSONBody = {
				type: ApplicationCommandType.User,
				name: cmd.name,
			};

			if (cmd.config?.integrationTypes) payload.integration_types = cmd.config.integrationTypes;
			if (cmd.config?.contexts) payload.contexts = cmd.config.contexts;

			payloads.push(payload);
		}

		for (const cmd of this.messageContextMenus.values()) {
			const payload: RESTPostAPIApplicationCommandsJSONBody = {
				type: ApplicationCommandType.Message,
				name: cmd.name,
			};

			if (cmd.config?.integrationTypes) payload.integration_types = cmd.config.integrationTypes;
			if (cmd.config?.contexts) payload.contexts = cmd.config.contexts;

			payloads.push(payload);
		}

		if (!this.client.application) {
			throw new Error("client application not ready to sync. ensure you await client.login()");
		}

		this.logger.debug(`preparing to sync ${payloads.length} command(s) to Discord API...`);

		if (guildId) {
			await this.client.application.commands.set(payloads, guildId);
			this.logger.info(`synced ${payloads.length} commands to guild ${guildId}.`, {
				guildId,
				commandCount: payloads.length,
			});
		} else {
			await this.client.application.commands.set(payloads);
			this.logger.info(`synced ${payloads.length} global commands.`, {
				commandCount: payloads.length,
			});
		}
	}

	private transformOptionsForDiscord(
		options?: Record<string, CommandOption<any, any>>,
	): APIApplicationCommandBasicOption[] {
		if (!options) return [];

		return Object.entries(options).map(([name, opt]) => {
			const payload: any = {
				name,
				description: opt.description,
				type: OPTION_TYPES[opt.type],
				required: opt.required,
			};

			if (opt.autocomplete) {
				payload.autocomplete = true;
			}

			return payload as APIApplicationCommandBasicOption;
		});
	}
}